Expense rules - Tax rate does not update when expense rule is applied

[lanitochka17]

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!

---

Version Number: 9.3.11-17
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: #80915
Email or phone of affected tester (no customers): sdjoidsjosdijoisno@gmail.com
Issue reported by: Applause Internal Team
Bug source: Exploratory - Significant User Experience Deterioration
Device used: Mac 26.1 / Chrome
App Component: Money Requests

Action Performed:

Precondition:

• Workspace taxes are enabled.

1. Go to staging.new.expensify.com
2. Go to Account > Expense rules.
3. Click New rule.
4. Create a rule where Tax will change to 5% rate when Merchant is Apple.
5. Click Save.
6. Go to workspace chat.
7. Create an expense with Apple as merchant.
8. Open the expense report.

Expected Result:

Tax rate will change to 5% as per expense rule.

Actual Result:

Tax rate still remains as 0% and does not change to 5%.

Workaround:

Unknown

Platforms:

• Android: App
• Android: mWeb Chrome
• iOS: App
• iOS: mWeb Safari
• iOS: mWeb Chrome
• Windows: Chrome
• MacOS: Chrome / Safari

Screenshots/Videos

Bug7063086_1769885770964.24.mp4

View all open jobs on GitHub

Issue Owner

Current Issue Owner: @QichenZhu

[melvin-bot]

Triggered auto assignment to @sonialiap (Bug), see https://stackoverflow.com/c/expensify/questions/14418 for more details. Please add this bug to a GH project, as outlined in the SO.

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @QichenZhu (External)

[MobileMage]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a user creates a personal expense rule (under Account > Expense rules) that sets a specific tax rate when the merchant matches a value (e.g., "when merchant is Apple, update tax to 5%"), the tax rate is not applied to expenses created with that merchant. The tax remains at the default rate (0%) instead of changing to the rule-specified rate (5%).

What is the root cause of that problem?

The root cause is that the frontend never applies personal expense rules when the merchant is set on a transaction draft. When the user enters a merchant name on the expense creation flow, setMoneyRequestMerchant is called, which simply writes the merchant to the Onyx draft transaction without checking personal expense rules for a match.

App/src/libs/actions/IOU/index.ts

Lines 1322 to 1324 in 9618ba6

	function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
	Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
	}

Compare this with setMoneyRequestCategory, which already applies workspace-level category tax rules when the category is set on a draft transaction. After setting the category, it calls getCategoryTaxCodeAndAmount to find the matching workspace expense rule and applies the corresponding tax code and amount to the transaction draft.

App/src/libs/actions/IOU/index.ts

