@1delta/trade-sdk 0.1.0

package/README.md

@@ -0,0 +1,63 @@
+# @1delta/trade-sdk
+
+A TypeScript SDK for token swaps and bridge operations.
+
+## Installation
+
+```bash
+pnpm add @1delta/trade-sdk
+```
+
+## Features
+
+- Token swaps
+- Bridge operations
+- Support for multiple DEX aggregators and bridges
+- Type-safe API with TypeScript support
+
+## Basic Usage
+
+```typescript
+import { initialize, fetchBridgeTrade, fetchAggregatorTrade } from '@1delta/trade-sdk';
+import { WalletClient } from 'viem';
+
+// Initialize the SDK
+await initialize({
+  isProductionEnv: true,
+  loadChainData: true,
+  loadSquidData: true,
+  load1deltaConfigs: true
+});
+
+// Set up wallet client
+const walletClient: WalletClient = /* your wallet client */;
+setWalletClient(walletClient);
+
+// Fetch a bridge trade
+const trade = await fetchBridgeTrade(bridge, {
+  fromCurrency: fromToken,
+  toCurrency: toToken,
+  amount: '1000000000000000000', // 1.0 in wei
+  receiver: '0x...',
+  caller: '0x...',
+  slippage: 0.5, // 0.5%
+});
+```
+
+## API
+
+### `initialize(config: SdkConfig): Promise<void>`
+
+Initializes the SDK with the given configuration.
+
+### `setWalletClient(walletClient: WalletClient): void`
+
+Sets the wallet client for transaction signing.
+
+### `fetchBridgeTrade(bridge: Bridge, input: BridgeInput): Promise<GenericTrade>`
+
+Fetches a bridge trade quote.
+
+### `fetchAggregatorTrade(aggregator: TradeAggregator, input: AggregatorApiInput): Promise<GenericTrade>`
+
+Fetches a trade quote from a DEX aggregator.

package/dist/aggregator/fetchAggregatorTrade.d.ts

@@ -0,0 +1,6 @@
+export * from './fetchAggregatorTrade';
+import { TradeAggregator } from '@1delta/aggregators';
+import { Bridge } from '@1delta/bridge-configs';
+import { AggregatorApiInput, GenericTrade, OneDeltaInput } from '@1delta/lib-utils';
+export declare const fetchAggregatorTrade: (aggregator: TradeAggregator | Bridge, input: AggregatorApiInput | OneDeltaInput, controller?: AbortController) => Promise<GenericTrade | undefined>;
+//# sourceMappingURL=fetchAggregatorTrade.d.ts.map

package/dist/aggregator/fetchAggregatorTrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchAggregatorTrade.d.ts","sourceRoot":"","sources":["../../src/aggregator/fetchAggregatorTrade.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,OAAO,EAGL,eAAe,EAChB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,MAAM,EAAsB,MAAM,wBAAwB,CAAA;AACnE,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACd,MAAM,mBAAmB,CAAA;AAI1B,eAAO,MAAM,oBAAoB,GAC/B,YAAY,eAAe,GAAG,MAAM,EACpC,OAAO,kBAAkB,GAAG,aAAa,EACzC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAgBlC,CAAA"}

package/dist/aggregator/fetchAggregatorTrade.js

@@ -0,0 +1,14 @@
+export * from './fetchAggregatorTrade';
+import { fetchAggregatorTrade as fetchAggregatorTradeWithoutConfigs, getAvailableAggregators, } from '@1delta/aggregators';
+import { getSwapAggregators } from '@1delta/bridge-configs';
+import { fetchBridgeTrade } from '../bridge';
+export const fetchAggregatorTrade = async (aggregator, input, controller) => {
+    if (!getAvailableAggregators(input.chainId))
+        return undefined;
+    if (getSwapAggregators().includes(aggregator)) {
+        return await fetchBridgeTrade(aggregator, { ...input, order: 'CHEAPEST' }, controller);
+    }
+    else {
+        return await fetchAggregatorTradeWithoutConfigs(aggregator, input, controller);
+    }
+};

package/dist/aggregator/getAvailableAggregators.d.ts

@@ -0,0 +1,2 @@
+export declare const getAvailableAggregators: (chainId: string) => string[];
+//# sourceMappingURL=getAvailableAggregators.d.ts.map

