@funnelfox/billing 0.8.0-ffb-395.9 → 0.8.0-ffb-395.12

package/dist/chunk-index.cjs.js

@@ -532,6 +532,7 @@ const API_ENDPOINTS = {
     RESUME_PAYMENT: '/v1/checkout/resume_payment',
     ONE_CLICK: '/v1/checkout/one_click',
     CREATE_SIMPLE_CLIENT_SESSION: '/v1/checkout/create_simple_client_session',
+    RECALCULATE_TAX: '/v1/checkout/recalculate_tax',
 };
 const ERROR_CODES = {
     SDK_ERROR: 'SDK_ERROR',
@@ -1169,11 +1170,35 @@ class APIClient {
         if (params.postalCode !== undefined) {
             payload.postal_code = params.postalCode;
         }
+        if (params.subdivision !== undefined) {
+            payload.subdivision = params.subdivision;
+        }
+        if (params.taxCalculationId !== undefined) {
+            payload.tax_calculation_id = params.taxCalculationId;
+        }
         return (await this.request(API_ENDPOINTS.CREATE_PAYMENT, {
             method: 'POST',
             body: JSON.stringify(payload),
         }));
     }
+    async recalculateTax(params) {
+        const payload = {
+            order_id: params.orderId,
+            client_token: params.clientToken,
+            country_code: params.countryCode,
+        };
+        if (params.postalCode) {
+            payload.postal_code = params.postalCode;
+        }
+        if (params.subdivision) {
+            payload.subdivision = params.subdivision;
+        }
+        const raw = (await this.request(API_ENDPOINTS.RECALCULATE_TAX, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        }));
+        return raw.data;
+    }
     async resumePayment(params) {
         const payload = {
             order_id: params.orderId,
@@ -1753,6 +1778,7 @@ function getPageUrl() {
 /**
  * @fileoverview Checkout instance manager for Funnefox SDK
  */
+const TAX_RECALC_DEBOUNCE_MS = 600;
 class CheckoutInstance extends EventEmitter {
     constructor(config) {
         super();
@@ -1788,11 +1814,71 @@ class CheckoutInstance extends EventEmitter {
                 if (!this.isPostalCodeVisible()) {
                     this.cardPostalCode = undefined;
                 }
-                return;
             }
-            if (inputName === 'postalCode') {
+            else if (inputName === 'postalCode') {
                 this.cardPostalCode = value?.trim() || undefined;
             }
+            if (this.isTaxEnabled()) {
+                this.scheduleTaxRecalc();
+            }
+        };
+        // Tax is driven by the tenant's tax_calculation_provider setting (surfaced as session.tax_enabled).
+        // enableTax stays as a legacy host override only when the backend doesn't report the flag.
+        this.isTaxEnabled = () => this.cachedSessionResponse?.data?.tax_enabled ??
+            this.checkoutConfig.enableTax ??
+            false;
+        this.emitSessionTaxEstimate = () => {
+            const data = this.cachedSessionResponse?.data;
+            if (!data || data.amount_total == null) {
+                return;
+            }
+            this.checkoutConfig.onTaxChange?.({
+                amountTotal: data.amount_total,
+                taxAmount: data.tax_amount ?? 0,
+                currency: data.currency ?? '',
+            });
+        };
+        this.runTaxRecalc = async () => {
+            const orderId = this.orderId;
+            const countryCode = this.getSelectedCountryCode();
+            if (!orderId || !countryCode) {
+                return;
+            }
+            try {
+                const tax = await this.apiClient.recalculateTax({
+                    orderId,
+                    clientToken: this.cachedSessionResponse?.data?.client_token ?? '',
+                    countryCode,
+                    postalCode: this.cardPostalCode,
+                });
+                this.checkoutConfig.onTaxChange?.({
+                    amountTotal: tax.amount_total,
+                    taxAmount: tax.tax_amount,
+                    currency: tax.currency,
+                });
+            }
+            catch (err) {
+                // Recalc failed for the new address; surface it instead of silently showing a stale total.
+                console.warn('[funnelfox-billing] tax recalculation failed', err);
+                this.checkoutConfig.onTaxError?.(err);
+            }
+        };
+        this.scheduleTaxRecalc = () => {
+            if (this.taxRecalcDebounce) {
+                clearTimeout(this.taxRecalcDebounce);
+            }
+            this.taxRecalcDebounce = setTimeout(this.runTaxRecalc, TAX_RECALC_DEBOUNCE_MS);
+        };
+        // Flush a pending recalc so a card charge reflects the final entered address (no estimate drift).
+        // Used for card payments only; wallets authorize their own amount and are left untouched.
+        this.flushTaxRecalc = async () => {
+            if (this.taxRecalcDebounce) {
+                clearTimeout(this.taxRecalcDebounce);
+                this.taxRecalcDebounce = undefined;
+            }
+            if (this.isTaxEnabled()) {
+                await this.runTaxRecalc();
+            }
         };
         this.handleMethodRender = (method) => {
             this.emit(EVENTS.METHOD_RENDER, method);
@@ -1812,6 +1898,11 @@ class CheckoutInstance extends EventEmitter {
             try {
                 this.onLoaderChangeWithRace(true);
                 this._setState('processing');
+                // Card charge must reflect the final entered address; wallets authorize their own amount, so
+                // only flush the pending recalc for card payments.
+                if (this.activePaymentMethodType === exports.PaymentMethod.PAYMENT_CARD) {
+                    await this.flushTaxRecalc();
+                }
                 const [radarSessionId, airwallexDeviceId] = await Promise.all([
                     this.cachedSessionResponse?.radarSessionId,
                     this.cachedSessionResponse?.airwallexDeviceId,
@@ -1929,6 +2020,9 @@ class CheckoutInstance extends EventEmitter {
             await this.createSession();
             await this._initializePrimerCheckout();
             this._setState('ready');
+            if (this.isTaxEnabled()) {
+                this.emitSessionTaxEstimate();
+            }
             this.startUnhandledTelemetry();
             this.checkoutConfig?.onInitialized?.();
             return this;
@@ -2203,6 +2297,7 @@ class CheckoutInstance extends EventEmitter {
                 wasPaymentProcessedStarted = true;
             },
             onTokenizeShouldStart: data => {
+                this.activePaymentMethodType = data.paymentMethodType;
                 this.emit(EVENTS.ERROR, undefined);
                 this.emit(EVENTS.START_PURCHASE, data.paymentMethodType);
                 return true;
@@ -2242,6 +2337,9 @@ class CheckoutInstance extends EventEmitter {
             await this.primerWrapper.refreshClientSession();
             this.onLoaderChangeWithRace(false);
             this._setState('ready');
+            if (this.isTaxEnabled()) {
+                this.scheduleTaxRecalc();
+            }
         }
         catch (error) {
             this.onLoaderChangeWithRace(false);

package/dist/chunk-index.es.js

@@ -530,6 +530,7 @@ const API_ENDPOINTS = {
     RESUME_PAYMENT: '/v1/checkout/resume_payment',
     ONE_CLICK: '/v1/checkout/one_click',
     CREATE_SIMPLE_CLIENT_SESSION: '/v1/checkout/create_simple_client_session',
+    RECALCULATE_TAX: '/v1/checkout/recalculate_tax',
 };
 const ERROR_CODES = {
     SDK_ERROR: 'SDK_ERROR',
@@ -1167,11 +1168,35 @@ class APIClient {
         if (params.postalCode !== undefined) {
             payload.postal_code = params.postalCode;
         }
+        if (params.subdivision !== undefined) {
+            payload.subdivision = params.subdivision;
+        }
+        if (params.taxCalculationId !== undefined) {
+            payload.tax_calculation_id = params.taxCalculationId;
+        }
         return (await this.request(API_ENDPOINTS.CREATE_PAYMENT, {
             method: 'POST',
             body: JSON.stringify(payload),
         }));
     }
+    async recalculateTax(params) {
+        const payload = {
+            order_id: params.orderId,
+            client_token: params.clientToken,
+            country_code: params.countryCode,
+        };
+        if (params.postalCode) {
+            payload.postal_code = params.postalCode;
+        }
+        if (params.subdivision) {
+            payload.subdivision = params.subdivision;
+        }
+        const raw = (await this.request(API_ENDPOINTS.RECALCULATE_TAX, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        }));
+        return raw.data;
+    }
     async resumePayment(params) {
         const payload = {
             order_id: params.orderId,
@@ -1751,6 +1776,7 @@ function getPageUrl() {
 /**
  * @fileoverview Checkout instance manager for Funnefox SDK
  */
+const TAX_RECALC_DEBOUNCE_MS = 600;
 class CheckoutInstance extends EventEmitter {
     constructor(config) {
         super();
@@ -1786,11 +1812,71 @@ class CheckoutInstance extends EventEmitter {
                 if (!this.isPostalCodeVisible()) {
                     this.cardPostalCode = undefined;
                 }
-                return;
             }
-            if (inputName === 'postalCode') {
+            else if (inputName === 'postalCode') {
                 this.cardPostalCode = value?.trim() || undefined;
             }
+            if (this.isTaxEnabled()) {
+                this.scheduleTaxRecalc();
+            }
+        };
+        // Tax is driven by the tenant's tax_calculation_provider setting (surfaced as session.tax_enabled).
+        // enableTax stays as a legacy host override only when the backend doesn't report the flag.
+        this.isTaxEnabled = () => this.cachedSessionResponse?.data?.tax_enabled ??
+            this.checkoutConfig.enableTax ??
+            false;
+        this.emitSessionTaxEstimate = () => {
+            const data = this.cachedSessionResponse?.data;
+            if (!data || data.amount_total == null) {
+                return;
+            }
+            this.checkoutConfig.onTaxChange?.({
+                amountTotal: data.amount_total,
+                taxAmount: data.tax_amount ?? 0,
+                currency: data.currency ?? '',
+            });
+        };
+        this.runTaxRecalc = async () => {
+            const orderId = this.orderId;
+            const countryCode = this.getSelectedCountryCode();
+            if (!orderId || !countryCode) {
+                return;
+            }
+            try {
+                const tax = await this.apiClient.recalculateTax({
+                    orderId,
+                    clientToken: this.cachedSessionResponse?.data?.client_token ?? '',
+                    countryCode,
+                    postalCode: this.cardPostalCode,
+                });
+                this.checkoutConfig.onTaxChange?.({
+                    amountTotal: tax.amount_total,
+                    taxAmount: tax.tax_amount,
+                    currency: tax.currency,
+                });
+            }
+            catch (err) {
+                // Recalc failed for the new address; surface it instead of silently showing a stale total.
+                console.warn('[funnelfox-billing] tax recalculation failed', err);
+                this.checkoutConfig.onTaxError?.(err);
+            }
+        };
+        this.scheduleTaxRecalc = () => {
+            if (this.taxRecalcDebounce) {
+                clearTimeout(this.taxRecalcDebounce);
+            }
+            this.taxRecalcDebounce = setTimeout(this.runTaxRecalc, TAX_RECALC_DEBOUNCE_MS);
+        };
+        // Flush a pending recalc so a card charge reflects the final entered address (no estimate drift).
+        // Used for card payments only; wallets authorize their own amount and are left untouched.
+        this.flushTaxRecalc = async () => {
+            if (this.taxRecalcDebounce) {
+                clearTimeout(this.taxRecalcDebounce);
+                this.taxRecalcDebounce = undefined;
+            }
+            if (this.isTaxEnabled()) {
+                await this.runTaxRecalc();
+            }
         };
         this.handleMethodRender = (method) => {
             this.emit(EVENTS.METHOD_RENDER, method);
@@ -1810,6 +1896,11 @@ class CheckoutInstance extends EventEmitter {
             try {
                 this.onLoaderChangeWithRace(true);
                 this._setState('processing');
+                // Card charge must reflect the final entered address; wallets authorize their own amount, so
+                // only flush the pending recalc for card payments.
+                if (this.activePaymentMethodType === PaymentMethod.PAYMENT_CARD) {
+                    await this.flushTaxRecalc();
+                }
                 const [radarSessionId, airwallexDeviceId] = await Promise.all([
                     this.cachedSessionResponse?.radarSessionId,
                     this.cachedSessionResponse?.airwallexDeviceId,
@@ -1927,6 +2018,9 @@ class CheckoutInstance extends EventEmitter {
             await this.createSession();
             await this._initializePrimerCheckout();
             this._setState('ready');
+            if (this.isTaxEnabled()) {
+                this.emitSessionTaxEstimate();
+            }
             this.startUnhandledTelemetry();
             this.checkoutConfig?.onInitialized?.();
             return this;
@@ -2201,6 +2295,7 @@ class CheckoutInstance extends EventEmitter {
                 wasPaymentProcessedStarted = true;
             },
             onTokenizeShouldStart: data => {
+                this.activePaymentMethodType = data.paymentMethodType;
                 this.emit(EVENTS.ERROR, undefined);
                 this.emit(EVENTS.START_PURCHASE, data.paymentMethodType);
                 return true;
@@ -2240,6 +2335,9 @@ class CheckoutInstance extends EventEmitter {
             await this.primerWrapper.refreshClientSession();
             this.onLoaderChangeWithRace(false);
             this._setState('ready');
+            if (this.isTaxEnabled()) {
+                this.scheduleTaxRecalc();
+            }
         }
         catch (error) {
             this.onLoaderChangeWithRace(false);

package/dist/chunk-stripe-card-form.cjs.js

@@ -10,11 +10,16 @@
 var stripeLoader = require('./chunk-stripe-loader.cjs.js');
 require('./chunk-index.cjs.js');
 
+const TAX_RECALC_DEBOUNCE_MS = 600;
 async function mountStripeCardForm(element, session, params) {
     const { stripe_public_key, amount, currency, order_id, is_link_enabled } = session.data;
+    // Tax flow is driven by the tenant setting (session.tax_enabled); enableTax is a legacy override.
+    const taxEnabled = session.data.tax_enabled ?? params.enableTax ?? false;
     const stripe = await stripeLoader.getStripe(stripe_public_key);
     if (!stripe)
         throw new Error('Failed to load Stripe');
+    // Remounting (e.g. picking another price) must replace the form, not stack a second one.
+    element.replaceChildren();
     const stripeElements = stripe.elements({
         mode: 'subscription',
         amount,
@@ -31,7 +36,81 @@ async function mountStripeCardForm(element, session, params) {
         },
         terms: { card: 'never' },
     });
-    paymentElement.mount(element);
+    // Tax mode mounts Stripe's Address Element (its change events are readable, so tax recalculates live
+    // as the buyer edits the address) above the Payment Element. The country is pre-filled from the
+    // detected location so tax is computed from the address (not a separate IP estimate); the resulting
+    // calculation id is attached to the PaymentIntent at payment time so Stripe records the tax.
+    let taxCalculationId;
+    let taxAddress = {};
+    // Flushed on submit so the charge always reflects the final entered address (no estimate drift).
+    let flushTaxRecalc = async () => { };
+    if (taxEnabled) {
+        const addressContainer = document.createElement('div');
+        const paymentContainer = document.createElement('div');
+        element.appendChild(addressContainer);
+        element.appendChild(paymentContainer);
+        const addressElement = stripeElements.create('address', {
+            mode: 'billing',
+            fields: { phone: 'never' },
+            ...(session.data.detected_country_code
+                ? {
+                    defaultValues: {
+                        address: { country: session.data.detected_country_code },
+                    },
+                }
+                : {}),
+        });
+        addressElement.mount(addressContainer);
+        paymentElement.mount(paymentContainer);
+        const runRecalc = async () => {
+            const country = taxAddress.country;
+            if (!country)
+                return;
+            try {
+                const tax = await params.apiClient.recalculateTax({
+                    orderId: order_id,
+                    clientToken: session.data.client_token,
+                    countryCode: country,
+                    postalCode: taxAddress.postalCode,
+                    subdivision: taxAddress.state,
+                });
+                taxCalculationId = tax.tax_calculation_id;
+                stripeElements.update({ amount: tax.amount_total });
+                params.onTaxChange?.({
+                    amountTotal: tax.amount_total,
+                    taxAmount: tax.tax_amount,
+                    currency: tax.currency,
+                });
+            }
+            catch {
+                // Best-effort: keep the current total if recalculation fails.
+            }
+        };
+        let debounce;
+        flushTaxRecalc = async () => {
+            if (debounce) {
+                clearTimeout(debounce);
+                debounce = undefined;
+            }
+            await runRecalc();
+        };
+        addressElement.on('change', event => {
+            const address = event.value.address;
+            taxAddress = {
+                country: address.country,
+                postalCode: address.postal_code || undefined,
+                state: address.state || undefined,
+            };
+            if (!taxAddress.country)
+                return;
+            if (debounce)
+                clearTimeout(debounce);
+            debounce = setTimeout(runRecalc, TAX_RECALC_DEBOUNCE_MS);
+        });
+    }
+    else {
+        paymentElement.mount(element);
+    }
     await new Promise((resolve, reject) => {
         paymentElement.once('ready', () => resolve());
         // 'loaderror' is a valid Stripe event but not yet in the @stripe/stripe-js types
@@ -42,6 +121,7 @@ async function mountStripeCardForm(element, session, params) {
         submit: async () => {
             params.onLoaderChange?.(true);
             try {
+                await flushTaxRecalc();
                 const { error: submitError } = await stripeElements.submit();
                 if (submitError)
                     throw submitError;
@@ -54,7 +134,10 @@ async function mountStripeCardForm(element, session, params) {
                     orderId: order_id,
                     paymentMethodToken: paymentMethod.id,
                     email: params.email,
-                    countryCode: params.countryCode,
+                    countryCode: taxEnabled ? taxAddress.country : params.countryCode,
+                    postalCode: taxEnabled ? taxAddress.postalCode : undefined,
+                    subdivision: taxEnabled ? taxAddress.state : undefined,
+                    taxCalculationId: taxEnabled ? taxCalculationId : undefined,
                     clientMetadata: params.clientMetadata,
                 });
                 const result = params.apiClient.processPaymentResponse(raw);

package/dist/chunk-stripe-card-form.es.js

@@ -8,11 +8,16 @@
 import { g as getStripe } from './chunk-stripe-loader.es.js';
 import './chunk-index.es.js';
 
+const TAX_RECALC_DEBOUNCE_MS = 600;
 async function mountStripeCardForm(element, session, params) {
     const { stripe_public_key, amount, currency, order_id, is_link_enabled } = session.data;
+    // Tax flow is driven by the tenant setting (session.tax_enabled); enableTax is a legacy override.
+    const taxEnabled = session.data.tax_enabled ?? params.enableTax ?? false;
     const stripe = await getStripe(stripe_public_key);
     if (!stripe)
         throw new Error('Failed to load Stripe');
+    // Remounting (e.g. picking another price) must replace the form, not stack a second one.
+    element.replaceChildren();
     const stripeElements = stripe.elements({
         mode: 'subscription',
         amount,
@@ -29,7 +34,81 @@ async function mountStripeCardForm(element, session, params) {
         },
         terms: { card: 'never' },
     });
-    paymentElement.mount(element);
+    // Tax mode mounts Stripe's Address Element (its change events are readable, so tax recalculates live
+    // as the buyer edits the address) above the Payment Element. The country is pre-filled from the
+    // detected location so tax is computed from the address (not a separate IP estimate); the resulting
+    // calculation id is attached to the PaymentIntent at payment time so Stripe records the tax.
+    let taxCalculationId;
+    let taxAddress = {};
+    // Flushed on submit so the charge always reflects the final entered address (no estimate drift).
+    let flushTaxRecalc = async () => { };
+    if (taxEnabled) {
+        const addressContainer = document.createElement('div');
+        const paymentContainer = document.createElement('div');
+        element.appendChild(addressContainer);
+        element.appendChild(paymentContainer);
+        const addressElement = stripeElements.create('address', {
+            mode: 'billing',
+            fields: { phone: 'never' },
+            ...(session.data.detected_country_code
+                ? {
+                    defaultValues: {
+                        address: { country: session.data.detected_country_code },
+                    },
+                }
+                : {}),
+        });
+        addressElement.mount(addressContainer);
+        paymentElement.mount(paymentContainer);
+        const runRecalc = async () => {
+            const country = taxAddress.country;
+            if (!country)
+                return;
+            try {
+                const tax = await params.apiClient.recalculateTax({
+                    orderId: order_id,
+                    clientToken: session.data.client_token,
+                    countryCode: country,
+                    postalCode: taxAddress.postalCode,
+                    subdivision: taxAddress.state,
+                });
+                taxCalculationId = tax.tax_calculation_id;
+                stripeElements.update({ amount: tax.amount_total });
+                params.onTaxChange?.({
+                    amountTotal: tax.amount_total,
+                    taxAmount: tax.tax_amount,
+                    currency: tax.currency,
+                });
+            }
+            catch {
+                // Best-effort: keep the current total if recalculation fails.
+            }
+        };
+        let debounce;
+        flushTaxRecalc = async () => {
+            if (debounce) {
+                clearTimeout(debounce);
+                debounce = undefined;
+            }
+            await runRecalc();
+        };
+        addressElement.on('change', event => {
+            const address = event.value.address;
+            taxAddress = {
+                country: address.country,
+                postalCode: address.postal_code || undefined,
+                state: address.state || undefined,
+            };
+            if (!taxAddress.country)
+                return;
+            if (debounce)
+                clearTimeout(debounce);
+            debounce = setTimeout(runRecalc, TAX_RECALC_DEBOUNCE_MS);
+        });
+    }
+    else {
+        paymentElement.mount(element);
+    }
     await new Promise((resolve, reject) => {
         paymentElement.once('ready', () => resolve());
         // 'loaderror' is a valid Stripe event but not yet in the @stripe/stripe-js types
@@ -40,6 +119,7 @@ async function mountStripeCardForm(element, session, params) {
         submit: async () => {
             params.onLoaderChange?.(true);
             try {
+                await flushTaxRecalc();
                 const { error: submitError } = await stripeElements.submit();
                 if (submitError)
                     throw submitError;
@@ -52,7 +132,10 @@ async function mountStripeCardForm(element, session, params) {
                     orderId: order_id,
                     paymentMethodToken: paymentMethod.id,
                     email: params.email,
-                    countryCode: params.countryCode,
+                    countryCode: taxEnabled ? taxAddress.country : params.countryCode,
+                    postalCode: taxEnabled ? taxAddress.postalCode : undefined,
+                    subdivision: taxEnabled ? taxAddress.state : undefined,
+                    taxCalculationId: taxEnabled ? taxCalculationId : undefined,
                     clientMetadata: params.clientMetadata,
                 });
                 const result = params.apiClient.processPaymentResponse(raw);

package/dist/chunk-stripe-wallet.cjs.js

@@ -30,13 +30,24 @@ function buildPaymentRequest(stripe, data, totalLabel) {
     const applePay = raw
         ? { recurringPaymentRequest: raw }
         : undefined;
+    const base = data.amount;
+    const tax = data.tax_amount ?? 0;
+    const total = data.amount_total ?? base;
     return stripe.paymentRequest({
         country: data.country,
         currency: data.currency,
         total: {
             label: totalLabel?.trim() || 'Total',
-            amount: data.amount,
+            amount: total,
         },
+        // Detected-country tax. The wallet sheet amount is fixed at open (not recomputed from the address
+        // picked in the sheet), so this line is the final charged tax, shown plainly as "Tax".
+        displayItems: tax > 0
+            ? [
+                { label: 'Subtotal', amount: base },
+                { label: 'Tax', amount: tax },
+            ]
+            : undefined,
         requestPayerName: false,
         requestPayerEmail: false,
         applePay,
@@ -59,6 +70,7 @@ async function getAvailableWallet(session) {
 }
 async function purchaseWallet(session, params) {
     const { stripe_public_key, order_id } = session.data;
+    const taxEnabled = session.data.tax_enabled ?? false;
     const stripe = await stripeLoader.getStripe(stripe_public_key);
     if (!stripe)
         throw new Error('Failed to load Stripe');
@@ -70,11 +82,28 @@ async function purchaseWallet(session, params) {
         paymentRequest.on('paymentmethod', async (event) => {
             params.onLoaderChange?.(true);
             try {
+                // Tax on: charge stays the detected-country estimate (the amount the sheet authorized, via
+                // tax_calculation_id); commit the finalized tax from the card's real billing address, which
+                // Stripe only exposes on the payment method after authorization. Tax off: send only the
+                // caller-provided country, exactly as before the tax flow existed.
+                const billingAddress = taxEnabled
+                    ? event.paymentMethod.billing_details.address
+                    : undefined;
                 const raw = await params.apiClient.createPayment({
                     orderId: order_id,
                     paymentMethodToken: event.paymentMethod.id,
                     email: params.email,
-                    countryCode: params.countryCode,
+                    countryCode: taxEnabled
+                        ? billingAddress?.country ||
+                            session.data.detected_country_code ||
+                            params.countryCode
+                        : params.countryCode,
+                    postalCode: taxEnabled
+                        ? billingAddress?.postal_code || undefined
+                        : undefined,
+                    taxCalculationId: taxEnabled
+                        ? session.data.tax_calculation_id
+                        : undefined,
                     clientMetadata: params.clientMetadata,
                 });
                 const result = params.apiClient.processPaymentResponse(raw);