Lines 1353 to 1369 in 9618ba6

	function setMoneyRequestCategory(transactionID: string, category: string, policy: OnyxEntry<OnyxTypes.Policy>, isMovingFromTrackExpense?: boolean) {
	Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`, {category});
	if (isMovingFromTrackExpense) {
	return;
	}
	if (!policy) {
	setMoneyRequestTaxRate(transactionID, '');
	setMoneyRequestTaxAmount(transactionID, null);
	return;
	}
	const transaction = allTransactionDrafts[`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`];
	const {categoryTaxCode, categoryTaxAmount} = getCategoryTaxCodeAndAmount(category, transaction, policy);
	if (categoryTaxCode && categoryTaxAmount !== undefined) {
	setMoneyRequestTaxRate(transactionID, categoryTaxCode);
	setMoneyRequestTaxAmount(transactionID, categoryTaxAmount);
	}
	}

Because setMoneyRequestMerchant does not perform an analogous check against personal expense rules (stored in NVP_EXPENSE_RULES), the transaction draft's taxCode and taxAmount are never updated. When the confirm page reads the tax from the draft, it sees the default tax code and sends that to the backend.

App/src/pages/iou/request/step/IOURequestStepConfirmation.tsx

Lines 265 to 267 in 9618ba6

	const defaultTaxCode = getDefaultTaxCode(policy, transaction);
	const transactionTaxCode = (transaction?.taxCode ? transaction?.taxCode : defaultTaxCode) ?? '';
	const transactionTaxAmount = transaction?.taxAmount ?? 0;

The personal expense rules data is available in Onyx under ONYXKEYS.NVP_EXPENSE_RULES and contains the merchantToMatch field plus the tax field with field_id_TAX.externalID (the tax code) and field_id_TAX.value (the tax percentage), but no code in the expense creation flow ever reads or applies this data.

App/src/types/onyx/ExpenseRule.ts

Lines 1 to 56 in 9618ba6

	/** Model of tax rate on a personal rule */
	type PersonalRuleTaxRate = {
	/** The tax ID */
	externalID: string;
	/** The tax rate */
	value: string;
	};
	/** Model of tax rate on a policy rule */
	type PolicyRuleTaxRate = {
	/** The tax ID */
	externalID: string;
	/** The tax rate */
	value: string;
	/** The name of the tax rate */
	name: string;
	};
	/** Model of expense rule */
	type ExpenseRule = {
	/** Whether the transaction is set to be billable */
	billable?: 'true' | 'false';
	/** The category set by the rule */
	category?: string;
	/** The description set by the rule */
	comment?: string;
	/** Whether to create report if necessary */
	createReport?: boolean;
	/** The merchant set by the rule */
	merchant?: string;
	/** Merchant name to match to apply the rule */
	merchantToMatch: string;
	/** Whether the transaction is set to be reimbursable */
	reimbursable?: 'true' | 'false';
	/** Name of the report to add transactions to */
	report?: string;
	/** The tag set by the rule */
	tag?: string;
	/** The tax rate set by the rule */
	tax?: Record<string, PersonalRuleTaxRate>;
	};
	export type {PersonalRuleTaxRate, PolicyRuleTaxRate};
	export default ExpenseRule;

What changes do you think we should make in order to solve the problem?

Following the same pattern used by setMoneyRequestCategory for workspace category tax rules, we should enhance setMoneyRequestMerchant to also check personal expense rules and apply the matched rule's tax rate to the transaction draft. The approach is to add an Onyx connection for NVP_EXPENSE_RULES in the IOU index file (alongside the existing connections for transactions, policies, etc.), then extend setMoneyRequestMerchant to match the incoming merchant against the personal expense rules and update the tax fields.

Specifically, in src/libs/actions/IOU/index.ts, add a new Onyx connection to subscribe to personal expense rules near the existing connections (around lines 960-970):

let personalExpenseRules: OnyxEntry<OnyxTypes.ExpenseRule[]> = null;
Onyx.connect({
    key: ONYXKEYS.NVP_EXPENSE_RULES,
    callback: (value) => {
        personalExpenseRules = value ?? null;
    },
});

Then add a helper function to find a matching personal expense rule's tax code based on merchant name, and compute the corresponding tax amount using the existing getTaxValue, calculateTaxAmount, and convertToBackendAmount utilities already used in getCategoryTaxCodeAndAmount:

function getPersonalRuleTaxCodeAndAmount(merchant: string, transactionID: string, policy: OnyxEntry<OnyxTypes.Policy>) {
    if (!personalExpenseRules || !merchant || !policy) {
        return {ruleTaxCode: undefined, ruleTaxAmount: undefined};
    }
    const matchingRule = personalExpenseRules.find(
        (rule) => rule.tax?.field_id_TAX?.externalID && rule.merchantToMatch && merchant.toLowerCase().includes(rule.merchantToMatch.toLowerCase()),
    );
    if (!matchingRule?.tax?.field_id_TAX?.externalID) {
        return {ruleTaxCode: undefined, ruleTaxAmount: undefined};
    }
    const ruleTaxCode = matchingRule.tax.field_id_TAX.externalID;
    const transaction = allTransactionDrafts[`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`];
    const ruleTaxPercentage = getTaxValue(policy, transaction, ruleTaxCode);
    let ruleTaxAmount;
    if (ruleTaxPercentage) {
        ruleTaxAmount = convertToBackendAmount(calculateTaxAmount(ruleTaxPercentage, getAmount(transaction), getCurrency(transaction)));
    }
    return {ruleTaxCode, ruleTaxAmount};
}

Finally, update setMoneyRequestMerchant to accept an optional policy parameter and apply the matched rule's tax (only when setting a draft, matching the category pattern):

function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean, policy?: OnyxEntry<OnyxTypes.Policy>) {
    Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
    if (isDraft && policy) {
        const {ruleTaxCode, ruleTaxAmount} = getPersonalRuleTaxCodeAndAmount(merchant, transactionID, policy);
        if (ruleTaxCode && ruleTaxAmount !== undefined) {
            setMoneyRequestTaxRate(transactionID, ruleTaxCode);
            setMoneyRequestTaxAmount(transactionID, ruleTaxAmount);
        }
    }
}

The callers in IOURequestStepMerchant.tsx already have access to the policy and can pass it through. The existing call at line 125 would become setMoneyRequestMerchant(transactionID, newMerchant || CONST.TRANSACTION.PARTIAL_TRANSACTION_MERCHANT, !isEditing, policy). Other callers that don't have or need personal rule matching (like distance merchant setting in MoneyRequest.ts) simply omit the optional policy parameter and behavior remains unchanged.

What alternative solutions did you explore? (Optional)

N/A

[annaweber830]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a user creates an Expense Rule (Account → Expense rules) that sets a tax rate based on the merchant (e.g., “Apple → 5% tax”), that tax rate is not applied to new expenses with that merchant. The expense continues to show the default tax (0%) instead of the rule-defined tax.

What is the root cause of that problem?

Personal expense rules are stored in Onyx (ONYXKEYS.NVP_EXPENSE_RULES) (e.g. RulePageBase.tsx reads them here:

App/src/pages/settings/Rules/RulePageBase.tsx

Lines 76 to 80 in 7697759

	function RulePageBase({titleKey, testID, hash}: RulePageBaseProps) {
	const {translate} = useLocalize();
	const [expenseRules = getEmptyArray<ExpenseRule>()] = useOnyx(ONYXKEYS.NVP_EXPENSE_RULES, {canBeMissing: true});
	const [form] = useOnyx(ONYXKEYS.FORMS.EXPENSE_RULE_FORM, {canBeMissing: true});
	// Cannot use useRef because react compiler fails

), but the money request draft flow never reads/applies them when the merchant is set.

Specifically, the merchant step calls setMoneyRequestMerchant(...) (

App/src/pages/iou/request/step/IOURequestStepMerchant.tsx

Lines 120 to 126 in 7697759

	if (newMerchant === merchant || (newMerchant === '' && merchant === CONST.TRANSACTION.PARTIAL_TRANSACTION_MERCHANT)) {
	setIsSaved(true);
	shouldNavigateAfterSaveRef.current = true;
	return;
	}
	setMoneyRequestMerchant(transactionID, newMerchant || CONST.TRANSACTION.PARTIAL_TRANSACTION_MERCHANT, !isEditing);
	if (isEditing) {

), and that action only writes the merchant string to the draft transaction and does not attempt to match rules or update taxCode / taxAmount:

App/src/libs/actions/IOU/index.ts

Lines 1320 to 1322 in 7697759

	function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
	Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
	}

Because the draft never gets a rule-driven taxCode, the confirmation screen falls back to the default tax code/value (resulting in 0%):

App/src/pages/iou/request/step/IOURequestStepConfirmation.tsx

Lines 265 to 267 in 7697759

	const defaultTaxCode = getDefaultTaxCode(policy, transaction);
	const transactionTaxCode = (transaction?.taxCode ? transaction?.taxCode : defaultTaxCode) ?? '';
	const transactionTaxAmount = transaction?.taxAmount ?? 0;

What changes do you think we should make in order to solve the problem?

Apply personal (Account-level) expense rules during merchant updates for draft transactions, similar to how workspace category tax rules are applied when setting category (see getCategoryTaxCodeAndAmount usage in setMoneyRequestCategory:

App/src/libs/actions/IOU/index.ts

Lines 1351 to 1367 in 7697759

	function setMoneyRequestCategory(transactionID: string, category: string, policy: OnyxEntry<OnyxTypes.Policy>, isMovingFromTrackExpense?: boolean) {
	Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`, {category});
	if (isMovingFromTrackExpense) {
	return;
	}
	if (!policy) {
	setMoneyRequestTaxRate(transactionID, '');
	setMoneyRequestTaxAmount(transactionID, null);
	return;
	}
	const transaction = allTransactionDrafts[`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`];
	const {categoryTaxCode, categoryTaxAmount} = getCategoryTaxCodeAndAmount(category, transaction, policy);
	if (categoryTaxCode && categoryTaxAmount !== undefined) {
	setMoneyRequestTaxRate(transactionID, categoryTaxCode);
	setMoneyRequestTaxAmount(transactionID, categoryTaxAmount);
	}
	}