package/dist/aggregator/getAvailableAggregators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAvailableAggregators.d.ts","sourceRoot":"","sources":["../../src/aggregator/getAvailableAggregators.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,uBAAuB,GAAI,SAAS,MAAM,KAAG,MAAM,EAK/D,CAAA"}

package/dist/aggregator/getAvailableAggregators.js

@@ -0,0 +1,11 @@
+import { getAvailableAggregators as getAvailableAggregatorsWithoutBridge } from '@1delta/aggregators';
+import { Bridge } from '@1delta/bridge-configs';
+import { SupportedChainId } from '@1delta/lib-utils';
+const TRADE_AGGREGATORS_FROM_BRIDGE_PER_CHAIN = {
+    [SupportedChainId.MOONBEAM]: [Bridge.Zenlink],
+};
+export const getAvailableAggregators = (chainId) => {
+    const tradeAggregators = getAvailableAggregatorsWithoutBridge(chainId) ?? [];
+    const bridgeAggregators = TRADE_AGGREGATORS_FROM_BRIDGE_PER_CHAIN[chainId] ?? [];
+    return [...tradeAggregators, ...bridgeAggregators];
+};

package/dist/aggregator/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetchAggregatorTrade';
+export * from './getAvailableAggregators';
+//# sourceMappingURL=index.d.ts.map

package/dist/aggregator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aggregator/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,2BAA2B,CAAA"}

package/dist/aggregator/index.js

@@ -0,0 +1,2 @@
+export * from './fetchAggregatorTrade';
+export * from './getAvailableAggregators';

package/dist/bridge/fetchBridgeTrade.d.ts

@@ -0,0 +1,5 @@
+import { Bridge } from '@1delta/bridge-configs';
+import { GenericTrade } from '@1delta/lib-utils';
+import { BridgeInput } from '../types';
+export declare const fetchBridgeTrade: (bridge: Bridge, input: BridgeInput, controller?: AbortController) => Promise<GenericTrade | undefined>;
+//# sourceMappingURL=fetchBridgeTrade.d.ts.map

package/dist/bridge/fetchBridgeTrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchBridgeTrade.d.ts","sourceRoot":"","sources":["../../src/bridge/fetchBridgeTrade.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAU/C,OAAO,EAKL,YAAY,EAWb,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,OAAO,WAAW,EAClB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAiMlC,CAAA"}

package/dist/bridge/fetchBridgeTrade.js

