validate USDT params for LayerZero bridge

Author: Mo-Hussain

typescript/rebalancer/src/bridges/LayerZeroBridge.test.ts

@@ -11,6 +11,7 @@ import {
   ARB_HUB_EID,
   getRouteNetwork,
   getOFTContractForRoute,
+  getUSDTAddress,
   getEID,
   SOLANA_CHAIN_ID,
   SOLANA_OFT_PROGRAM,
@@ -247,11 +248,72 @@ describe('LayerZeroBridge', function () {
       expect(quote.toAmount).to.equal(9997000n);
     });
 
+    it('rejects non-USDT fromToken params', async () => {
+      let threw = false;
+      try {
+        await bridge.quote({
+          ...BASE_PARAMS,
+          fromToken: '0x1111111111111111111111111111111111111111',
+          fromAmount: 10000000000n,
+        });
+      } catch (error) {
+        threw = true;
+        expect((error as Error).message).to.match(/USDT-only.*fromToken/i);
+      }
+      expect(threw).to.equal(true);
+    });
+
+    it('rejects non-USDT toToken params', async () => {
+      let threw = false;
+      try {
+        await bridge.quote({
+          ...BASE_PARAMS,
+          toToken: '0x1111111111111111111111111111111111111111',
+          fromAmount: 10000000000n,
+        });
+      } catch (error) {
+        threw = true;
+        expect((error as Error).message).to.match(/USDT-only.*toToken/i);
+      }
+      expect(threw).to.equal(true);
+    });
+
+    it('accepts mixed-case EVM USDT token params', async () => {
+      const quoteOFTResponse = createMockQuoteOFTResponse();
+      const quoteSendResponse = createMockQuoteSendResponse();
+
+      const quoteOFTStub = sinon
+        .stub()
+        .resolves([
+          quoteOFTResponse.oftLimit,
+          quoteOFTResponse.oftFeeDetails,
+          quoteOFTResponse.oftReceipt,
+        ]);
+      const quoteSendStub = sinon.stub().resolves([quoteSendResponse]);
+      stubContractConstructor(() => ({
+        quoteOFT: quoteOFTStub,
+        quoteSend: quoteSendStub,
+      }));
+
+      const quote = await bridge.quote({
+        ...BASE_PARAMS,
+        fromToken: BASE_PARAMS.fromToken.toUpperCase(),
+        toToken: BASE_PARAMS.toToken.toUpperCase(),
+        fromAmount: 10000000000n,
+      });
+
+      expect(quote.tool).to.equal('layerzero');
+      expect(quoteOFTStub.calledOnce).to.equal(true);
+      expect(quoteSendStub.calledOnce).to.equal(true);
+    });
+
     it('quotes non-Solana compose routes through the Arbitrum hub', async () => {
       const composeParams = {
         ...BASE_PARAMS,
         fromChain: TRON_CHAIN_ID,
         toChain: 9745,
+        fromToken: getUSDTAddress(TRON_CHAIN_ID),
+        toToken: getUSDTAddress(9745),
         fromAmount: 10000000000n,
       };
       const { firstHopOFT, secondHopOFT } = getComposeHopContracts(
@@ -327,6 +389,8 @@ describe('LayerZeroBridge', function () {
         ...BASE_PARAMS,
         fromChain: TRON_CHAIN_ID,
         toChain: 9745,
+        fromToken: getUSDTAddress(TRON_CHAIN_ID),
+        toToken: getUSDTAddress(9745),
         fromAmount: 10000000000n,
       };
       const { firstHopOFT, secondHopOFT } = getComposeHopContracts(

typescript/rebalancer/src/bridges/LayerZeroBridge.ts

@@ -86,6 +86,7 @@ export class LayerZeroBridge implements IExternalBridge {
       fromAmount !== undefined || toAmount !== undefined,
       'Must specify either fromAmount or toAmount',
     );
+    this.assertUsdtRoute(params);
 
     const network = getRouteNetwork(fromChain, toChain);
     assert(network, `Unsupported route: ${fromChain} -> ${toChain}`);
@@ -744,4 +745,30 @@ export class LayerZeroBridge implements IExternalBridge {
     assert(rpcUrl, `No RPC URL configured for chain ${chainId}`);
     return rpcUrl;
   }
+
+  private assertUsdtRoute(params: BridgeQuoteParams): void {
+    const { fromChain, toChain, fromToken, toToken } = params;
+    const expectedFromToken = getUSDTAddress(fromChain);
+    const expectedToToken = getUSDTAddress(toChain);
+
+    assert(
+      this.matchesBridgeToken(fromToken, expectedFromToken),
+      `LayerZero bridge is USDT-only: fromToken ${fromToken} does not match USDT ${expectedFromToken} on chain ${fromChain}`,
+    );
+    assert(
+      this.matchesBridgeToken(toToken, expectedToToken),
+      `LayerZero bridge is USDT-only: toToken ${toToken} does not match USDT ${expectedToToken} on chain ${toChain}`,
+    );
+  }
+
+  private matchesBridgeToken(
+    actualToken: string,
+    expectedToken: string,
+  ): boolean {
+    if (/^0x/i.test(actualToken) && /^0x/i.test(expectedToken)) {
+      return actualToken.toLowerCase() === expectedToken.toLowerCase();
+    }
+
+    return actualToken === expectedToken;
+  }
 }