and the helper itself:

App/src/libs/TransactionUtils/index.ts

Lines 2559 to 2575 in 7697759

	function getCategoryTaxCodeAndAmount(category: string, transaction: OnyxEntry<Transaction>, policy: OnyxEntry<Policy>) {
	const taxRules = policy?.rules?.expenseRules?.filter((rule) => rule.tax);
	if (!taxRules || taxRules?.length === 0 || isDistanceRequest(transaction)) {
	return {categoryTaxCode: undefined, categoryTaxAmount: undefined};
	}
	const defaultTaxCode = getDefaultTaxCode(policy, transaction, getCurrency(transaction));
	const categoryTaxCode = getCategoryDefaultTaxRate(taxRules, category, defaultTaxCode);
	const categoryTaxPercentage = getTaxValue(policy, transaction, categoryTaxCode ?? '');
	let categoryTaxAmount;
	if (categoryTaxPercentage) {
	categoryTaxAmount = convertToBackendAmount(calculateTaxAmount(categoryTaxPercentage, getAmount(transaction), getCurrency(transaction)));
	}
	return {categoryTaxCode, categoryTaxAmount};
	}

).

Concretely:

1. Subscribe to personal expense rules in src/libs/actions/IOU/index.ts (near the other non-UI subscriptions, e.g. around

   App/src/libs/actions/IOU/index.ts

   Lines 963 to 974 in 7697759

   	// Use connectWithoutView because this is created for non-UI task only
   	let recentAttendees: OnyxEntry<Attendee[]>;
   	Onyx.connectWithoutView({
   	key: ONYXKEYS.NVP_RECENT_ATTENDEES,
   	callback: (value) => (recentAttendees = value),
   	});
   	let deprecatedRecentWaypoints: OnyxTypes.RecentWaypoint[] = [];
   	Onyx.connect({
   	key: ONYXKEYS.NVP_RECENT_WAYPOINTS,
   	callback: (val) => (deprecatedRecentWaypoints = val ?? []),
   	});

   ), storing them in a module-level personalExpenseRules variable.
