@adtrackify/at-service-common 5.1.2 → 5.1.4

package/dist/esm/__tests__/services/cost/cost-calculator-service.spec.js

@@ -1,8 +1,7 @@
-import { describe, it, expect, vi } from 'vitest';
 import { ORDER_COST_ENTRY_TYPE, SHIPPING_METHOD, SHIPPING_RATE_TYPE, WEIGHT_UNIT, COST_FILTER_MODE, } from '@adtrackify/at-tracking-event-types';
 import { CostCalculatorService } from '../../../services/cost/cost-calculator-service';
-vi.mock('../../../helpers/logging-helper', () => ({
-    Logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+jest.mock('../../../helpers/logging-helper', () => ({
+    Logger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
 }));
 const emptyRatesMap = {};
 const createLineItem = (overrides = {}) => ({
@@ -241,9 +240,7 @@ describe('CostCalculatorService', () => {
         it('should return 0 when no matching gateway', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'paypal', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'paypal', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
             expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
@@ -251,20 +248,16 @@ describe('CostCalculatorService', () => {
         it('should calculate flat + percent for matching gateway', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
             const result = CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
-            expect(result).toBeCloseTo(3.2);
+            expect(result).toBeCloseTo(3.20);
         });
         it('should be case-insensitive for gateway name', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'Stripe', flatAmount: 1, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'Stripe', flatAmount: 1, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
             expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(1);
@@ -272,17 +265,10 @@ describe('CostCalculatorService', () => {
         it('should respect date range', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        {
-                            gatewayName: 'stripe',
-                            flatAmount: 1,
-                            percentRate: 0,
-                            currency: 'USD',
-                            effectiveFrom: '2025-01-01T00:00:00Z',
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                    entries: [{
+                            gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'USD',
+                            effectiveFrom: '2025-01-01T00:00:00Z', createdAt: '', updatedAt: '',
+                        }],
                 },
             });
             expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
@@ -290,9 +276,7 @@ describe('CostCalculatorService', () => {
         it('should convert flat amount from entry currency', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'EUR', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'EUR', createdAt: '', updatedAt: '' }],
                 },
             });
             const rates = { EUR: { USD: 1.1 } };
@@ -303,28 +287,21 @@ describe('CostCalculatorService', () => {
             const configs = createConfigs({
                 gateway: {
                     entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                        { gatewayName: 'stripe', flatAmount: 0.5, percentRate: 3.5, currency: 'USD', createdAt: '', updatedAt: '' },
+                        { gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
+                        { gatewayName: 'stripe', flatAmount: 0.50, percentRate: 3.5, currency: 'USD', createdAt: '', updatedAt: '' },
                     ],
                 },
             });
             const result = CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
-            expect(result).toBeCloseTo(3.2);
+            expect(result).toBeCloseTo(3.20);
         });
         it('should respect effectiveTo date on gateway entry', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        {
-                            gatewayName: 'stripe',
-                            flatAmount: 1,
-                            percentRate: 0,
-                            currency: 'USD',
-                            effectiveTo: '2024-01-01T00:00:00Z',
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                    entries: [{
+                            gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'USD',
+                            effectiveTo: '2024-01-01T00:00:00Z', createdAt: '', updatedAt: '',
+                        }],
                 },
             });
             expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
@@ -332,13 +309,11 @@ describe('CostCalculatorService', () => {
         it('should match gateway when order has multiple gateways', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'paypal', flatAmount: 0.5, percentRate: 3.0, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'paypal', flatAmount: 0.50, percentRate: 3.0, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
             const result = CostCalculatorService.calculateGatewayCost(configs, ['stripe', 'paypal'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
-            expect(result).toBeCloseTo(3.5);
+            expect(result).toBeCloseTo(3.50);
         });
     });
     describe('calculateShippingCost', () => {
@@ -350,7 +325,7 @@ describe('CostCalculatorService', () => {
             const configs = createConfigs({
                 shipping: { method: SHIPPING_METHOD.SHOPIFY_CHARGES, currency: 'USD' },
             });
-            expect(CostCalculatorService.calculateShippingCost(configs, 15.5, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(15.5);
+            expect(CostCalculatorService.calculateShippingCost(configs, 15.50, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(15.50);
         });
         it('should return fixed rate for FIXED_RATE method', () => {
             const configs = createConfigs({
@@ -373,26 +348,14 @@ describe('CostCalculatorService', () => {
                     currency: 'USD',
                     profiles: [
                         {
-                            id: 'p1',
-                            name: 'US Profile',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 5,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p1', name: 'US Profile', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                         {
-                            id: 'p2',
-                            name: 'Default',
-                            countries: [],
-                            isDefault: true,
-                            rateType: SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 15,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 15, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                     ],
                 },
@@ -406,26 +369,14 @@ describe('CostCalculatorService', () => {
                     currency: 'USD',
                     profiles: [
                         {
-                            id: 'p1',
-                            name: 'US Profile',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 5,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p1', name: 'US Profile', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                         {
-                            id: 'p2',
-                            name: 'Default',
-                            countries: [],
-                            isDefault: true,
-                            rateType: SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 15,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 15, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                     ],
                 },
@@ -437,23 +388,16 @@ describe('CostCalculatorService', () => {
                 shipping: {
                     method: SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
-                    profiles: [
-                        {
-                            id: 'p1',
-                            name: 'Weight',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: SHIPPING_RATE_TYPE.WEIGHT_TIERED,
-                            currency: 'USD',
+                    profiles: [{
+                            id: 'p1', name: 'Weight', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.WEIGHT_TIERED, currency: 'USD',
                             weightUnit: WEIGHT_UNIT.GRAMS,
                             weightTiers: [
                                 { weightMin: 0, weightMax: 500, flatAmount: 5 },
                                 { weightMin: 501, weightMax: null, flatAmount: 10 },
                             ],
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                            createdAt: '', updatedAt: '',
+                        }],
                 },
             });
             expect(CostCalculatorService.calculateShippingCost(configs, 0, 'US', 300, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(5);
@@ -464,19 +408,11 @@ describe('CostCalculatorService', () => {
                 shipping: {
                     method: SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
-                    profiles: [
-                        {
-                            id: 'p1',
-                            name: 'US Only',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 5,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                    profiles: [{
+                            id: 'p1', name: 'US Only', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        }],
                 },
             });
             expect(CostCalculatorService.calculateShippingCost(configs, 0, 'CA', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
@@ -488,27 +424,15 @@ describe('CostCalculatorService', () => {
                     currency: 'USD',
                     profiles: [
                         {
-                            id: 'p1',
-                            name: 'US Expired',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 5,
-                            currency: 'USD',
+                            id: 'p1', name: 'US Expired', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
                             effectiveTo: '2024-01-01T00:00:00Z',
-                            createdAt: '',
-                            updatedAt: '',
+                            createdAt: '', updatedAt: '',
                         },
                         {
-                            id: 'p2',
-                            name: 'Default',
-                            countries: [],
-                            isDefault: true,
-                            rateType: SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 12,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 12, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                     ],
                 },
@@ -520,23 +444,16 @@ describe('CostCalculatorService', () => {
                 shipping: {
                     method: SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'EUR',
-                    profiles: [
-                        {
-                            id: 'p1',
-                            name: 'EU Weight',
-                            countries: ['DE'],
-                            isDefault: false,
-                            rateType: SHIPPING_RATE_TYPE.WEIGHT_TIERED,
-                            currency: 'EUR',
+                    profiles: [{
+                            id: 'p1', name: 'EU Weight', countries: ['DE'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.WEIGHT_TIERED, currency: 'EUR',
                             weightUnit: WEIGHT_UNIT.GRAMS,
                             weightTiers: [
                                 { weightMin: 0, weightMax: 500, flatAmount: 5 },
                                 { weightMin: 501, weightMax: null, flatAmount: 10 },
                             ],
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                            createdAt: '', updatedAt: '',
+                        }],
                 },
             });
             const rates = { EUR: { USD: 1.1 } };
@@ -547,19 +464,11 @@ describe('CostCalculatorService', () => {
                 shipping: {
                     method: SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
-                    profiles: [
-                        {
-                            id: 'p1',
-                            name: 'US',
-                            countries: ['us'],
-                            isDefault: false,
-                            rateType: SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 7,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                    profiles: [{
+                            id: 'p1', name: 'US', countries: ['us'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 7, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        }],
                 },
             });
             expect(CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(7);
@@ -658,7 +567,7 @@ describe('CostCalculatorService', () => {
         });
         it('should calculate BY_ORDER_WEIGHT with flat amount and KILOGRAMS unit (converts weight before multiplying)', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
-                flatAmount: 0.5,
+                flatAmount: 0.50,
                 weightUnit: WEIGHT_UNIT.KILOGRAMS,
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap);
@@ -667,7 +576,7 @@ describe('CostCalculatorService', () => {
         });
         it('should calculate BY_ORDER_WEIGHT with flat amount and POUNDS unit (converts weight before multiplying)', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
-                flatAmount: 2.0,
+                flatAmount: 2.00,
                 weightUnit: WEIGHT_UNIT.POUNDS,
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 453.592 }), initLineItemCosts(), 'USD', emptyRatesMap);
@@ -675,7 +584,7 @@ describe('CostCalculatorService', () => {
             expect(result.lineItemLevel).toBe(0);
         });
         it('should calculate BY_LINE_ITEM_QUANTITY with flat amount as line-item-level cost', () => {
-            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, { flatAmount: 0.5 });
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, { flatAmount: 0.50 });
             const liCosts = initLineItemCosts();
             const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 10 })] }), liCosts, 'USD', emptyRatesMap);
             expect(result.orderLevel).toBe(0);
@@ -722,7 +631,7 @@ describe('CostCalculatorService', () => {
             expect(liCosts['2'].totalLineItemOtherCost).toBe(2);
         });
         it('should calculate BY_ORDER_QUANTITY with flat amount as order-level cost', () => {
-            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 0.5 });
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 0.50 });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap);
             expect(result.orderLevel).toBe(5);
             expect(result.lineItemLevel).toBe(0);
@@ -752,7 +661,9 @@ describe('CostCalculatorService', () => {
         });
         it('should return 0 for BY_ORDER_QUANTITY when quantity does not match any tier', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
-                quantityIntervals: [{ quantityMin: 5, quantityMax: 10, flatAmount: 3 }],
+                quantityIntervals: [
+                    { quantityMin: 5, quantityMax: 10, flatAmount: 3 },
+                ],
             });
             expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 2 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
@@ -780,16 +691,8 @@ describe('CostCalculatorService', () => {
             };
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 4,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 6,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 4, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                    createLineItem({ lineItemId: '2', quantity: 6, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' } }),
                 ],
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
@@ -822,8 +725,7 @@ describe('CostCalculatorService', () => {
                 totalQuantity: 10,
                 orderFilterContext: { tags: ['retail'], paymentGateways: [], shippingTitles: [] },
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should calculate PER_REFUND_ORDER when hasRefund as order-level cost', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, { flatAmount: 5 });
@@ -952,9 +854,7 @@ describe('CostCalculatorService', () => {
                 flatAmount: 5,
                 filters: { countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] } },
             });
-            const context = createContext({
-                orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' },
-            });
+            const context = createContext({ orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' } });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap);
             expect(result.orderLevel).toBe(0);
         });
@@ -972,8 +872,7 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply PER_ORDER when product filter matches a line item', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -983,8 +882,7 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
         it('should apply PER_ORDER when at least one of multiple line items matches product filter', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -993,14 +891,8 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike' },
-                    }),
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
+                    createLineItem({ lineItemId: '2', filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike' } }),
                 ],
             });
             const liCosts = {
@@ -1018,8 +910,7 @@ describe('CostCalculatorService', () => {
                 totalWeight: 500,
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: ['lightweight'] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply BY_ORDER_WEIGHT when productTags filter matches a line item', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
@@ -1030,8 +921,7 @@ describe('CostCalculatorService', () => {
                 totalWeight: 500,
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: ['fragile'] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
         it('should return 0 for BY_LINE_ITEM_QUANTITY when productVendors filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
@@ -1039,15 +929,9 @@ describe('CostCalculatorService', () => {
                 filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
-                lineItems: [
-                    createLineItem({
-                        quantity: 10,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' },
-                    }),
-                ],
+                lineItems: [createLineItem({ quantity: 10, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
         it('should apply BY_LINE_ITEM_QUANTITY when productVendors filter matches', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
@@ -1055,15 +939,9 @@ describe('CostCalculatorService', () => {
                 filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
-                lineItems: [
-                    createLineItem({
-                        quantity: 10,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                ],
+                lineItems: [createLineItem({ quantity: 10, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(5);
         });
         it('should return 0 for PCT_GROSS_SALES when productTypes filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
@@ -1072,12 +950,9 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 grossSalePrice: 150,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Clothing' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Clothing' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply PCT_GROSS_SALES when productTypes filter matches', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
@@ -1086,12 +961,9 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 grossSalePrice: 150,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Electronics' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Electronics' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBeCloseTo(4.5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBeCloseTo(4.5);
         });
         it('should return 0 for PCT_NET_SALES when productCategories filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, {
@@ -1100,12 +972,9 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 netSalePrice: 80,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Sports' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Sports' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should return 0 for PCT_TOTAL_SALES when products filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, {
@@ -1116,8 +985,7 @@ describe('CostCalculatorService', () => {
                 totalPrice: 200,
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should return 0 for PCT_COGS when product filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, {
@@ -1126,12 +994,9 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 totalProductCost: 50,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Samsung' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Samsung' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should return 0 for PCT_SHIPPING when product filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, {
@@ -1142,8 +1007,7 @@ describe('CostCalculatorService', () => {
                 totalShipping: 20,
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should return 0 for PER_REFUND_ORDER when product filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
@@ -1152,12 +1016,9 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 hasRefund: true,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply PER_REFUND_ORDER when product filter matches and hasRefund', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
@@ -1168,8 +1029,7 @@ describe('CostCalculatorService', () => {
                 hasRefund: true,
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
         it('should only apply PER_LINE_ITEM cost to line items matching product filter', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
@@ -1182,16 +1042,8 @@ describe('CostCalculatorService', () => {
             };
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 3,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 2,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                    createLineItem({ lineItemId: '2', quantity: 2, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' } }),
                 ],
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
@@ -1206,15 +1058,10 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 3,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
                 ],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
         it('should only apply PER_REFUND_LINE_ITEM cost to refunded line items matching product filter', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
@@ -1228,16 +1075,8 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 hasRefund: true,
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        refundedQuantity: 2,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [] },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        refundedQuantity: 1,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [] },
-                    }),
+                    createLineItem({ lineItemId: '1', refundedQuantity: 2, filterContext: { productId: 'P1', variantId: 'V1', tags: [] } }),
+                    createLineItem({ lineItemId: '2', refundedQuantity: 1, filterContext: { productId: 'P2', variantId: 'V2', tags: [] } }),
                 ],
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
@@ -1257,13 +1096,10 @@ describe('CostCalculatorService', () => {
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'US' },
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, contextPass, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, contextPass, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
             const contextProductFail = createContext({
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'US' },
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
             expect(CostCalculatorService.calculateOtherCostEntry(entry, contextProductFail, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
             const contextOrderFail = createContext({
@@ -1281,8 +1117,7 @@ describe('CostCalculatorService', () => {
                 totalWeight: 500,
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' },
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should return 0 for BY_LINE_ITEM_QUANTITY when orderTags filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
@@ -1293,8 +1128,7 @@ describe('CostCalculatorService', () => {
                 lineItems: [createLineItem({ quantity: 10 })],
                 orderFilterContext: { tags: ['retail'], paymentGateways: [], shippingTitles: [] },
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
         it('should return 0 for PCT_GROSS_SALES when orderPaymentGateways filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
@@ -1305,8 +1139,7 @@ describe('CostCalculatorService', () => {
                 grossSalePrice: 150,
                 orderFilterContext: { tags: [], paymentGateways: ['paypal'], shippingTitles: [] },
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply PCT_GROSS_SALES when orderPaymentGateways filter matches', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
@@ -1317,8 +1150,7 @@ describe('CostCalculatorService', () => {
                 grossSalePrice: 150,
                 orderFilterContext: { tags: [], paymentGateways: ['stripe'], shippingTitles: [] },
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBeCloseTo(4.5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBeCloseTo(4.5);
         });
         it('should return 0 for PER_LINE_ITEM when orderShippingTitles filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
@@ -1329,8 +1161,7 @@ describe('CostCalculatorService', () => {
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: ['Standard'] },
                 lineItems: [createLineItem({ quantity: 3 })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
         it('should return 0 for PCT_COGS when orderSourceNames filter does not match', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, {
@@ -1341,8 +1172,7 @@ describe('CostCalculatorService', () => {
                 totalProductCost: 50,
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], sourceName: 'pos' },
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply PER_ORDER when EXCLUDE product filter does not match any line item vendor', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1350,12 +1180,9 @@ describe('CostCalculatorService', () => {
                 filters: { productVendors: { mode: COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
         it('should return 0 for PER_ORDER when EXCLUDE product filter matches all line items', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1364,14 +1191,10 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
                 ],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply PER_ORDER when product filter mode is ALL', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1379,12 +1202,9 @@ describe('CostCalculatorService', () => {
                 filters: { productVendors: { mode: COST_FILTER_MODE.ALL, values: [] } },
             });
             const context = createContext({
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'anything' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'anything' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
         it('should return 0 for PER_ORDER when multiple product filters set and no single line item satisfies all', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1396,14 +1216,8 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike', productType: 'Hats' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas', productType: 'Shoes' },
-                    }),
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike', productType: 'Hats' } }),
+                    createLineItem({ lineItemId: '2', filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas', productType: 'Shoes' } }),
                 ],
             });
             const liCosts = {
@@ -1422,14 +1236,8 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas', productType: 'Hats' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike', productType: 'Shoes' },
-                    }),
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas', productType: 'Hats' } }),
+                    createLineItem({ lineItemId: '2', filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike', productType: 'Shoes' } }),
                 ],
             });
             const liCosts = {
@@ -1446,13 +1254,11 @@ describe('CostCalculatorService', () => {
             const matchContext = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V200', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
             const noMatchContext = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V999', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should convert currency AND evaluate product filters for PER_ORDER', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1466,12 +1272,9 @@ describe('CostCalculatorService', () => {
             });
             expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', rates).orderLevel).toBeCloseTo(11);
             const noMatchContext = createContext({
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', rates)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', rates).orderLevel).toBe(0);
         });
         it('should evaluate weight tiers AND product filters for BY_ORDER_WEIGHT', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
@@ -1484,20 +1287,14 @@ describe('CostCalculatorService', () => {
             });
             const matchContext = createContext({
                 totalWeight: 2000,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Heavy Items' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Heavy Items' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(3);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
             const noMatchContext = createContext({
                 totalWeight: 2000,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Light Items' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Light Items' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should evaluate quantity tiers AND product filters for BY_LINE_ITEM_QUANTITY', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
@@ -1508,19 +1305,13 @@ describe('CostCalculatorService', () => {
                 filters: { productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['bulk'] } },
             });
             const matchContext = createContext({
-                lineItems: [
-                    createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['bulk'] } }),
-                ],
+                lineItems: [createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['bulk'] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(2);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(2);
             const noMatchContext = createContext({
-                lineItems: [
-                    createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['single'] } }),
-                ],
+                lineItems: [createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['single'] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
         it('should apply PER_LINE_ITEM to line items NOT matching EXCLUDE product filter', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
@@ -1533,16 +1324,8 @@ describe('CostCalculatorService', () => {
             };
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 3,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 2,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                    createLineItem({ lineItemId: '2', quantity: 2, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' } }),
                 ],
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
@@ -1565,21 +1348,9 @@ describe('CostCalculatorService', () => {
             };
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 2,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike', productType: 'Shoes' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 3,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike', productType: 'Hats' },
-                    }),
-                    createLineItem({
-                        lineItemId: '3',
-                        quantity: 1,
-                        filterContext: { productId: 'P3', variantId: 'V3', tags: [], vendor: 'Adidas', productType: 'Shoes' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 2, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike', productType: 'Shoes' } }),
+                    createLineItem({ lineItemId: '2', quantity: 3, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike', productType: 'Hats' } }),
+                    createLineItem({ lineItemId: '3', quantity: 1, filterContext: { productId: 'P3', variantId: 'V3', tags: [], vendor: 'Adidas', productType: 'Shoes' } }),
                 ],
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
@@ -1597,8 +1368,7 @@ describe('CostCalculatorService', () => {
                 hasRefund: false,
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply PER_REFUND_LINE_ITEM only to refunded line items NOT matching EXCLUDE filter', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
@@ -1612,16 +1382,8 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 hasRefund: true,
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        refundedQuantity: 2,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [] },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        refundedQuantity: 1,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [] },
-                    }),
+                    createLineItem({ lineItemId: '1', refundedQuantity: 2, filterContext: { productId: 'P1', variantId: 'V1', tags: [] } }),
+                    createLineItem({ lineItemId: '2', refundedQuantity: 1, filterContext: { productId: 'P2', variantId: 'V2', tags: [] } }),
                 ],
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
@@ -1637,8 +1399,7 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 orderFilterContext: { tags: ['vip'], paymentGateways: [], shippingTitles: [] },
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
         it('should return 0 for PER_ORDER when EXCLUDE order filter matches', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1648,8 +1409,7 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 orderFilterContext: { tags: ['test'], paymentGateways: [], shippingTitles: [] },
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should handle undefined filter context fields (missing vendor, productType, category)', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1659,8 +1419,7 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should handle EXCLUDE filter with undefined filter context field (undefined treated as not matching)', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1670,8 +1429,7 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
         it('should return 0 for PER_ORDER when INCLUDE productTags filter and line item has empty tags', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1681,8 +1439,7 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
         it('should apply PER_ORDER when EXCLUDE productTags filter and line item has empty tags', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
@@ -1692,8 +1449,7 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
             });
-            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
         it('should apply PER_LINE_ITEM only to line items matching product filter when order filter also passes', () => {
             const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
@@ -1710,16 +1466,8 @@ describe('CostCalculatorService', () => {
             const context = createContext({
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'US' },
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 3,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 2,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                    createLineItem({ lineItemId: '2', quantity: 2, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' } }),
                 ],
             });
             const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
@@ -1745,9 +1493,7 @@ describe('CostCalculatorService', () => {
                     ],
                 },
             });
-            const liCosts = {
-                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
-            };
+            const liCosts = { '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 } };
             const result = CostCalculatorService.calculateOtherCost(configs, createContext(), liCosts, 'USD', emptyRatesMap);
             expect(result.total).toBe(5);
             expect(result.orderLevel).toBe(5);
@@ -1791,22 +1537,18 @@ describe('CostCalculatorService', () => {
                 order: {
                     entries: [
                         createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e1',
-                            flatAmount: 3,
+                            id: 'e1', flatAmount: 3,
                             filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
                         }),
                         createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e2',
-                            flatAmount: 7,
+                            id: 'e2', flatAmount: 7,
                             filters: { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P999'] } },
                         }),
                         createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
-                            id: 'e3',
-                            percentRate: 2,
+                            id: 'e3', percentRate: 2,
                         }),
                         createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e4',
-                            flatAmount: 10,
+                            id: 'e4', flatAmount: 10,
                             filters: { countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['CA'] } },
                         }),
                     ],
@@ -1814,19 +1556,10 @@ describe('CostCalculatorService', () => {
             });
             const context = createContext({
                 grossSalePrice: 120,
-                orderFilterContext: {
-                    tags: [],
-                    paymentGateways: ['stripe'],
-                    shippingTitles: ['Standard'],
-                    shipCountryCode: 'US',
-                },
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [], vendor: 'Nike' } }),
-                ],
+                orderFilterContext: { tags: [], paymentGateways: ['stripe'], shippingTitles: ['Standard'], shipCountryCode: 'US' },
+                lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            const liCosts = {
-                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
-            };
+            const liCosts = { '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 } };
             const result = CostCalculatorService.calculateOtherCost(configs, context, liCosts, 'USD', emptyRatesMap);
             expect(result.total).toBeCloseTo(5.4);
             expect(result.orderLevel).toBeCloseTo(5.4);
@@ -1841,7 +1574,10 @@ describe('CostCalculatorService', () => {
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 3 }), createLineItem({ lineItemId: '2', quantity: 2 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 2 }),
+                ],
             });
             const liCosts = {
                 '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
@@ -1862,9 +1598,7 @@ describe('CostCalculatorService', () => {
             expect(Object.keys(result)).toHaveLength(0);
         });
         it('should include an explicit 0 override as 0, distinct from having no override', () => {
-            const result = CostCalculatorService.calculateLineItemHandlingCosts([
-                createLineItem({ variantHandlingFee: 0, quantity: 3 }),
-            ]);
+            const result = CostCalculatorService.calculateLineItemHandlingCosts([createLineItem({ variantHandlingFee: 0, quantity: 3 })]);
             expect(result['1']).toBe(0);
         });
         it('should multiply handling fee by quantity', () => {
@@ -1898,9 +1632,7 @@ describe('CostCalculatorService', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 2 },
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
                 shipping: { method: SHIPPING_METHOD.SHOPIFY_CHARGES, currency: 'USD' },
                 order: {
@@ -1915,7 +1647,7 @@ describe('CostCalculatorService', () => {
             expect(result.orderLevelHandlingCost).toBe(0);
             expect(result.lineItemLevelHandlingCost).toBe(1);
             expect(result.totalHandlingCost).toBe(1);
-            expect(result.totalGatewayCost).toBeCloseTo(3.2);
+            expect(result.totalGatewayCost).toBeCloseTo(3.20);
             expect(result.totalShippingCost).toBe(10);
             expect(result.totalOtherCost).toBe(1);
             expect(result.orderLevelOtherCost).toBe(1);
@@ -1925,16 +1657,14 @@ describe('CostCalculatorService', () => {
         it('should handle partial configs', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
             const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
             expect(result.orderLevelHandlingCost).toBe(0);
             expect(result.lineItemLevelHandlingCost).toBe(0);
             expect(result.totalHandlingCost).toBe(0);
-            expect(result.totalGatewayCost).toBe(0.3);
+            expect(result.totalGatewayCost).toBe(0.30);
             expect(result.totalShippingCost).toBe(0);
             expect(result.totalOtherCost).toBe(0);
         });
@@ -1943,13 +1673,11 @@ describe('CostCalculatorService', () => {
                 order: {
                     entries: [
                         createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e1',
-                            flatAmount: 5,
+                            id: 'e1', flatAmount: 5,
                             filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
                         }),
                         createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e2',
-                            flatAmount: 10,
+                            id: 'e2', flatAmount: 10,
                             filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Puma'] } },
                         }),
                     ],
@@ -1972,9 +1700,7 @@ describe('CostCalculatorService', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 1, currency: 'USD' },
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
                 shipping: { method: SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 5, currency: 'USD' },
                 order: {
@@ -1996,7 +1722,7 @@ describe('CostCalculatorService', () => {
             expect(result.orderLevelHandlingCost).toBe(0);
             expect(result.lineItemLevelHandlingCost).toBe(3.5);
             expect(result.totalHandlingCost).toBe(3.5);
-            expect(result.totalGatewayCost).toBeCloseTo(6.1);
+            expect(result.totalGatewayCost).toBeCloseTo(6.10);
             expect(result.totalShippingCost).toBe(5);
             expect(result.totalOtherCost).toBe(12);
             expect(result.orderLevelOtherCost).toBe(7);
@@ -2009,7 +1735,9 @@ describe('CostCalculatorService', () => {
         it('should maintain decimal precision with Big.js', () => {
             const configs = createConfigs({
                 order: {
-                    entries: [createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 33.33 })],
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 33.33 }),
+                    ],
                 },
             });
             const context = createContext({ totalPrice: 99.99 });
@@ -2075,11 +1803,7 @@ describe('CostCalculatorService', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
-                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
-                            id: 'agency1',
-                            percentRate: 15,
-                            category: 'agency_fees',
-                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, { id: 'agency1', percentRate: 15, category: 'agency_fees' }),
                     ],
                 },
             });
@@ -2090,7 +1814,9 @@ describe('CostCalculatorService', () => {
         it('should route OPEX category costs to opexCost', () => {
             const configs = createConfigs({
                 order: {
-                    entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'opex1', flatAmount: 12, category: 'opex' })],
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'opex1', flatAmount: 12, category: 'opex' }),
+                    ],
                 },
             });
             const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2099,7 +1825,9 @@ describe('CostCalculatorService', () => {
         it('should route OTHER category costs to totalOtherCost', () => {
             const configs = createConfigs({
                 order: {
-                    entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'other1', flatAmount: 7, category: 'other' })],
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'other1', flatAmount: 7, category: 'other' }),
+                    ],
                 },
             });
             const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2133,11 +1861,7 @@ describe('CostCalculatorService', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
-                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'unknown1',
-                            flatAmount: 3,
-                            category: 'unknown_category_xyz',
-                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'unknown1', flatAmount: 3, category: 'unknown_category_xyz' }),
                     ],
                 },
             });
@@ -2167,7 +1891,10 @@ describe('CostCalculatorService', () => {
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 2 }), createLineItem({ lineItemId: '2', quantity: 3 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 2 }),
+                    createLineItem({ lineItemId: '2', quantity: 3 }),
+                ],
             });
             const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
             expect(result.categoryCosts.otherFulfillmentCost).toBe(18);
@@ -2202,16 +1929,15 @@ describe('CostCalculatorService', () => {
                 order: {
                     entries: [
                         createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'cogs_li', flatAmount: 2, category: 'cogs' }),
-                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
-                            id: 'ful_li',
-                            flatAmount: 1.5,
-                            category: 'fulfillment',
-                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'ful_li', flatAmount: 1.5, category: 'fulfillment' }),
                     ],
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 3 }), createLineItem({ lineItemId: '2', quantity: 2 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 2 }),
+                ],
             });
             const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
             expect(result.categoryCosts.totalOtherCogs).toBe(10);
@@ -2220,7 +1946,9 @@ describe('CostCalculatorService', () => {
         it('should handle PCT_COGS entry type with category routing', () => {
             const configs = createConfigs({
                 order: {
-                    entries: [createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { id: 'pct_cogs', percentRate: 10, category: 'cogs' })],
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { id: 'pct_cogs', percentRate: 10, category: 'cogs' }),
+                    ],
                 },
             });
             const context = createContext({ totalProductCost: 50 });
@@ -2231,11 +1959,7 @@ describe('CostCalculatorService', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
-                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, {
-                            id: 'pct_ship',
-                            percentRate: 20,
-                            category: 'fulfillment',
-                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, { id: 'pct_ship', percentRate: 20, category: 'fulfillment' }),
                     ],
                 },
             });
@@ -2381,7 +2105,10 @@ describe('CostCalculatorService', () => {
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 4 }), createLineItem({ lineItemId: '2', quantity: 3 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 4 }),
+                    createLineItem({ lineItemId: '2', quantity: 3 }),
+                ],
                 totalQuantity: 7,
             });
             const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
@@ -2414,9 +2141,7 @@ describe('CostCalculatorService', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 1.5, currency: 'USD' },
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
                 shipping: { method: SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 7, currency: 'USD' },
                 order: {
@@ -2441,7 +2166,7 @@ describe('CostCalculatorService', () => {
             const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
             expect(result.lineItemLevelHandlingCost).toBe(3.25);
             expect(result.totalHandlingCost).toBe(3.25);
-            expect(result.totalGatewayCost).toBeCloseTo(6.1);
+            expect(result.totalGatewayCost).toBeCloseTo(6.10);
             expect(result.totalShippingCost).toBe(7);
             expect(result.categoryCosts.totalOtherCogs).toBe(5);
             expect(result.categoryCosts.otherFulfillmentCost).toBe(3);
@@ -2464,7 +2189,10 @@ describe('CostCalculatorService', () => {
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 3 }), createLineItem({ lineItemId: '2', quantity: 2 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 2 }),
+                ],
             });
             const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
             expect(result.orderLevelOtherCost).toBe(15);
@@ -2522,7 +2250,9 @@ describe('CostCalculatorService', () => {
             it('should handle entry with undefined flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: undefined, category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: undefined, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2531,7 +2261,9 @@ describe('CostCalculatorService', () => {
             it('should handle entry with null flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: null, category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: null, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2540,7 +2272,9 @@ describe('CostCalculatorService', () => {
             it('should handle entry with NaN flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: NaN, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: NaN, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2549,7 +2283,9 @@ describe('CostCalculatorService', () => {
             it('should handle entry with negative flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: -10, category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: -10, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2558,7 +2294,9 @@ describe('CostCalculatorService', () => {
             it('should handle entry with Infinity flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: Infinity, category: 'marketing' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: Infinity, category: 'marketing' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2567,7 +2305,9 @@ describe('CostCalculatorService', () => {
             it('should handle entry with string flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: '10.50', category: 'opex' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: '10.50', category: 'opex' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2602,7 +2342,9 @@ describe('CostCalculatorService', () => {
             it('should handle negative percentRate', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, { percentRate: -5, category: 'marketing' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, { percentRate: -5, category: 'marketing' }),
+                        ],
                     },
                 });
                 const context = createContext({ netSalePrice: 100 });
@@ -2612,7 +2354,9 @@ describe('CostCalculatorService', () => {
             it('should handle percentRate over 100', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 150, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 150, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const context = createContext({ totalProductCost: 50 });
@@ -2624,7 +2368,9 @@ describe('CostCalculatorService', () => {
             it('should handle zero totalPrice for percent calculations', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'transaction' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'transaction' }),
+                        ],
                     },
                 });
                 const context = createContext({ totalPrice: 0 });
@@ -2634,7 +2380,9 @@ describe('CostCalculatorService', () => {
             it('should handle negative totalPrice', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'cogs' }),
+                        ],
                     },
                 });
                 const context = createContext({ totalPrice: -100 });
@@ -2644,7 +2392,9 @@ describe('CostCalculatorService', () => {
             it('should handle empty lineItems array', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const context = createContext({ lineItems: [] });
@@ -2655,7 +2405,9 @@ describe('CostCalculatorService', () => {
             it('should handle lineItems with zero quantity', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'marketing' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'marketing' }),
+                        ],
                     },
                 });
                 const context = createContext({
@@ -2702,7 +2454,9 @@ describe('CostCalculatorService', () => {
             it('should handle empty currency string', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: '', category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: '', category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2711,7 +2465,9 @@ describe('CostCalculatorService', () => {
             it('should handle null order currency', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), null, emptyRatesMap);
@@ -2721,11 +2477,7 @@ describe('CostCalculatorService', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
-                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                                flatAmount: 10,
-                                currency: 'EUR',
-                                category: 'transaction',
-                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: 'EUR', category: 'transaction' }),
                         ],
                     },
                 });
@@ -2822,7 +2574,9 @@ describe('CostCalculatorService', () => {
             it('should handle undefined orderFilterContext', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' }),
+                        ],
                     },
                 });
                 const context = createContext({ orderFilterContext: undefined });
@@ -2951,7 +2705,9 @@ describe('CostCalculatorService', () => {
             it('should maintain identity with single order-level COGS entry', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 25, category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 25, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -2968,7 +2724,9 @@ describe('CostCalculatorService', () => {
                 const context = createContext({ lineItems, totalQuantity: 5 });
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 4, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 4, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
@@ -3167,11 +2925,7 @@ describe('CostCalculatorService', () => {
                     order: {
                         entries: [
                             createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs', currency: 'EUR' }),
-                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                                flatAmount: 20,
-                                category: 'fulfillment',
-                                currency: 'GBP',
-                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 20, category: 'fulfillment', currency: 'GBP' }),
                             createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 15, category: 'marketing', currency: 'USD' }),
                         ],
                     },
@@ -3287,7 +3041,9 @@ describe('CostCalculatorService', () => {
             it('should route each entry to exactly one category', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e1', flatAmount: 100, category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e1', flatAmount: 100, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -3345,7 +3101,9 @@ describe('CostCalculatorService', () => {
                 const configs = createConfigs({
                     globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' }),
+                        ],
                     },
                 });
                 const context = createContext({ lineItems, totalQuantity: 3 });
@@ -3365,11 +3123,13 @@ describe('CostCalculatorService', () => {
                 const configs = createConfigs({
                     gateway: {
                         entries: [
-                            { id: 'g1', name: 'Stripe', gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD' },
+                            { id: 'g1', name: 'Stripe', gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD' },
                         ],
                     },
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const context = createContext({ totalPrice: 100 });
@@ -3392,7 +3152,9 @@ describe('CostCalculatorService', () => {
                         currency: 'USD',
                     },
                     order: {
-                        entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'marketing' })],
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'marketing' }),
+                        ],
                     },
                 });
                 const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -3414,7 +3176,7 @@ describe('CostCalculatorService', () => {
                         lineItemId: 'li-1',
                         quantity: 5,
                         refundedQuantity: 0,
-                        variantHandlingFee: 1.5,
+                        variantHandlingFee: 1.50,
                         filterContext: { tags: ['electronics'], productId: '100', variantId: '200', vendor: 'Samsung' },
                     }),
                     createLineItem({
@@ -3428,17 +3190,17 @@ describe('CostCalculatorService', () => {
                         lineItemId: 'li-3',
                         quantity: 2,
                         refundedQuantity: 0,
-                        variantHandlingFee: 2.0,
+                        variantHandlingFee: 2.00,
                         filterContext: { tags: ['premium', 'electronics'], productId: '102', variantId: '202', vendor: 'Apple' },
                     }),
                 ];
                 const context = createContext({
                     orderCreatedAt: '2024-06-15T10:00:00Z',
-                    totalPrice: 850.0,
-                    grossSalePrice: 920.0,
-                    netSalePrice: 780.0,
-                    totalProductCost: 425.0,
-                    totalShipping: 25.0,
+                    totalPrice: 850.00,
+                    grossSalePrice: 920.00,
+                    netSalePrice: 780.00,
+                    totalProductCost: 425.00,
+                    totalShipping: 25.00,
                     totalWeight: 2500,
                     totalQuantity: 10,
                     hasRefund: true,
@@ -3458,7 +3220,7 @@ describe('CostCalculatorService', () => {
                 };
                 const configs = createConfigs({
                     globalProductOverride: {
-                        globalHandlingFee: 0.5,
+                        globalHandlingFee: 0.50,
                         currency: 'USD',
                     },
                     gateway: {
@@ -3467,7 +3229,7 @@ describe('CostCalculatorService', () => {
                                 id: 'stripe',
                                 name: 'Stripe',
                                 gatewayName: 'stripe',
-                                flatAmount: 0.3,
+                                flatAmount: 0.30,
                                 percentRate: 2.9,
                                 currency: 'USD',
                             },
@@ -3482,7 +3244,7 @@ describe('CostCalculatorService', () => {
                                 countries: ['US'],
                                 isDefault: false,
                                 rateType: SHIPPING_RATE_TYPE.FLAT,
-                                flatAmount: 12.0,
+                                flatAmount: 12.00,
                                 currency: 'USD',
                             },
                             {
@@ -3505,7 +3267,7 @@ describe('CostCalculatorService', () => {
                         entries: [
                             createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                                 id: 'packaging-base',
-                                flatAmount: 2.0,
+                                flatAmount: 2.00,
                                 category: 'cogs',
                             }),
                             createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, {
@@ -3535,7 +3297,7 @@ describe('CostCalculatorService', () => {
                             }),
                             createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                                 id: 'agency-retainer-allocation',
-                                flatAmount: 8.0,
+                                flatAmount: 8.00,
                                 currency: 'EUR',
                                 category: 'agency_fees',
                             }),
@@ -3546,12 +3308,12 @@ describe('CostCalculatorService', () => {
                             }),
                             createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
                                 id: 'refund-processing',
-                                flatAmount: 5.0,
+                                flatAmount: 5.00,
                                 category: 'opex',
                             }),
                             createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
                                 id: 'restocking-fee',
-                                flatAmount: 3.0,
+                                flatAmount: 3.00,
                                 category: 'other',
                             }),
                             createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {