@humanode-hyperlane/rebalancer 0.0.0-stage → 27.2.2-humanode.1

package/package.json

@@ -1,6 +1,90 @@
 {
   "name": "@humanode-hyperlane/rebalancer",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "27.2.2-humanode.1",
+  "description": "Hyperlane Warp Route Collateral Rebalancer Service",
+  "keywords": [
+    "blockchain",
+    "collateral",
+    "hyperlane",
+    "interchain",
+    "rebalancer",
+    "warp-route"
+  ],
+  "license": "Apache-2.0",
+  "author": "Abacus Works, Inc.",
+  "repository": "https://github.com/humanode-network/hyperlane-monorepo",
+  "bin": {
+    "hyperlane-rebalancer": "./dist/service.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@google-cloud/pino-logging-gcp-config": "^1.3.0",
+    "@humanode-hyperlane/registry": "23.12.0",
+    "@inquirer/prompts": "3.3.2",
+    "@inquirer/select": "^1.0.0",
+    "@lifi/sdk": "^3.15.4",
+    "@solana/web3.js": "^1.98.4",
+    "bignumber.js": "^9.1.1",
+    "bs58": "^6.0.0",
+    "ethers": "^5.8.0",
+    "express": "^5.1.0",
+    "pino": "^8.19.0",
+    "pino-pretty": "^13.0.0",
+    "prom-client": "^14.0.1",
+    "uuid": "^10.0.0",
+    "viem": "^2.21.45",
+    "yaml": "2.4.5",
+    "zod": "^3.21.2",
+    "zod-validation-error": "^3.3.0",
+    "@humanode-hyperlane/core": "11.2.0-humanode.1",
+    "@humanode-hyperlane/metrics": "0.2.8-humanode.1",
+    "@humanode-hyperlane/provider-sdk": "4.2.3-humanode.1",
+    "@humanode-hyperlane/sdk": "30.0.0-humanode.1",
+    "@humanode-hyperlane/utils": "30.0.0-humanode.1"
+  },
+  "devDependencies": {
+    "@ethersproject/constants": "*",
+    "@types/chai": "^4.3.11",
+    "@types/chai-as-promised": "^8",
+    "@types/express": "^5.0.3",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^24.10.9",
+    "@types/sinon": "^17.0.1",
+    "@types/uuid": "^10.0.0",
+    "@vercel/ncc": "^0.38.3",
+    "chai": "^4.5.0",
+    "chai-as-promised": "^8.0.1",
+    "mocha": "^11.5.0",
+    "oxfmt": "^0.42.0",
+    "sinon": "^13.0.2",
+    "testcontainers": "11.12.0",
+    "tsx": "^4.19.1",
+    "typescript": "6.0.2",
+    "@humanode-hyperlane/relayer": "1.1.15-humanode.1",
+    "@humanode-hyperlane/tsconfig": "^30.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:dist": "tsc -p tsconfig.build.json",
+    "bundle": "pnpm build:dist && rm -rf ./bundle && ncc build ./dist/service.js -o bundle -e @google-cloud/pino-logging-gcp-config && node ../../scripts/ncc.post-bundle.mjs",
+    "clean": "rm -rf dist cache bundle",
+    "dev": "tsc --watch",
+    "lint": "oxlint -c ../../oxlint.json",
+    "format": "oxfmt --write ./src",
+    "test": "mocha --config .mocharc.json './src/**/*.test.ts' --exit",
+    "test:e2e": "mocha --config .mocharc.e2e.json",
+    "test:e2e:ci": "sh -c 'mocha --config .mocharc.e2e.json \"src/e2e/*${REBALANCER_E2E_TEST}*.e2e-test.ts\" --exit'",
+    "test:ci": "pnpm test",
+    "start": "node dist/service.js",
+    "start:dev": "tsx src/service.ts"
+  }
 }

package/src/bridges/LiFiBridge.test.ts