2. Update setMoneyRequestMerchant(...) so that when isDraft === true it:
   • finds a matching personal rule where merchant.toLowerCase().includes(rule.merchantToMatch.toLowerCase())
   • if the rule has a tax (rule.tax.field_id_TAX.externalID + rule.tax.field_id_TAX.value), sets taxCode and recalculates taxAmount for the current draft transaction amount/currency.
3. Add any missing imports in IOU/index.ts needed to calculate the tax amount (e.g., calculateTaxAmount from @libs/TransactionUtils and convertToBackendAmount from @libs/CurrencyUtils).

Change site:

App/src/libs/actions/IOU/index.ts

Lines 1320 to 1322 in 7697759

	function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
	Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
	}

function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
    Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});

    if (!isDraft) {
        return;
    }

    const transaction = allTransactionDrafts[`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`];
    if (!transaction || isDistanceRequestTransactionUtils(transaction)) {
        return;
    }

    const matchingRule = personalExpenseRules?.find(
        (rule) => !!rule?.merchantToMatch && merchant.toLowerCase().includes(rule.merchantToMatch.toLowerCase()) && !!rule?.tax?.field_id_TAX?.externalID,
    );
    const taxCode = matchingRule?.tax?.field_id_TAX?.externalID;
    const taxPercentage = matchingRule?.tax?.field_id_TAX?.value;

    if (!taxCode || !taxPercentage) {
        return;
    }

    const taxAmount = convertToBackendAmount(calculateTaxAmount(taxPercentage, getAmount(transaction), getCurrency(transaction)));
    setMoneyRequestTaxRate(transactionID, taxCode);
    setMoneyRequestTaxAmount(transactionID, taxAmount);
}

This ensures that when a user sets the merchant on an expense draft, any matching personal Expense Rule will immediately update the draft’s taxCode/taxAmount, and the confirmation step will display the correct (rule-driven) tax rate instead of falling back to the default.

What alternative solutions did you explore? (Optional)

• Passing expenseRules down from UI (via useOnyx(ONYXKEYS.NVP_EXPENSE_RULES)) into setMoneyRequestMerchant(...) to keep the action more “pure”, but this would require a broader signature change across call sites. Subscribing once inside IOU/index.ts matches existing patterns in that file and keeps the change localized.