@@ -0,0 +1,195 @@
+import { convertRawAmount } from '@1delta/aggregators';
+import { Bridge } from '@1delta/bridge-configs';
+import { buildTransactionData, getQuote, getRoute, getStatus, } from '@1delta/bridge-core';
+import { ChainType, ChainUtils, CurrencyHandler, isDirectlyPermittable, NATIVE_PLACEHOLDER, PermitShared, TradeType, } from '@1delta/lib-utils';
+export const fetchBridgeTrade = async (bridge, input, controller) => {
+    const inputSlippage = input.slippage;
+    const fromChain = input.fromCurrency.chainId;
+    const fromCurrencyAddress = CurrencyHandler.isNative(input.fromCurrency) &&
+        !ChainUtils.isFuel(fromChain)
+        ? NATIVE_PLACEHOLDER
+        : CurrencyHandler.wrappedAddress(input.fromCurrency);
+    const fromCurrencyDecimals = input.fromCurrency.decimals;
+    const toChain = input.toCurrency.chainId;
+    const toCurrencyAddress = CurrencyHandler.isNative(input.toCurrency) && !ChainUtils.isFuel(toChain)
+        ? NATIVE_PLACEHOLDER
+        : CurrencyHandler.wrappedAddress(input.toCurrency);
+    const toCurrencyDecimals = input.toCurrency.decimals;
+    const caller = input.caller;
+    const receiver = input.receiver;
+    const amount = input.swapAmount;
+    const slippage = input.slippage;
+    const canDirectlyPermit = isDirectlyPermittable(input.fromCurrency);
+    const params = {
+        fromChainId: fromChain,
+        fromAmount: amount,
+        fromTokenAddress: fromCurrencyAddress,
+        fromTokenDecimals: fromCurrencyDecimals,
+        toChainId: toChain,
+        toTokenAddress: toCurrencyAddress,
+        toTokenDecimals: toCurrencyDecimals,
+        fromAddress: caller,
+        toAddress: receiver,
+        slippage,
+        permitEnabled: input.usePermit,
+        message: input.message,
+        canDirectlyPermit,
+        fromHash: undefined,
+        referrer: undefined,
+        order: input.order,
+        destinationGasLimit: input.destinationGasLimit,
+    };
+    const route = ChainUtils.isAddress(caller, fromChain) &&
+        ChainUtils.isAddress(receiver, toChain)
+        ? await getRoute(bridge, params, controller?.signal)
+        : await getQuote(bridge, params, controller?.signal);
+    if (route?.code)
+        throw new Error(`${route?.code}: ${route?.message}`);
+    const trade = getTradeFromBridgeApi(bridge, route, input.swapAmount, input.fromCurrency, input.toCurrency, input.tradeType, inputSlippage);
+    if (!trade)
+        return undefined;
+    const refresh = async (inputOverride) => {
+        const newAggregatorInput = {
+            ...input,
+            slippage: inputOverride?.slippage ?? input.slippage,
+        };
+        return fetchBridgeTrade(bridge, newAggregatorInput);
+    };
+    if (route?.orderData?.broadcastIntent) {
+        const order = {
+            dataToSign: route.orderData.typedData
+                ? {
+                    typedData: route.orderData.typedData,
+                    chainId: fromChain,
+                }
+                : undefined,
+            broadcastIntent: async (orderSignature, permitData) => {
+                if (!route.orderData)
+                    throw new Error('no order data');
+                if (permitData) {
+                    const { v, r, s } = PermitShared.splitSignatureToVRS(permitData.permitSignature);
+                    const erc20Permit = {
+                        value: permitData.permitValue,
+                        deadline: permitData.permitDeadline,
+                        v: Number(v),
+                        r,
+                        s,
+                    };
+                    await route.orderData.broadcastIntent(orderSignature, erc20Permit);
+                }
+                else {
+                    const { orderId } = await route.orderData.broadcastIntent(orderSignature);
+                    if (orderId)
+                        route.interfaceParamData = { orderId };
+                }
+                return { success: true };
+            },
+            trackIntent: async () => {
+                // Check for 30 seconds
+                const maxAttempts = 30;
+                const delayMs = 1000;
+                for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                    const status = await getStatus(bridge, params, route.interfaceParamData);
+                    if (status?.fromHash) {
+                        const txTrackingInputs = {
+                            [ChainType.EVM]: {
+                                chainId: params.fromChainId,
+                                hash: status.fromHash,
+                            },
+                        };
+                        return txTrackingInputs;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+                throw new Error('Failed to retrieve transaction hash after 30 seconds');
+            },
+        };
+        return {
+            ...trade,
+            order,
+            refresh,
+        };
+    }
+    else {
+        const assemble = !ChainUtils.isAddress(caller, fromChain) ||
+            !ChainUtils.isAddress(receiver, toChain)
+            ? undefined
+            : async () => {
+                try {
+                    const tx = route?.transactionData ??
+                        (await buildTransactionData(bridge, params, route?.interfaceParamData));
+                    if (ChainUtils.isEvm(fromChain)) {
+                        const validTx = validateEVMBridgeTx(route, tx);
+                        return {
+                            [ChainType.EVM]: {
+                                calldata: validTx.data,
+                                value: validTx.value,
+                                to: validTx.to,
+                            },
+                        };
+                    }
+                    else if (ChainUtils.isFuel(fromChain)) {
+                        if (!tx?.data)
+                            throw new Error('Missing Fuel transaction data');
+                        return {
+                            [ChainType.FUEL]: {
+                                calldata: tx.data,
+                            },
+                        };
+                    }
+                    return undefined;
+                }
+                catch (error) {
+                    console.log(`cannot compose ${bridge.toString()} bridge tx:`, error);
+                    return undefined;
+                }
+            };
+        return {
+            ...trade,
+            assemble,
+            refresh,
+        };
+    }
+};
+const getTradeFromBridgeApi = (bridge, data, amount, fromToken, toToken, tradeType, slippage) => {
+    if (!data ||
+        !fromToken ||
+        !toToken ||
+        !amount ||
+        slippage === undefined ||
+        BigInt(data.toAmount) <= 0n)
+        return undefined;
+    return {
+        tradeType: tradeType || TradeType.EXACT_INPUT,
+        inputAmount: CurrencyHandler.fromRawAmount(fromToken, amount),
+        outputAmount: CurrencyHandler.fromRawAmount(toToken, data.toAmount),
+        aggregator: bridge,
+        target: data.transactionData?.to ?? data.depositContract,
+        approvalTarget: data.depositContract,
+        crossChainParams: data.interfaceParamData,
+        stringified: `${amount}-${fromToken.chainId}-${fromToken.symbol}->${data.toAmount}-${toToken.chainId}-${toToken.symbol}-${bridge}`,
+        inputAmountRealized: convertRawAmount(amount, fromToken.decimals),
+        outputAmountRealized: convertRawAmount(data.toAmount, toToken.decimals),
+        estimatedDuration: data.estimatedDuration,
+        skipApprove: bridge === Bridge.LAYERSWAP,
+        gasAmount: safeBigInt(data.fee.destinationGasFee ?? ''),
+        slippage,
+    };
+};
+const validateEVMBridgeTx = (route, tx) => {
+    if (!route)
+        throw new Error('no data');
+    if (!tx)
+        throw new Error('no tx');
+    if (tx?.code)
+        throw new Error(`${tx.code}: ${tx?.message}`);
+    return tx;
+};
+const safeBigInt = (value) => {
+    try {
+        return BigInt(value);
+    }
+    catch {
+        return undefined;
+    }
+};

package/dist/bridge/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fetchBridgeTrade';
+//# sourceMappingURL=index.d.ts.map

package/dist/bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bridge/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA"}

package/dist/bridge/index.js

@@ -0,0 +1 @@
+export * from './fetchBridgeTrade';

package/dist/composedTrades/across/acrossRoutes.d.ts

@@ -0,0 +1,17 @@
+import { RawCurrency } from '@1delta/lib-utils';
+interface AcrossRouteResponse {
+    originChainId: number;
+    originToken: string;
+    destinationChainId: number;
+    destinationToken: string;
+    originTokenSymbol: string;
+    destinationTokenSymbol: string;
+    isNative: boolean;
+}
+export declare const fetchAcrossRoutes: (fromChainId: string, toChainId: string) => Promise<AcrossRouteResponse[]>;
+/**
+ * Enhanced route selection with clearer priority logic
+ */
+export declare const selectAcrossRoute: (routes: AcrossRouteResponse[], fromCurrency: RawCurrency, toCurrency: RawCurrency) => AcrossRouteResponse | undefined;
+export {};
+//# sourceMappingURL=acrossRoutes.d.ts.map

package/dist/composedTrades/across/acrossRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acrossRoutes.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossRoutes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEhE,UAAU,mBAAmB;IAC3B,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,gBAAgB,EAAE,MAAM,CAAA;IACxB,iBAAiB,EAAE,MAAM,CAAA;IACzB,sBAAsB,EAAE,MAAM,CAAA;IAC9B,QAAQ,EAAE,OAAO,CAAA;CAClB;AAKD,eAAO,MAAM,iBAAiB,GAC5B,aAAa,MAAM,EACnB,WAAW,MAAM,KAChB,OAAO,CAAC,mBAAmB,EAAE,CAK/B,CAAA;AA4DD;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,mBAAmB,EAAE,EAC7B,cAAc,WAAW,EACzB,YAAY,WAAW,KACtB,mBAAmB,GAAG,SAyBxB,CAAA"}

package/dist/composedTrades/across/acrossRoutes.js

@@ -0,0 +1,64 @@
+import { CurrencyHandler } from '@1delta/lib-utils';
+const getRouteURL = (fromChainId, toChainId) => `https://app.across.to/api/available-routes?originChainId=${fromChainId}&destinationChainId=${toChainId}`;
+export const fetchAcrossRoutes = async (fromChainId, toChainId) => {
+    const url = getRouteURL(fromChainId, toChainId);
+    const response = await fetch(url);
+    const data = await response.json();
+    return data;
+};
+const PRIORITY_STABLE_SYMBOLS = ['USDC', 'USDC.e', 'USDT'];
+/**
+ * Improved route selection with priority-based matching
+ */
+const findDestinationMatch = (routes, fromCurrency, toCurrency) => {
+    const destinationRoutes = routes.filter((route) => route.destinationToken.toLowerCase() ===
+        CurrencyHandler.wrapped(toCurrency).address.toLowerCase());
+    return destinationRoutes.find((route) => {
+        if (CurrencyHandler.isNative(fromCurrency))
+            return route.isNative;
+        return !route.isNative;
+    });
+};
+const findSourceMatch = (routes, fromCurrency) => {
+    return routes.find((route) => (route.originToken.toLowerCase() === fromCurrency.address.toLowerCase() &&
+        !route.isNative) ||
+        (route.isNative && CurrencyHandler.isNative(fromCurrency)));
+};
+const findStableMatch = (routes, toCurrency) => {
+    if (!toCurrency.symbol?.includes('USD'))
+        return undefined;
+    for (const symbol of PRIORITY_STABLE_SYMBOLS) {
+        const stableRoute = routes.find((route) => route.originTokenSymbol.includes(symbol));
+        if (stableRoute)
+            return stableRoute;
+    }
+    return undefined;
+};
+const findNativeMatch = (routes) => {
+    return routes.find((route) => route.originTokenSymbol === 'WETH' && !route.isNative);
+};
+/**
+ * Enhanced route selection with clearer priority logic
+ */
+export const selectAcrossRoute = (routes, fromCurrency, toCurrency) => {
+    if (routes.length === 0)
+        return undefined;
+    // Priority 1: Exact destination match
+    const destinationMatch = findDestinationMatch(routes, fromCurrency, toCurrency);
+    if (destinationMatch)
+        return destinationMatch;
+    // Priority 2: Exact source match
+    const sourceMatch = findSourceMatch(routes, fromCurrency);
+    if (sourceMatch)
+        return sourceMatch;
+    // Priority 3: Stable coin preference for USD targets
+    const stableMatch = findStableMatch(routes, toCurrency);
+    if (stableMatch)
+        return stableMatch;
+    // Priority 4: Native/WETH fallback
+    const nativeMatch = findNativeMatch(routes);
+    if (nativeMatch)
+        return nativeMatch;
+    // Fallback to first available
+    return routes[0];
+};

package/dist/composedTrades/across/acrossWithSwap.d.ts

@@ -0,0 +1,11 @@
+import { GenericTrade, RawCurrency } from '@1delta/lib-utils';
+import { BridgeInput } from '../../types';
+export interface AcrossWithSwapInput extends BridgeInput {
+    bridgeToCurrency: RawCurrency | undefined;
+}
+export declare const fetchAcrossTradeWithSwap: (input: AcrossWithSwapInput, controller?: AbortController) => Promise<{
+    trade: GenericTrade | undefined;
+    receiver: string;
+}>;
+export default fetchAcrossTradeWithSwap;
+//# sourceMappingURL=acrossWithSwap.d.ts.map

package/dist/composedTrades/across/acrossWithSwap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acrossWithSwap.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossWithSwap.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,YAAY,EAKZ,WAAW,EAEZ,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAA;AAO1D,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,gBAAgB,EAAE,WAAW,GAAG,SAAS,CAAA;CAC1C;AAED,eAAO,MAAM,wBAAwB,GACnC,OAAO,mBAAmB,EAC1B,aAAa,eAAe,KAC3B,OAAO,CAAC;IAAE,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA6C/D,CAAA;AAED,eAAe,wBAAwB,CAAA"}

package/dist/composedTrades/across/acrossWithSwap.integration.spec.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=acrossWithSwap.integration.spec.d.ts.map

package/dist/composedTrades/across/acrossWithSwap.integration.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acrossWithSwap.integration.spec.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossWithSwap.integration.spec.ts"],"names":[],"mappings":""}

package/dist/composedTrades/across/acrossWithSwap.integration.spec.js

@@ -0,0 +1,116 @@
+"use strict";
+// import { ChainId, Percent, TradeType } from '@1delta/base-sdk'
+// import { beforeEach, describe, expect, it, vi } from 'vitest'
+// import { USDC_ON } from '@/lib/constants/addresses'
+// import { getAcrossMulticallHandler } from '@/lib/constants/addresses/multicall/across'
+// import { CurrencyHandler } from '@/lib/services/currencyUtils'
+// import { nativeOnChain } from '@/lib/services/tokens'
+// import { RawCurrency } from '@/lib/types'
+// import fetchAcrossTradeWithSwap, { AcrossWithSwapInput } from './acrossWithSwap'
+// describe('fetchAcrossTradeWithSwap', () => {
+//   beforeEach(() => {
+//     vi.clearAllMocks()
+//   })
+//   const ACCOUNT = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'
+//   const WBTC_OP: RawCurrency = {
+//     chainId: ChainId.OP_MAINNET,
+//     address: '0x68f180fcCe6836688e9084f035309E29Bf0A2095',
+//     decimals: 8,
+//     symbol: 'WBTC',
+//     name: 'Wrapped BTC',
+//   }
+//   it('Bridge Native', async () => {
+//     // Receive Native only if receiver address is EOA
+//     const fromCurrency = nativeOnChain(ChainId.ARBITRUM_ONE)
+//     const toCurrency = nativeOnChain(ChainId.OP_MAINNET)
+//     const bridgeToCurrency = CurrencyHandler.wrapped(toCurrency)
+//     const input: AcrossWithSwapInput = {
+//       tradeType: TradeType.EXACT_INPUT,
+//       fromCurrency,
+//       bridgeToCurrency,
+//       toCurrency,
+//       slippage: 1,
+//       swapAmount: '1000000000000000000',
+//       caller: ACCOUNT,
+//       receiver: ACCOUNT,
+//       order: 'FASTEST',
+//     }
+//     const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input)
+//     console.log('result', result, receiver)
+//     expect(result).toBeDefined()
+//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
+//     expect(result?.outputAmount.currency).toEqual(toCurrency)
+//     expect(receiver).toEqual(ACCOUNT)
+//     expect(result?.crossChainParams?.message).toBeUndefined()
+//   })
+//   it('Bridge Native -> WETH', async () => {
+//     // Receive Wrapped Native only if receiver address is contract
+//     const fromCurrency = nativeOnChain(ChainId.ARBITRUM_ONE)
+//     const toCurrency = CurrencyHandler.wrapped(
+//       nativeOnChain(ChainId.OP_MAINNET)
+//     )
+//     const input: AcrossWithSwapInput = {
+//       tradeType: TradeType.EXACT_INPUT,
+//       fromCurrency,
+//       bridgeToCurrency: toCurrency,
+//       toCurrency,
+//       slippage: 1,
+//       swapAmount: '1000000000000000000',
+//       caller: ACCOUNT,
+//       receiver: ACCOUNT,
+//       order: 'FASTEST',
+//     }
+//     const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input)
+//     console.log('result', result, receiver)
+//     expect(result).toBeDefined()
+//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
+//     expect(result?.outputAmount.currency).toEqual(toCurrency)
+//     expect(receiver).toEqual(getAcrossMulticallHandler(ChainId.OP_MAINNET))
+//     expect(result?.crossChainParams?.message).toBeDefined()
+//   })
+//   it('Bridge USDC', async () => {
+//     const fromCurrency = USDC_ON(ChainId.ARBITRUM_ONE)
+//     const toCurrency = USDC_ON(ChainId.OP_MAINNET)
+//     const input: AcrossWithSwapInput = {
+//       tradeType: TradeType.EXACT_INPUT,
+//       fromCurrency,
+//       bridgeToCurrency: toCurrency,
+//       toCurrency,
+//       slippage: 1,
+//       swapAmount: '1000000',
+//       caller: ACCOUNT,
+//       receiver: ACCOUNT,
+//       order: 'FASTEST',
+//     }
+//     const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input)
+//     console.log('result', result, receiver)
+//     expect(result).toBeDefined()
+//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
+//     expect(result?.outputAmount.currency).toEqual(toCurrency)
+//     expect(receiver).toEqual(ACCOUNT)
+//     expect(result?.crossChainParams?.message).toBeUndefined()
+//   })
+//   it('Bridge + Swap', async () => {
+//     const fromCurrency = USDC_ON(ChainId.ARBITRUM_ONE)
+//     const bridgeToCurrency = USDC_ON(ChainId.OP_MAINNET)
+//     const toCurrency = WBTC_OP
+//     const input: AcrossWithSwapInput = {
+//       tradeType: TradeType.EXACT_INPUT,
+//       fromCurrency,
+//       bridgeToCurrency,
+//       toCurrency,
+//       slippage: 1,
+//       swapAmount: '1000000',
+//       caller: ACCOUNT,
+//       receiver: ACCOUNT,
+//       order: 'FASTEST',
+//     }
+//     const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input)
+//     console.log('result', result, receiver)
+//     expect(result).toBeDefined()
+//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
+//     expect(result?.outputAmount.currency).toEqual(toCurrency)
+//     expect(receiver).toEqual(getAcrossMulticallHandler(ChainId.OP_MAINNET))
+//     expect(result?.crossChainParams?.message).toBeDefined()
+//   })
+// }, 20000)