feat: implement QuoteResponse V1 and V2 coercers

packages/bridge-controller/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Implement coercers between `QuoteResponse` v1 and v2 ([#9725](https://github.com/MetaMask/core/pull/9725))
+  - `toQuoteResponseV2` and `toQuoteResponseV1` convert quote responses to required schema when needed
+  - `toQuoteMetadataV2` and `toQuoteMetadataV1` convert quote metadata to required schema when needed
+  - `toNormalizedAmounts`converts atomic amounts to display-ready values
+- Export `sumAmounts` util that adds up fees or token amounts ([#9725](https://github.com/MetaMask/core/pull/9725))
+
 ### Changed
 
 - Bump `@metamask/transaction-controller` from `^69.4.0` to `^69.5.0` ([#9780](https://github.com/MetaMask/core/pull/9780))

packages/bridge-controller/src/coercers/quote-response-v1-to-v2.test.ts

@@ -0,0 +1,172 @@
+import { KnownCaipNamespace } from '@metamask/utils';
+import { QuoteMetadata } from 'src/utils/quote-metadata/types';
+
+import { mockBridgeQuotesErc20Erc20V2Migration } from '../../tests/mock-quotes-erc20-erc20-migration-v2.js';
+import { mockBridgeQuotesErc20Erc20V1 } from '../../tests/mock-quotes-erc20-erc20.js';
+import { mergeQuoteMetadata } from '../utils/quote-metadata/merge.js';
+import { toQuoteMetadataV1 } from '../utils/quote-metadata/to-quote-metadata-v1.js';
+import { toQuoteResponseV2 } from './quote-response-v1-to-v2.js';
+
+const TEST_METADATA: QuoteMetadata = {
+  sentAmount: {
+    amount: '14',
+    usd: undefined,
+    valueInCurrency: undefined,
+  },
+  toTokenAmount: {
+    amount: '13.98428',
+    usd: undefined,
+    valueInCurrency: undefined,
+  },
+  minToTokenAmount: {
+    amount: '13.7',
+    usd: undefined,
+    valueInCurrency: undefined,
+  },
+  relayerFee: {
+    amount: '0.00001',
+    usd: undefined,
+    valueInCurrency: undefined,
+  },
+  totalNetworkFee: {
+    amount: '0.001',
+    usd: undefined,
+    valueInCurrency: undefined,
+  },
+  gasFee: {
+    total: { amount: '0.00099', usd: undefined, valueInCurrency: undefined },
+  },
+  swapRate: '0.99887714285714285714',
+  priceImpact: {
+    usd: '1.5',
+    valueInCurrency: '1.5',
+  },
+};
+
+const quoteResponseV1WithMetadata = {
+  ...mockBridgeQuotesErc20Erc20V1[0],
+  ...TEST_METADATA,
+};
+
+describe('quote-response-v2 migration', () => {
+  describe('toQuoteResponseV2', () => {
+    it('should return a validation error for an invalid quote response', () => {
+      const quoteResponse = {
+        quote: {
+          requestId: '123',
+        },
+      };
+
+      expect(() =>
+        toQuoteResponseV2(quoteResponse),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `"At path: quote.src -- Expected an object, but received: undefined"`,
+      );
+    });
+
+    it('should return QuoteResponse with no normalized amounts and no metadata (V1 input)', () => {
+      const quoteResponseV2 = toQuoteResponseV2(quoteResponseV1WithMetadata);
+
+      const expectedQuoteResponseV2 = mockBridgeQuotesErc20Erc20V2Migration[0];
+      delete expectedQuoteResponseV2.quote.feeData.network;
+      expect(
+        quoteResponseV2.quote.feeData?.network?.[0]?.amount,
+      ).toBeUndefined();
+
+      expect(quoteResponseV2).toStrictEqual({
+        ...expectedQuoteResponseV2,
+        ...TEST_METADATA,
+        namespace: KnownCaipNamespace.Eip155,
+        chainId: 'eip155:10',
+      });
+
+      const extractedMetadata = toQuoteMetadataV1(quoteResponseV2);
+      expect(extractedMetadata).toStrictEqual(TEST_METADATA);
+    });
+
+    it('should return QuoteResponse with no normalized amounts and preserve metadata (V1 input)', () => {
+      const quoteResponseV2 = mergeQuoteMetadata(
+        toQuoteResponseV2(quoteResponseV1WithMetadata),
+        TEST_METADATA,
+      );
+      const expectedQuoteResponseV2 = mergeQuoteMetadata(
+        mockBridgeQuotesErc20Erc20V2Migration[0],
+        TEST_METADATA,
+      );
+
+      expect(expectedQuoteResponseV2.quote.feeData).toMatchInlineSnapshot(`
+        {
+          "metabridge": [
+            {
+              "amount": "0",
+              "asset": {
+                "assetId": "eip155:10/erc20:0x0b2c639c533813f4aa9d7837caf62653d097ff85",
+                "decimals": 6,
+                "name": "USD Coin",
+                "symbol": "USDC",
+              },
+            },
+          ],
+          "network": [
+            {
+              "amount": "990000000000000",
+              "asset": {
+                "assetId": "eip155:10/slip44:60",
+                "decimals": 18,
+                "name": "Ether",
+                "symbol": "ETH",
+              },
+              "normalizedAmount": "0.00099",
+              "usd": undefined,
+              "valueInCurrency": undefined,
+            },
+          ],
+          "relayer": [
+            {
+              "amount": "10000000000000",
+              "asset": {
+                "assetId": "eip155:10/slip44:60",
+                "decimals": 18,
+                "name": "Ether",
+                "symbol": "ETH",
+              },
+              "normalizedAmount": "0.00001",
+              "usd": undefined,
+              "valueInCurrency": undefined,
+            },
+          ],
+          "txFee": undefined,
+        }
+      `);
+
+      const extractedMetadata = toQuoteMetadataV1(quoteResponseV2);
+      expect(quoteResponseV2).toStrictEqual({
+        ...expectedQuoteResponseV2,
+        ...TEST_METADATA,
+        namespace: KnownCaipNamespace.Eip155,
+        chainId: 'eip155:10',
+      });
+      expect(extractedMetadata).toStrictEqual(TEST_METADATA);
+    });
+
+    it('should return QuoteResponse and preserve metadata (V2 input)', () => {
+      const quoteResponse = {
+        ...mockBridgeQuotesErc20Erc20V2Migration[0],
+        ...TEST_METADATA,
+      };
+      const quoteResponseV2 = toQuoteResponseV2(quoteResponse);
+      expect(quoteResponseV2).toStrictEqual({
+        ...quoteResponse,
+        namespace: KnownCaipNamespace.Eip155,
+        chainId: 'eip155:10',
+      });
+      expect(toQuoteMetadataV1(quoteResponseV2)).toStrictEqual(TEST_METADATA);
+    });
+
+    it('should throw an error for a null input', () => {
+      expect(() => toQuoteResponseV2(null)).toThrow(
+        'Expected an object, but received: null',
+      );
+    });
+  });
+});

packages/bridge-controller/src/coercers/quote-response-v1-to-v2.ts

@@ -0,0 +1,199 @@
+import { create, coerce, Infer, is, intersection } from '@metamask/superstruct';
+import { parseCaipAssetType } from '@metamask/utils';
+import { BigNumber } from 'bignumber.js';
+
+import { formatAddressToAssetId } from '../utils/caip-formatters.js';
+import { sumAmounts } from '../utils/number-formatters.js';
+import {
+  BridgeAssetSchema,
+  BridgeAssetV2Schema,
+  MinimalAssetSchema,
+} from '../validators/bridge-asset.js';
+import { QuoteResponseSchemaV1 } from '../validators/quote-response-v1.js';
+import type { QuoteResponseV1 } from '../validators/quote-response-v1.js';
+import {
+  QuoteResponseSchemaV2,
+  validateQuoteResponse,
+} from '../validators/quote-response.js';
+import type { QuoteResponse } from '../validators/quote-response.js';
+import { QuoteSchemaV2, FeeType, QuoteSchema } from '../validators/quote.js';
+import { StepSchemaV2, StepSchema } from '../validators/step.js';
+
+const BridgeAssetV2FromV1 = coerce(
+  BridgeAssetV2Schema,
+  intersection([BridgeAssetSchema, MinimalAssetSchema]),
+  (value) => {
+    const { chainId, address, iconUrl, icon, assetId, ...rest } = value;
+
+    const resolvedIconUrl = iconUrl ?? icon;
+
+    return {
+      assetId:
+        assetId ??
+        /* istanbul ignore next */ formatAddressToAssetId(address, chainId),
+      ...(resolvedIconUrl && { iconUrl: resolvedIconUrl }),
+      ...rest,
+    };
+  },
+);
+
+export const toBridgeAssetV2 = (
+  data: unknown,
+): Infer<typeof BridgeAssetV2Schema> => {
+  return create(data, BridgeAssetV2FromV1);
+};
+
+const StepSchemaV2FromV1 = coerce(StepSchemaV2, StepSchema, (value) => {
+  const { srcAsset, destAsset, action } = value;
+  return {
+    action,
+    src: {
+      asset: toBridgeAssetV2(srcAsset),
+    },
+    dest: {
+      asset: toBridgeAssetV2(destAsset),
+    },
+  };
+});
+const toStepV2 = (step: Infer<typeof StepSchema>): Infer<typeof StepSchemaV2> =>
+  create(step, StepSchemaV2FromV1);
+
+const QuoteV2FromV1 = coerce(QuoteSchemaV2, QuoteSchema, (value) => {
+  const {
+    srcTokenAmount,
+    destTokenAmount,
+    minDestTokenAmount,
+    srcAsset,
+    destAsset,
+    srcChainId,
+    destChainId,
+    walletAddress,
+    destWalletAddress,
+    priceData,
+    feeData,
+    bridgeId,
+    bridges,
+    steps,
+    intent,
+    ...restQuote
+  } = value;
+
+  return {
+    src: {
+      amount: new BigNumber(srcTokenAmount)
+        .plus(
+          intent
+            ? 0
+            : (sumAmounts([
+                feeData[FeeType.TX_FEE],
+                feeData[FeeType.METABRIDGE],
+              ])?.amount ?? 0),
+        )
+        .toFixed(),
+      asset: toBridgeAssetV2(srcAsset),
+      ...(walletAddress && { walletAddress }),
+    },
+    dest: {
+      amount: destTokenAmount,
+      asset: toBridgeAssetV2(destAsset),
+      ...(destWalletAddress && { walletAddress: destWalletAddress }),
+      minAmount: minDestTokenAmount,
+    },
+    priceData: {
+      ...(priceData?.priceImpact && {
+        priceImpact: {
+          amount: priceData.priceImpact,
+        },
+      }),
+    },
+    feeData: {
+      [FeeType.METABRIDGE]: [
+        {
+          ...feeData[FeeType.METABRIDGE],
+          asset: toBridgeAssetV2(feeData[FeeType.METABRIDGE].asset),
+          ...(priceData?.totalFeeAmountUsd && /* istanbul ignore next */ {
+            usd: priceData?.totalFeeAmountUsd,
+          }),
+        },
+      ],
+      ...(feeData[FeeType.TX_FEE] && /* istanbul ignore next */ {
+        [FeeType.TX_FEE]: [
+          {
+            ...feeData[FeeType.TX_FEE],
+            asset: toBridgeAssetV2(feeData[FeeType.TX_FEE].asset),
+          },
+        ],
+      }),
+    },
+    steps: steps?.map(toStepV2),
+    ...restQuote,
+    ...(intent && /* istanbul ignore next */ { intent }),
+    protocols: bridges,
+    aggregator: bridgeId,
+  };
+});
+
+const toQuoteV2 = (
+  quote: Infer<typeof QuoteSchema>,
+): Infer<typeof QuoteSchemaV2> => {
+  const quoteV2 = create(quote, QuoteV2FromV1);
+  return quoteV2;
+};
+
+const QuoteResponseV2FromV1 = coerce(
+  QuoteResponseSchemaV2,
+  QuoteResponseSchemaV1,
+  (value: QuoteResponseV1) => {
+    const { quote, l1GasFeesInHexWei, nonEvmFeesInNative, ...rest } = value;
+    const { srcAsset } = quote;
+
+    const {
+      chain: { namespace },
+      chainId,
+    } = parseCaipAssetType(srcAsset.assetId);
+
+    return {
+      ...rest,
+      ...(nonEvmFeesInNative && { nonEvmFeesInNative }),
+      ...(l1GasFeesInHexWei && { l1GasFeesInHexWei }),
+      namespace,
+      chainId,
+      quote: toQuoteV2(quote),
+    };
+  },
+);
+
+/**
+ * Converts a partial quote response to a {@link QuoteResponse}.
+ * This does not preserve any post-fetch metadata.
+ *
+ * @param quoteResponse - The {@link QuoteResponseV1} to convert
+ * @returns The {@link QuoteResponse}
+ */
+export function toQuoteResponseV2(quoteResponse: unknown): QuoteResponse {
+  let quoteResponseV2: QuoteResponse | null = null;
+
+  // V1 quote
+  /* istanbul ignore else */
+  if (is(quoteResponse, QuoteResponseSchemaV1)) {
+    quoteResponseV2 = create(quoteResponse, QuoteResponseV2FromV1);
+  }
+  // V2 quote
+  else if (validateQuoteResponse(quoteResponse)) {
+    quoteResponseV2 = quoteResponse;
+  }
+
+  /* istanbul ignore else */
+  if (quoteResponseV2) {
+    const {
+      chain: { namespace },
+      chainId,
+    } = parseCaipAssetType(quoteResponseV2.quote.src.asset.assetId);
+
+    // Add namespace, chainId
+    return { ...quoteResponseV2, namespace: namespace as never, chainId };
+  }
+
+  /* istanbul ignore next */
+  throw new Error('QuoteResponseV1 to V2 conversion failed');
+}