[github-actions]

⚠️ @annaweber830 Your proposal is a duplicate of an already existing proposal and has been automatically withdrawn to prevent spam. Please review the existing proposals before submitting a new one.

[twinkle-react]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When creating an expense whose merchant matches a personal expense rule, the expense shows the policy-default tax instead of the rule tax because the displayed tax rate is derived from transaction.taxCode (falling back to the policy default when needed). App/src/components/ReportActionItem/MoneyRequestView.tsx:313, App/src/libs/TransactionUtils/index.ts:2164-2175

What is the root cause of that problem?

In App/src/components/MoneyRequestConfirmationList.tsx, the “Update the tax code when the default changes” useEffect unconditionally assumes the draft transaction taxCode is always safe to replace with defaultTaxCode, but this is wrong because taxCode can already be correctly set earlier by rules, and overwriting it directly causes the wrong value to be stored by setMoneyRequestTaxRate(...) inside that effect. App/src/components/MoneyRequestConfirmationList.tsx:375-384, App/src/libs/actions/IOU/index.ts:11521-11523

// App/src/components/MoneyRequestConfirmationList.tsx:375-384
useEffect(() => {
    if (!transactionID || isReadOnly || !shouldShowTax || isMovingTransactionFromTrackExpense) {
        return;
    }
    setMoneyRequestTaxRate(transactionID, defaultTaxCode);
    // trigger this useEffect also when policyID changes - the defaultTaxCode may stay the same
}, [defaultTaxCode, isMovingTransactionFromTrackExpense, isReadOnly, transactionID, policyID, shouldShowTax]);

What changes do you think we should make in order to solve the problem?

Update the effect in MoneyRequestConfirmationList.tsx (lines 375-384) so it does not overwrite transaction.taxCode when it is already set. Apply defaultTaxCode only when the draft has no taxCode. Optionally, also apply it when the current taxCode is invalid or out of policy, aligned with the existing blocking validation. This should be done in MoneyRequestConfirmationList.tsx (lines 375-384) and consider the checks around MoneyRequestConfirmationList.tsx (lines 1007-1010). Personal expense rules already set taxCode and taxAmount on draft merchant changes in setMoneyRequestMerchant(), so the confirmation screen must keep that value instead of replacing it with the policy default. index.ts (lines 1373-1399)

// Pseudocode
const currentTaxCode = transaction?.taxCode ?? '';
if (!currentTaxCode) {
    setMoneyRequestTaxRate(transactionID, defaultTaxCode);
}

What alternative solutions did you explore? (Optional)

None.

[marufsharifi]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a workspace expense rule sets a tax rate based on merchant (e.g., “Apple → 5%”), creating an expense with that merchant does not update the tax rate. The tax remains at 0% instead of applying the rule.

What is the root cause of that problem?

The app applies merchant-based tax rules using policy.rules.codingRules, but expense rules created in Account > Expense rules are stored in Onyx under nvp_expensify_expenseRules, not in the policy object. Because the code never looks at nvp_expensify_expenseRules, the rule is never matched when the merchant is set, so tax stays unchanged.

What changes do you think we should make in order to solve the problem?

• Cache ONYXKEYS.NVP_EXPENSE_RULES in TransactionUtils, similar to existing Onyx caches.
• Add a merchant‑matching helper for nvp_expensify_expenseRules using normalized, case‑insensitive “contains” matching on merchantToMatch.
• Implement precedence: if the transaction is tied to a workspace policy and a workspace coding rule matches, use the workspace rule; otherwise fall back to the account‑level expense rule.
• When a rule matches, compute taxAmount from rule.tax.field_id_TAX.value and set both taxCode and taxAmount.
• Reuse the existing merchant‑change flows (setMoneyRequestMerchant and update params) so the tax is applied for both drafts and saved expenses.

--- a/src/libs/TransactionUtils/index.ts
+++ b/src/libs/TransactionUtils/index.ts
@@ -21,6 +21,7 @@ import Log from '@libs/Log';
 import {rand64, roundToTwoDecimalPlaces} from '@libs/NumberUtils';
 import Permissions from '@libs/Permissions';
 import {getLoginsByAccountIDs, getPersonalDetailsByIDs} from '@libs/PersonalDetailsUtils';
+import StringUtils from '@libs/StringUtils';
 import {
     getCommaSeparatedTagNameWithSanitizedColons,
     getDistanceRateCustomUnit,
@@ -69,6 +70,8 @@ import type {
     TransactionViolations,
     ViolationName,
 } from '@src/types/onyx';
+import type ExpenseRule from '@src/types/onyx/ExpenseRule';
+import type {CodingRule} from '@src/types/onyx/Policy';
 import type {Attendee, Participant, SplitExpense} from '@src/types/onyx/IOU';
 import type {Errors, PendingAction} from '@src/types/onyx/OnyxCommon';
 import type {CurrentUserPersonalDetails} from '@src/types/onyx/PersonalDetails';
@@ -151,6 +154,12 @@ Onyx.connect({
     },
 });
 
+let allExpenseRules: OnyxEntry<ExpenseRule[]>;
+Onyx.connectWithoutView({
+    key: ONYXKEYS.NVP_EXPENSE_RULES,
+    callback: (value) => (allExpenseRules = value),
+});
+
 /**
  * @deprecated This function uses Onyx.connect and should be replaced with useOnyx for reactive data access.
  * TODO: remove `getPolicyTagsData` from this file (https://github.com/Expensify/App/issues/72719)
@@ -2574,6 +2583,109 @@ function getCategoryTaxCodeAndAmount(category: string, transaction: OnyxEntry<Tr
     return {categoryTaxCode, categoryTaxAmount};
 }
 
+function getMatchingCodingRuleForMerchant(merchant: string, policy: OnyxEntry<Policy>): CodingRule | undefined {
+    const codingRules = policy?.rules?.codingRules;
+    if (!codingRules) {
+        return;
+    }
+
+    const normalizedMerchant = StringUtils.normalize(merchant).toLowerCase();
+    if (!normalizedMerchant) {
+        return;
+    }
+
+    const sortedRules = Object.values(codingRules)
+        .filter((rule): rule is CodingRule => !!rule)
+        .sort((ruleA, ruleB) => {
+            if (ruleA.created && ruleB.created) {
+                return ruleA.created < ruleB.created ? 1 : -1;
+            }
+            return 0;
+        });
+
+    for (const rule of sortedRules) {
+        const filters = rule.filters;
+        if (!filters || filters.left !== 'merchant') {
+            continue;
+        }
+
+        const normalizedRight = StringUtils.normalize(filters.right ?? '').toLowerCase();
+        if (!normalizedRight) {
+            continue;
+        }
+
+        const operator = filters.operator ?? CONST.SEARCH.SYNTAX_OPERATORS.CONTAINS;
+        if (operator === CONST.SEARCH.SYNTAX_OPERATORS.EQUAL_TO) {
+            if (normalizedMerchant === normalizedRight) {
+                return rule;
+            }
+            continue;
+        }
+
+        if (operator === CONST.SEARCH.SYNTAX_OPERATORS.CONTAINS && normalizedMerchant.includes(normalizedRight)) {
+            return rule;
+        }
+    }
+}
+
+function getMatchingExpenseRuleForMerchant(merchant: string): ExpenseRule | undefined {
+    if (!allExpenseRules?.length) {
+        return;
+    }
+
+    const normalizedMerchant = StringUtils.normalize(merchant).toLowerCase();
+    if (!normalizedMerchant) {
+        return;
+    }
+
+    return allExpenseRules.find((rule) => {
+        const normalizedMatch = StringUtils.normalize(rule.merchantToMatch ?? '').toLowerCase();
+        return normalizedMatch ? normalizedMerchant.includes(normalizedMatch) : false;
+    });
+}
+
+function getExpenseRuleTaxCodeAndAmount(merchant: string, transaction: OnyxEntry<Transaction>) {
+    if (!merchant || isDistanceRequest(transaction)) {
+        return {expenseRuleTaxCode: undefined, expenseRuleTaxAmount: undefined};
+    }
+
+    const expenseRule = getMatchingExpenseRuleForMerchant(merchant);
+    const expenseRuleTaxCode = expenseRule?.tax?.field_id_TAX?.externalID;
+    const expenseRuleTaxValue = expenseRule?.tax?.field_id_TAX?.value;
+    if (!expenseRuleTaxCode || !expenseRuleTaxValue) {
+        return {expenseRuleTaxCode: undefined, expenseRuleTaxAmount: undefined};
+    }
+
+    const expenseRuleTaxAmount = convertToBackendAmount(calculateTaxAmount(expenseRuleTaxValue, getAmount(transaction), getCurrency(transaction)));
+    return {expenseRuleTaxCode, expenseRuleTaxAmount};
+}
+
+function getCodingRuleTaxCodeAndAmount(merchant: string, transaction: OnyxEntry<Transaction>, policy: OnyxEntry<Policy>) {
+    if (!merchant || isDistanceRequest(transaction)) {
+        return {codingRuleTaxCode: undefined, codingRuleTaxAmount: undefined};
+    }
+
+    const isWorkspacePolicy = policy?.type && policy.type !== CONST.POLICY.TYPE.PERSONAL;
+    if (isWorkspacePolicy && policy?.rules?.codingRules) {
+        const codingRule = getMatchingCodingRuleForMerchant(merchant, policy);
+        const codingRuleTaxCode = codingRule?.tax?.field_id_TAX?.externalID;
+        if (codingRuleTaxCode) {
+            const codingRuleTaxPercentage = getTaxValue(policy, transaction, codingRuleTaxCode);
+            if (codingRuleTaxPercentage) {
+                return {
+                    codingRuleTaxCode,
+                    codingRuleTaxAmount: convertToBackendAmount(
+                        calculateTaxAmount(codingRuleTaxPercentage, getAmount(transaction), getCurrency(transaction)),
+                    ),
+                };
+            }
+        }
+    }
+
+    const {expenseRuleTaxCode, expenseRuleTaxAmount} = getExpenseRuleTaxCodeAndAmount(merchant, transaction);
+    return {codingRuleTaxCode: expenseRuleTaxCode, codingRuleTaxAmount: expenseRuleTaxAmount};
+}
+
 /**
  * Return the sorted list transactions of an iou report
  */