@@ -0,0 +1,615 @@
+import { expect } from 'chai';
+import { pino } from 'pino';
+
+import type { LiFiStep } from '@lifi/sdk';
+import { ProtocolType } from '@humanode-hyperlane/utils';
+
+import type {
+  BridgeQuote,
+  BridgeQuoteParams,
+  ExternalBridgeConfig,
+} from '../interfaces/IExternalBridge.js';
+import { LiFiBridge } from './LiFiBridge.js';
+
+const testLogger = pino({ level: 'silent' });
+
+const TEST_PRIVATE_KEY =
+  '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+const BRIDGE_CONFIG: ExternalBridgeConfig = {
+  integrator: 'test-rebalancer',
+};
+
+const SOLANA_CHAIN_METADATA_CONFIG: ExternalBridgeConfig = {
+  integrator: 'test-rebalancer',
+  chainMetadata: {
+    solana: {
+      chainId: 1399811149,
+      protocol: ProtocolType.Sealevel,
+      name: 'solana',
+      displayName: 'Solana',
+      domainId: 1399811149,
+      rpcUrls: [{ http: 'https://api.mainnet-beta.solana.com' }],
+    },
+  },
+};
+
+// Use all-digit hex addresses to avoid EIP-55 checksum case mutations
+const TOKEN_ADDR = '0x1234567890123456789012345678901234567890';
+const SENDER_ADDR = '0x9876543210987654321098765432109876543210';
+const BAD_ADDR = '0x1111111111111111111111111111111111111111';
+
+/**
+ * Creates a LiFiStep object that convertQuoteToRoute can consume.
+ * The SDK's convertQuoteToRoute reads action.fromToken.chainId, action.toToken.chainId, etc.
+ */
+function createLiFiStep(overrides?: {
+  fromChainId?: number;
+  toChainId?: number;
+  fromTokenAddress?: string;
+  toTokenAddress?: string;
+  toAddress?: string;
+  fromAmount?: string;
+  toAmount?: string;
+  fromAddress?: string;
+}): LiFiStep {
+  const fromChainId = overrides?.fromChainId ?? 42161;
+  const toChainId = overrides?.toChainId ?? 1151111081099710;
+  const fromTokenAddress = overrides?.fromTokenAddress ?? TOKEN_ADDR;
+  const toTokenAddress = overrides?.toTokenAddress ?? TOKEN_ADDR;
+  const fromAmount = overrides?.fromAmount ?? '10000000000';
+  const fromAddress = overrides?.fromAddress ?? SENDER_ADDR;
+  const toAddress = overrides?.toAddress ?? SENDER_ADDR;
+
+  return {
+    id: 'quote-123',
+    type: 'lifi' as const,
+    tool: 'across',
+    toolDetails: { key: 'across', name: 'Across', logoURI: '' },
+    includedSteps: [],
+    action: {
+      fromToken: {
+        chainId: fromChainId,
+        address: fromTokenAddress,
+        symbol: 'USDC',
+        decimals: 6,
+        name: 'USD Coin',
+        priceUSD: '1',
+      },
+      toToken: {
+        chainId: toChainId,
+        address: toTokenAddress,
+        symbol: 'USDC',
+        decimals: 6,
+        name: 'USD Coin',
+        priceUSD: '1',
+      },
+      fromAmount,
+      fromAddress,
+      toAddress,
+      fromChainId,
+      toChainId,
+      slippage: 0.005,
+    },
+    estimate: {
+      tool: 'across',
+      fromAmount,
+      fromAmountUSD: '10000',
+      toAmount: overrides?.toAmount ?? '9950000000',
+      toAmountMin: '9900000000',
+      toAmountUSD: '9950',
+      approvalAddress: '0x0000000000000000000000000000000000000000',
+      executionDuration: 300,
+      gasCosts: [
+        {
+          type: 'SEND' as const,
+          price: '50',
+          estimate: '21000',
+          limit: '26250',
+          amount: '50000000',
+          amountUSD: '5',
+          token: {
+            chainId: fromChainId,
+            address: '0x0000000000000000000000000000000000000000',
+            symbol: 'ETH',
+            decimals: 18,
+            name: 'Ethereum',
+            priceUSD: '3000',
+          },
+        },
+      ],
+    },
+  };
+}
+
+/**
+ * Creates a BridgeQuote with matching requestParams for the default LiFi step.
+ */
+function createTestQuote(
+  routeOverrides?: Parameters<typeof createLiFiStep>[0],
+  paramOverrides?: Partial<BridgeQuoteParams>,
+): BridgeQuote<LiFiStep> {
+  const lifiStep = createLiFiStep(routeOverrides);
+
+  const defaultParams: BridgeQuoteParams = {
+    fromChain: 42161,
+    toChain: 1151111081099710,
+    fromToken: TOKEN_ADDR,
+    toToken: TOKEN_ADDR,
+    fromAddress: SENDER_ADDR,
+    toAddress: SENDER_ADDR,
+    fromAmount: 10000000000n,
+  };
+
+  return {
+    id: 'quote-123',
+    tool: 'across',
+    fromAmount: 10000000000n,
+    toAmount: 9950000000n,
+    toAmountMin: 9900000000n,
+    executionDuration: 300,
+    gasCosts: 50000000n,
+    feeCosts: 0n,
+    route: lifiStep,
+    requestParams: { ...defaultParams, ...paramOverrides },
+  };
+}
+
+/**
+ * Validation regex patterns used by LiFiBridge.execute() assertion messages.
+ * If an error message matches any of these, it came from route validation.
+ */
+const VALIDATION_PATTERNS = [
+  /Route fromChainId .* does not match requested/,
+  /Route toChainId .* does not match requested/,
+  /Route fromToken .* does not match requested/,
+  /Route toToken .* does not match requested/,
+  /Route toAddress .* does not match requested/,
+  /Route fromAddress .* does not match requested/,
+  /Route fromAmount .* does not match requested/,
+  /Route toAmount .* is less than requested/,
+  /Route fromAmount must be positive/,
+];
+
+function isValidationError(msg: string): boolean {
+  return VALIDATION_PATTERNS.some((pattern) => pattern.test(msg));
+}
+
+describe('LiFiBridge.execute() route validation', function () {
+  // Allow extra time for tests that pass validation and reach SDK execution
+  this.timeout(15000);
+
+  let bridge: LiFiBridge;
+
+  beforeEach(() => {
+    bridge = new LiFiBridge(BRIDGE_CONFIG, testLogger);
+  });
+
+  it('should pass validation when all route fields match requestParams', async () => {
+    const quote = createTestQuote();
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      // If it resolves, validation definitely passed
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      // Post-validation error (SDK/RPC). Verify it is NOT a route validation error.
+      expect(
+        isValidationError(msg),
+        `Expected non-validation error but got: ${msg}`,
+      ).to.equal(false);
+    }
+  });
+
+  it('should throw when route fromChainId does not match requested', async () => {
+    const quote = createTestQuote({ fromChainId: 999 }, { fromChain: 42161 });
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('999');
+      expect(msg).to.include('42161');
+      expect(msg).to.include('fromChainId');
+    }
+  });
+
+  it('should throw when route toChainId does not match requested', async () => {
+    const quote = createTestQuote(
+      { toChainId: 888 },
+      { toChain: 1151111081099710 },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('888');
+      expect(msg).to.include('1151111081099710');
+      expect(msg).to.include('toChainId');
+    }
+  });
+
+  it('should throw when route fromToken does not match requested', async () => {
+    const quote = createTestQuote(
+      { fromTokenAddress: BAD_ADDR },
+      { fromToken: TOKEN_ADDR },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('fromToken');
+      // Error message should contain the mismatched address value
+      expect(msg.toLowerCase()).to.include(BAD_ADDR.toLowerCase());
+    }
+  });
+
+  it('should throw when route toToken does not match requested', async () => {
+    const quote = createTestQuote(
+      { toTokenAddress: BAD_ADDR },
+      { toToken: TOKEN_ADDR },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('toToken');
+      expect(msg.toLowerCase()).to.include(BAD_ADDR.toLowerCase());
+    }
+  });
+
+  it('should throw when route toAddress does not match requested', async () => {
+    const quote = createTestQuote(
+      { toAddress: BAD_ADDR },
+      { toAddress: SENDER_ADDR },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('toAddress');
+    }
+  });
+
+  it('should throw when route fromAddress does not match requested', async () => {
+    const quote = createTestQuote(
+      { fromAddress: BAD_ADDR },
+      { fromAddress: SENDER_ADDR },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('fromAddress');
+    }
+  });
+
+  it('should pass validation when fromAmount is omitted in requestParams', async () => {
+    // Route has fromAmount='99999' but requestParams has no fromAmount.
+    // The fromAmount assertion is skipped when requestParams.fromAmount is undefined.
+    // The positive amount check still passes (99999 > 0).
+    const quote = createTestQuote(
+      { fromAmount: '99999' },
+      { fromAmount: undefined },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(
+        isValidationError(msg),
+        `Expected non-validation error but got: ${msg}`,
+      ).to.equal(false);
+    }
+  });
+
+  it('should throw when route fromAmount does not match requested', async () => {
+    const quote = createTestQuote(
+      { fromAmount: '9999999999' },
+      { fromAmount: 10000000000n },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('9999999999');
+      expect(msg).to.include('10000000000');
+      expect(msg).to.include('fromAmount');
+    }
+  });
+
+  it('should throw when route fromAmount is zero', async () => {
+    // fromAmount=0n is falsy, so the mismatch assertion is skipped.
+    // But the positive amount check catches it.
+    const quote = createTestQuote(
+      { fromAmount: '0' },
+      { fromAmount: undefined },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('must be positive');
+    }
+  });
+
+  it('should match addresses case-insensitively (mixed vs uppercase)', async () => {
+    // Route uses lowercase a-f, requestParams uses uppercase A-F
+    // Both should match after toLowerCase()
+    const mixedCaseToken = '0xaabb000000000000000000000000000000001122';
+    const upperCaseToken = '0xAABB000000000000000000000000000000001122';
+    const mixedCaseSender = '0xddee000000000000000000000000000000003344';
+    const upperCaseSender = '0xDDEE000000000000000000000000000000003344';
+
+    const quote = createTestQuote(
+      {
+        fromTokenAddress: mixedCaseToken,
+        toTokenAddress: mixedCaseToken,
+        fromAddress: mixedCaseSender,
+        toAddress: mixedCaseSender,
+      },
+      {
+        fromToken: upperCaseToken,
+        toToken: upperCaseToken,
+        fromAddress: upperCaseSender,
+        toAddress: upperCaseSender,
+      },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(
+        isValidationError(msg),
+        `Expected non-validation error but got: ${msg}`,
+      ).to.equal(false);
+    }
+  });
+
+  it('should throw when requestParams.fromAmount is 0n and route has positive amount', async () => {
+    // Validates the fix for the fromAmount=0n truthiness bypass:
+    // 0n was falsy so `if (requestParams.fromAmount)` would skip the comparison.
+    // With `!== undefined`, a 0n request is correctly compared against the route amount.
+    const quote = createTestQuote({ fromAmount: '1' }, { fromAmount: 0n });
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('fromAmount');
+    }
+  });
+
+  it('should pass validation for toAmount quote path (fromAmount undefined, toAmount present)', async () => {
+    // Tests reverse-quote pattern where toAmount is set and fromAmount is undefined.
+    // The fromAmount equality check is skipped when requestParams.fromAmount is undefined.
+    // The toAmount equality check passes because route.toAmount matches requestParams.toAmount.
+    const quote = createTestQuote(
+      { fromAmount: '5000000000', toAmount: '5000000000' },
+      { fromAmount: undefined, toAmount: 5000000000n },
+    );
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(
+        isValidationError(msg),
+        `Expected non-validation error but got: ${msg}`,
+      ).to.equal(false);
+    }
+  });
+
+  it('should throw when route toAmount is less than requested for reverse quote', async () => {
+    // Route estimate.toAmount='100' but requestParams.toAmount=123n -> 100 < 123, should throw
+    const quote = createTestQuote(
+      { toAmount: '100' },
+      { fromAmount: undefined, toAmount: 123n },
+    );
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('toAmount');
+      expect(msg).to.include('100');
+      expect(msg).to.include('123');
+      expect(msg).to.include('is less than');
+    }
+  });
+
+  it('should pass validation when route toAmount exceeds requested (reverse quote)', async () => {
+    // paulbalaji reproduction: requested 1000000, LiFi returned 1000002.
+    // >= semantics: 1000002 >= 1000000 passes validation.
+    const quote = createTestQuote(
+      { toAmount: '1000002' },
+      { fromAmount: undefined, toAmount: 1000000n },
+    );
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(
+        isValidationError(msg),
+        `Expected non-validation error but got: ${msg}`,
+      ).to.equal(false);
+    }
+  });
+});
+
+describe('LiFiBridge.quote() input validation', function () {
+  let bridge: LiFiBridge;
+
+  beforeEach(() => {
+    bridge = new LiFiBridge(BRIDGE_CONFIG, testLogger);
+  });
+
+  it('should throw when fromAmount is 0n', async () => {
+    try {
+      await bridge.quote({
+        fromChain: 42161,
+        toChain: 1151111081099710,
+        fromToken: TOKEN_ADDR,
+        toToken: TOKEN_ADDR,
+        fromAddress: SENDER_ADDR,
+        fromAmount: 0n,
+      });
+      expect.fail('Expected quote to throw');
+    } catch (error: unknown) {
+      expect((error as Error).message).to.include(
+        'fromAmount must be positive',
+      );
+    }
+  });
+
+  it('should throw when toAmount is 0n', async () => {
+    try {
+      await bridge.quote({
+        fromChain: 42161,
+        toChain: 1151111081099710,
+        fromToken: TOKEN_ADDR,
+        toToken: TOKEN_ADDR,
+        fromAddress: SENDER_ADDR,
+        toAmount: 0n,
+      });
+      expect.fail('Expected quote to throw');
+    } catch (error: unknown) {
+      expect((error as Error).message).to.include('toAmount must be positive');
+    }
+  });
+
+  it('should throw when both fromAmount and toAmount are provided', async () => {
+    try {
+      await bridge.quote({
+        fromChain: 42161,
+        toChain: 1151111081099710,
+        fromToken: TOKEN_ADDR,
+        toToken: TOKEN_ADDR,
+        fromAddress: SENDER_ADDR,
+        fromAmount: 10000000000n,
+        toAmount: 5000000000n,
+      });
+      expect.fail('Expected quote to throw');
+    } catch (error: unknown) {
+      expect((error as Error).message).to.include('Cannot specify both');
+    }
+  });
+
+  it('should throw when neither fromAmount nor toAmount is provided', async () => {
+    try {
+      await bridge.quote({
+        fromChain: 42161,
+        toChain: 1151111081099710,
+        fromToken: TOKEN_ADDR,
+        toToken: TOKEN_ADDR,
+        fromAddress: SENDER_ADDR,
+      });
+      expect.fail('Expected quote to throw');
+    } catch (error: unknown) {
+      expect((error as Error).message).to.include('Must specify either');
+    }
+  });
+});
+
+describe('LiFiBridge.getStatus()', function () {
+  let bridge: LiFiBridge;
+
+  beforeEach(() => {
+    bridge = new LiFiBridge(BRIDGE_CONFIG, testLogger);
+  });
+
+  it('should translate Hyperlane domain IDs to LiFi chain IDs before SDK status lookup', async () => {
+    const originalFetch = globalThis.fetch;
+    let requestUrl = '';
+
+    globalThis.fetch = (async (input: URL | RequestInfo) => {
+      requestUrl = String(input);
+      return {
+        ok: true,
+        json: async () => ({ status: 'NOT_FOUND' }),
+      } as Response;
+    }) as typeof fetch;
+
+    try {
+      const result = await bridge.getStatus('0x1234', 1399811149, 1399811149);
+      const params = new URL(requestUrl).searchParams;
+
+      expect(result.status).to.equal('not_found');
+      expect(params.get('fromChain')).to.equal('1151111081099710');
+      expect(params.get('toChain')).to.equal('1151111081099710');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('LiFiBridge constructor chainMetadataByChainId', function () {
+  it('should resolve Sealevel protocol using a LiFi chain ID mapped from Hyperlane metadata', async () => {
+    const bridge = new LiFiBridge(SOLANA_CHAIN_METADATA_CONFIG, testLogger);
+    const quote = createTestQuote(
+      {
+        toTokenAddress: 'Abcdef123456789ABCDEFGHijklmnopQRSTUVwx',
+      },
+      {
+        toToken: 'abcdef123456789abcdefghijklmnopqrstuvwx',
+      },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include('toToken');
+      expect(msg).to.include('does not match requested');
+    }
+  });
+});