@@ -2830,6 +2942,7 @@ export {
     getAllSortedTransactions,
     getFormattedPostedDate,
     getCategoryTaxCodeAndAmount,
+    getCodingRuleTaxCodeAndAmount,
     isPerDiemRequest,
     isViolationDismissed,
     isBrokenConnectionViolation,
~
~

--- a/src/libs/actions/IOU/index.ts
+++ b/src/libs/actions/IOU/index.ts
@@ -198,6 +198,7 @@ import {
     buildOptimisticTransaction,
     getAmount,
     getCategoryTaxCodeAndAmount,
+    getCodingRuleTaxCodeAndAmount,
     getChildTransactions,
     getClearedPendingFields,
     getCurrency,
@@ -1320,7 +1321,16 @@ function setMoneyRequestDescription(transactionID: string, comment: string, isDr
 }
 
 function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
-    Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
+    const transactionKey = `${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`;
+    const transaction = isDraft ? allTransactionDrafts?.[transactionKey] : allTransactions?.[transactionKey];
+    const report = transaction?.reportID ? allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${transaction.reportID}`] : undefined;
+    const policy = getPolicy(report?.policyID);
+    const {codingRuleTaxCode, codingRuleTaxAmount} = getCodingRuleTaxCodeAndAmount(merchant, transaction, policy);
+
+    Onyx.merge(transactionKey, {
+        merchant,
+        ...(codingRuleTaxCode && codingRuleTaxAmount !== undefined ? {taxCode: codingRuleTaxCode, taxAmount: codingRuleTaxAmount} : {}),
+    });
 }
 
 function setMoneyRequestAttendees(transactionID: string, attendees: Attendee[], isDraft: boolean) {
@@ -4178,7 +4188,7 @@ function getUpdateMoneyRequestParams(params: GetUpdateMoneyRequestParamsType): U
     const {
         transactionID,
         transactionThreadReport,
-        transactionChanges,
+        transactionChanges: baseTransactionChanges,
         policy,
         policyTagList,
         policyRecentlyUsedTags,
@@ -4196,6 +4206,7 @@ function getUpdateMoneyRequestParams(params: GetUpdateMoneyRequestParamsType): U
         policyRecentlyUsedCurrencies,
         iouReportNextStep,
     } = params;
+    const transactionChanges: TransactionChanges = {...baseTransactionChanges};
     const optimisticData: OnyxUpdate[] = [];
     const successData: Array<
         OnyxUpdate<typeof ONYXKEYS.COLLECTION.TRANSACTION_DRAFT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.TRANSACTION>
@@ -4211,14 +4222,26 @@ function getUpdateMoneyRequestParams(params: GetUpdateMoneyRequestParamsType): U
         >
     > = [];
 
-    // Step 1: Set any "pending fields" (ones updated while the user was offline) to have error messages in the failureData
+    // Step 1: Get all the collections being updated
+    const transaction = allTransactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`];
+    if (
+        Object.hasOwn(transactionChanges, 'merchant') &&
+        typeof transactionChanges.merchant === 'string' &&
+        !Object.hasOwn(transactionChanges, 'taxCode') &&
+        !Object.hasOwn(transactionChanges, 'taxAmount')
+    ) {
+        const {codingRuleTaxCode, codingRuleTaxAmount} = getCodingRuleTaxCodeAndAmount(transactionChanges.merchant, transaction, policy);
+        if (codingRuleTaxCode && codingRuleTaxAmount !== undefined) {
+            transactionChanges.taxCode = codingRuleTaxCode;
+            transactionChanges.taxAmount = codingRuleTaxAmount;
+        }
+    }
+
+    // Step 2: Set any "pending fields" (ones updated while the user was offline) to have error messages in the failureData
     const pendingFields: OnyxTypes.Transaction['pendingFields'] = Object.fromEntries(Object.keys(transactionChanges).map((key) => [key, CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE]));
     const clearedPendingFields = getClearedPendingFields(transactionChanges);
     const errorFields = Object.fromEntries(Object.keys(pendingFields).map((key) => [key, getMicroSecondOnyxErrorWithTranslationKey('iou.error.genericEditFailureMessage')]));
 
-    // Step 2: Get all the collections being updated
-    const transaction = allTransactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`];
-
     const isTransactionOnHold = isOnHold(transaction);
     const isFromExpenseReport = isExpenseReport(iouReport);
     const updatedTransaction: OnyxEntry<OnyxTypes.Transaction> = transaction
@@ -4750,6 +4773,20 @@ function getUpdateTrackExpenseParams(
     const successData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.TRANSACTION_DRAFT | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.TRANSACTION>> = [];
     const failureData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.TRANSACTION | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.REPORT>> = [];
 
+    const transaction = allTransactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`];
+    if (
+        Object.hasOwn(transactionChanges, 'merchant') &&
+        typeof transactionChanges.merchant === 'string' &&
+        !Object.hasOwn(transactionChanges, 'taxCode') &&
+        !Object.hasOwn(transactionChanges, 'taxAmount')
+    ) {
+        const {codingRuleTaxCode, codingRuleTaxAmount} = getCodingRuleTaxCodeAndAmount(transactionChanges.merchant, transaction, policy);
+        if (codingRuleTaxCode && codingRuleTaxAmount !== undefined) {
+            transactionChanges.taxCode = codingRuleTaxCode;
+            transactionChanges.taxAmount = codingRuleTaxAmount;
+        }
+    }
+
     // Step 1: Set any "pending fields" (ones updated while the user was offline) to have error messages in the failureData
     const pendingFields = Object.fromEntries(Object.keys(transactionChanges).map((key) => [key, CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE]));
     const clearedPendingFields = getClearedPendingFields(transactionChanges);
@@ -4757,7 +4794,6 @@ function getUpdateTrackExpenseParams(
 
     // Step 2: Get all the collections being updated
     const transactionThread = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${transactionThreadReportID}`] ?? null;
-    const transaction = allTransactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`];
     const chatReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${transactionThread?.parentReportID}`] ?? null;
     const updatedTransaction = transaction
         ? getUpdatedTransaction({

What alternative solutions did you explore? (Optional)

Reminder: Please use plain English, be brief and avoid jargon. Feel free to use images, charts or pseudo-code if necessary. Do not post large multi-line diffs or write walls of text. Do not create PRs unless you have been hired for this job.

[github-actions]

⚠️ @marufsharifi Your proposal is a duplicate of an already existing proposal and has been automatically withdrawn to prevent spam. Please review the existing proposals before submitting a new one.