@1delta/trade-sdk 0.1.0

package/dist/composedTrades/across/acrossWithSwap.js

@@ -0,0 +1,122 @@
+import { Bridge } from '@1delta/bridge-configs';
+import { CurrencyHandler, getAcrossMulticallHandler, getSafeChainId, normalizeDecimals, TradeType, } from '@1delta/lib-utils';
+import { fetchBridgeTrade } from '../../bridge/fetchBridgeTrade';
+import { fetchBestTrade } from '../utils/multichainUtils';
+import { createAcrossDrainMessage, createAcrossSwapMessage, } from './calldata/createAcrossMessage';
+export const fetchAcrossTradeWithSwap = async (input, controller) => {
+    if (!input.bridgeToCurrency)
+        throw new Error('BridgeToCurrency undefined');
+    const toChainId = getSafeChainId(input.toCurrency?.chainId);
+    const toTokenIsBridgeToken = CurrencyHandler.equal(input.bridgeToCurrency, CurrencyHandler.wrapped(input.toCurrency));
+    if (toTokenIsBridgeToken) {
+        const toTokenIsWNative = CurrencyHandler.isWNative(input.toCurrency);
+        if (toTokenIsWNative) {
+            // special case: to receive wrapped native receiver must be contract
+            const acrossTrade = await fetchAcrossTradeWithSweep(input, controller);
+            return {
+                trade: acrossTrade,
+                receiver: getAcrossMulticallHandler(toChainId),
+            };
+        }
+        else {
+            // normal case: for all other token receiver can directly be EOA
+            const acrossTrade = await fetchBridgeTrade(Bridge.ACROSS, input, controller);
+            return {
+                trade: acrossTrade,
+                receiver: input.receiver,
+            };
+        }
+    }
+    else {
+        const acrossTrade = await fetchAcrossTradeWithDestinationSwap(input, controller);
+        return {
+            trade: acrossTrade,
+            receiver: getAcrossMulticallHandler(toChainId),
+        };
+    }
+};
+export default fetchAcrossTradeWithSwap;
+const fetchAcrossTradeWithSweep = async (input, controller) => {
+    if (!input.swapAmount)
+        throw new Error('Swap amount undefined');
+    if (!input.fromCurrency)
+        throw new Error('FromCurrency undefined');
+    if (!input.toCurrency)
+        throw new Error('ToCurrency undefined');
+    const toChainId = input.toCurrency.chainId;
+    const message = createAcrossDrainMessage(getAcrossMulticallHandler(toChainId), input.receiver, [input.toCurrency.address]);
+    const acrossInput = {
+        ...input,
+        receiver: getAcrossMulticallHandler(toChainId),
+        message,
+    };
+    const acrossTrade = await fetchBridgeTrade(Bridge.ACROSS, acrossInput, controller);
+    if (!acrossTrade)
+        return undefined;
+    return acrossTrade;
+};
+const fetchAcrossTradeWithDestinationSwap = async (input, controller) => {
+    if (!input.swapAmount)
+        throw new Error('Swap amount undefined');
+    if (!input.fromCurrency)
+        throw new Error('FromCurrency undefined');
+    if (!input.toCurrency)
+        throw new Error('ToCurrency undefined');
+    if (!input.bridgeToCurrency)
+        throw new Error('BridgeToCurrency undefined');
+    const toChainId = input.toCurrency.chainId;
+    const fetchSwapAndMessage = async (amount) => {
+        const destinationSwapInput = {
+            chainId: toChainId,
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency: input.bridgeToCurrency,
+            toCurrency: input.toCurrency,
+            slippage: input.slippage,
+            swapAmount: amount.toString(),
+            txOrigin: getAcrossMulticallHandler(toChainId),
+            caller: getAcrossMulticallHandler(toChainId),
+            receiver: input.receiver,
+            flashSwap: undefined,
+        };
+        const destinationSwapTrade = await fetchBestTrade(destinationSwapInput, controller);
+        if (!destinationSwapTrade || !destinationSwapTrade.assemble)
+            return undefined;
+        const tx = await destinationSwapTrade.assemble();
+        if (!tx?.EVM)
+            return undefined;
+        const message = createAcrossSwapMessage(getAcrossMulticallHandler(toChainId), destinationSwapTrade.inputAmount.currency.address, destinationSwapTrade.inputAmount.amount, destinationSwapTrade.target, [tx.EVM], input.receiver, [destinationSwapTrade.inputAmount.currency.address]);
+        return { message, destinationSwapTrade };
+    };
+    const destinationSwapAmount = normalizeDecimals(BigInt(input.swapAmount), input.fromCurrency.decimals, input.bridgeToCurrency.decimals);
+    const swap = await fetchSwapAndMessage(destinationSwapAmount);
+    if (!swap)
+        return undefined;
+    const acrossInput = {
+        ...input,
+        toCurrency: input.bridgeToCurrency,
+        receiver: getAcrossMulticallHandler(toChainId),
+    };
+    const acrossTrade = await fetchBridgeTrade(Bridge.ACROSS, { ...acrossInput, message: swap.message }, controller);
+    if (!acrossTrade)
+        return undefined;
+    const updatedSwap = await fetchSwapAndMessage(acrossTrade.outputAmount.amount);
+    if (!updatedSwap)
+        return undefined;
+    const updatedAcrossTrade = await fetchBridgeTrade(Bridge.ACROSS, { ...acrossInput, message: updatedSwap.message }, controller);
+    if (!updatedAcrossTrade)
+        return undefined;
+    const refresh = async (inputOverride) => {
+        const newAggregatorInput = {
+            ...input,
+            slippage: inputOverride?.slippage ?? input.slippage,
+        };
+        return (await fetchAcrossTradeWithSwap(newAggregatorInput)).trade;
+    };
+    return {
+        ...updatedAcrossTrade,
+        outputAmount: updatedSwap.destinationSwapTrade.outputAmount,
+        outputAmountRealized: updatedSwap.destinationSwapTrade.outputAmountRealized,
+        stringified: `${updatedAcrossTrade?.stringified}-${updatedSwap.destinationSwapTrade.stringified}`,
+        refresh,
+    };
+};

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

@@ -0,0 +1,5 @@
+import { GenericTrade, RawCurrency } from '@1delta/lib-utils';
+import { BridgeInput } from '../../types';
+export declare const fetchAcrossTradeWithSwaps: (input: BridgeInput, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency | undefined, controller?: AbortController) => Promise<GenericTrade | undefined>;
+export default fetchAcrossTradeWithSwaps;
+//# sourceMappingURL=acrossWithSwaps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"acrossWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossWithSwaps.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,YAAY,EAOZ,WAAW,EAGZ,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAA;AAsB1D,eAAO,MAAM,yBAAyB,GACpC,OAAO,WAAW,EAClB,aAAa,CACX,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,KAC7B,WAAW,GAAG,SAAS,EAC5B,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAoKlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

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

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

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

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

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

@@ -0,0 +1,110 @@
+"use strict";
+// import { ChainId, Percent, TradeType } from '@1delta/base-sdk'
+// import { beforeEach, describe, expect, it, vi } from 'vitest'
+// import { BridgeInput } from '@/hooks/bridge/types'
+// import { USDC_ON } from '@/lib/constants/addresses'
+// import { RawCurrency } from '@/lib/types'
+// import fetchAcrossTradeWithSwaps from './acrossWithSwaps'
+// describe('fetchAcrossTradeWithSwaps', () => {
+//   beforeEach(() => {
+//     vi.clearAllMocks()
+//   })
+//   const ACCOUNT = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'
+//   const WBTC_OP: RawCurrency = {
+//     chainId: ChainId.OP_MAINNET,
+//     address: '0x68f180fcCe6836688e9084f035309E29Bf0A2095',
+//     decimals: 8,
+//     symbol: 'WBTC',
+//     name: 'Wrapped BTC',
+//   }
+//   const WBTC_ARB: RawCurrency = {
+//     chainId: ChainId.ARBITRUM_ONE,
+//     address: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+//     decimals: 8,
+//     symbol: 'WBTC',
+//     name: 'Wrapped BTC',
+//   }
+//   const USDT_ARB: RawCurrency = {
+//     chainId: ChainId.ARBITRUM_ONE,
+//     address: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
+//     decimals: 6,
+//     symbol: 'USDT',
+//     name: 'USDT',
+//   }
+//   const getCurrency = (
+//     chainId: string | undefined,
+//     tokenAddress: string | undefined
+//   ) => {
+//     if (!chainId || !tokenAddress) return undefined
+//     if (
+//       WBTC_ARB.address.toLowerCase() === tokenAddress.toLowerCase() &&
+//       WBTC_ARB.chainId === chainId
+//     )
+//       return WBTC_ARB
+//     if (
+//       WBTC_OP.address.toLowerCase() === tokenAddress.toLowerCase() &&
+//       WBTC_OP.chainId === chainId
+//     )
+//       return WBTC_OP
+//     if (USDC_ON(chainId).address.toLowerCase() === tokenAddress.toLowerCase())
+//       return USDC_ON(chainId)
+//     return undefined
+//   }
+//   it('Bridge', async () => {
+//     const fromCurrency = USDC_ON(ChainId.ARBITRUM_ONE)
+//     const toCurrency = USDC_ON(ChainId.OP_MAINNET)
+//     const input: BridgeInput = {
+//       tradeType: TradeType.EXACT_INPUT,
+//       fromCurrency,
+//       toCurrency,
+//       slippage: 1,
+//       swapAmount: '1000000',
+//       caller: ACCOUNT,
+//       receiver: ACCOUNT,
+//       order: 'FASTEST',
+//     }
+//     const result = await fetchAcrossTradeWithSwaps(input, getCurrency)
+//     console.log('result', result)
+//     expect(result).toBeDefined()
+//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
+//     expect(result?.outputAmount.currency).toEqual(toCurrency)
+//   })
+//   it('Bridge + Swap', async () => {
+//     const fromCurrency = USDC_ON(ChainId.ARBITRUM_ONE)
+//     const toCurrency = WBTC_OP
+//     const input: BridgeInput = {
+//       tradeType: TradeType.EXACT_INPUT,
+//       fromCurrency,
+//       toCurrency,
+//       slippage: 1,
+//       swapAmount: '1000000',
+//       caller: ACCOUNT,
+//       receiver: ACCOUNT,
+//       order: 'FASTEST',
+//     }
+//     const result = await fetchAcrossTradeWithSwaps(input, getCurrency)
+//     console.log('result', result)
+//     expect(result).toBeDefined()
+//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
+//     expect(result?.outputAmount.currency).toEqual(toCurrency)
+//   })
+//   it('Swap + Bridge + Swap', async () => {
+//     const fromCurrency = USDT_ARB
+//     const toCurrency = WBTC_OP
+//     const input: BridgeInput = {
+//       tradeType: TradeType.EXACT_INPUT,
+//       fromCurrency,
+//       toCurrency,
+//       slippage: 1,
+//       swapAmount: '1000000',
+//       caller: ACCOUNT,
+//       receiver: ACCOUNT,
+//       order: 'FASTEST',
+//     }
+//     const result = await fetchAcrossTradeWithSwaps(input, getCurrency)
+//     console.log('result', result)
+//     expect(result).toBeDefined()
+//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
+//     expect(result?.outputAmount.currency).toEqual(toCurrency)
+//   })
+// }, 20000)

package/dist/composedTrades/across/acrossWithSwaps.js

@@ -0,0 +1,121 @@
+import { convertRawAmount } from '@1delta/aggregators';
+import { CurrencyHandler, getDeltaComposerProxyAddress, getForwarderAddress, getSafeChainId, minimumAmountOutFromTrade, nativeOnChain, splitSlippage, TradeType, } from '@1delta/lib-utils';
+import { createSwapAndBridgeCalldata } from '../utils/createSwapAndBridgeCalldata';
+import { fetchBestTrade, increaseAmountBySlippage, } from '../utils/multichainUtils';
+import { fetchAcrossRoutes, selectAcrossRoute } from './acrossRoutes';
+import fetchAcrossTradeWithSwap from './acrossWithSwap';
+// Extract contract address validation
+const validateContracts = (fromChainId) => {
+    const forwarder = getForwarderAddress(fromChainId);
+    if (!forwarder)
+        throw new Error('Forwarder contract not found');
+    const composer = getDeltaComposerProxyAddress(fromChainId);
+    if (!composer)
+        throw new Error('Composer proxy contract not found');
+    return { forwarder, composer };
+};
+const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
+export const fetchAcrossTradeWithSwaps = async (input, getCurrency, controller) => {
+    if (!input.fromCurrency || !input.toCurrency)
+        return undefined;
+    if (input.tradeType === TradeType.EXACT_OUTPUT)
+        throw new Error('Exact-out not supported for composed Across trade!');
+    // use a dummy to make across quote without a user address
+    // IMPORTANT: block assemble in this case
+    const isDummy = !input.receiver || !input.caller;
+    let sourceSwapTrade = undefined;
+    const fromChainId = getSafeChainId(input.fromCurrency?.chainId);
+    const toChainId = getSafeChainId(input.toCurrency?.chainId);
+    const { forwarder, composer } = validateContracts(fromChainId);
+    const routes = await fetchAcrossRoutes(fromChainId, toChainId);
+    const acrossRoute = selectAcrossRoute(routes, input.fromCurrency, input.toCurrency);
+    if (!acrossRoute)
+        return undefined;
+    const fromAcrossCurrency = getCurrency(acrossRoute.originChainId.toString(), acrossRoute.originToken);
+    const toAcrossCurrency = getCurrency(acrossRoute.destinationChainId.toString(), acrossRoute.destinationToken);
+    const outputIsAcrossAsset = CurrencyHandler.equal(CurrencyHandler.wrapped(input.toCurrency), toAcrossCurrency);
+    const inputIsAcrossAsset = CurrencyHandler.equal(CurrencyHandler.wrapped(input.fromCurrency), fromAcrossCurrency);
+    const [swapSlippage, acrossSlippage] = splitSlippage(input.slippage, inputIsAcrossAsset, outputIsAcrossAsset);
+    if (!inputIsAcrossAsset) {
+        const sourceSwapInput = {
+            chainId: fromChainId,
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency: input.fromCurrency,
+            toCurrency: fromAcrossCurrency,
+            slippage: swapSlippage,
+            swapAmount: input.swapAmount,
+            txOrigin: input.caller,
+            caller: forwarder,
+            receiver: forwarder,
+            flashSwap: undefined,
+        };
+        sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
+    }
+    const acrossExtendedAmount = sourceSwapTrade
+        ? minimumAmountOutFromTrade(sourceSwapTrade, sourceSwapTrade.slippage).amount.toString()
+        : input.swapAmount;
+    const acrossExtendedInput = {
+        ...input,
+        caller: isDummy ? DUMMY_ADDRESS : input.caller, // placeholder addresses if we have no connection
+        receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
+        slippage: acrossSlippage,
+        swapAmount: acrossExtendedAmount,
+        fromCurrency: acrossRoute.isNative
+            ? nativeOnChain(acrossRoute.originChainId.toString())
+            : fromAcrossCurrency,
+        bridgeToCurrency: toAcrossCurrency,
+    };
+    const { trade: acrossTradeWithSwap, receiver: bridgeReceiver } = await fetchAcrossTradeWithSwap(acrossExtendedInput, controller);
+    if (!acrossTradeWithSwap)
+        return undefined;
+    const trades = sourceSwapTrade
+        ? [sourceSwapTrade, acrossTradeWithSwap]
+        : [acrossTradeWithSwap];
+    const assemble = async () => {
+        // block assemble if no user address
+        if (isDummy)
+            return undefined;
+        // otherwise continue
+        const fundsToPull = [
+            {
+                address: input.fromCurrency.address,
+                amount: BigInt(input.swapAmount),
+            },
+        ];
+        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, bridgeReceiver, false, fundsToPull, false);
+        return {
+            EVM: {
+                to,
+                calldata,
+                value: value.toString(),
+            },
+        };
+    };
+    const refresh = async (inputOverride) => {
+        const newAggregatorInput = {
+            ...input,
+            slippage: inputOverride?.slippage ?? input.slippage,
+        };
+        return fetchAcrossTradeWithSwaps(newAggregatorInput, getCurrency);
+    };
+    const outputAmount = !!sourceSwapTrade
+        ? increaseAmountBySlippage(acrossTradeWithSwap.outputAmount.amount, Number(swapSlippage))
+        : acrossTradeWithSwap.outputAmount.amount;
+    return {
+        ...acrossTradeWithSwap,
+        inputAmount: sourceSwapTrade?.inputAmount ?? acrossTradeWithSwap.inputAmount,
+        inputAmountRealized: sourceSwapTrade?.inputAmountRealized ??
+            acrossTradeWithSwap.inputAmountRealized,
+        outputAmount: CurrencyHandler.fromRawAmount(acrossTradeWithSwap.outputAmount.currency, outputAmount),
+        outputAmountRealized: convertRawAmount(outputAmount, acrossTradeWithSwap.outputAmount.currency.decimals),
+        stringified: sourceSwapTrade
+            ? `${sourceSwapTrade?.stringified}-${acrossTradeWithSwap.stringified}`
+            : acrossTradeWithSwap.stringified,
+        target: composer,
+        approvalTarget: composer,
+        slippage: input.slippage,
+        assemble,
+        refresh,
+    };
+};
+export default fetchAcrossTradeWithSwaps;

package/dist/composedTrades/across/calldata/createAcrossMessage.d.ts

@@ -0,0 +1,23 @@
+import { EvmGenericCallInfo } from '@1delta/lib-utils';
+import { Hex } from 'viem';
+/**
+ * Creates the ABI-encoded `message` for a complete "Approve -> Execute -> Drain" sequence
+ * using the Across MulticallHandler.
+ *
+ * This is a high-level helper that orchestrates the entire flow:
+ * 1. **Approves** an ERC20 token for a spender.
+ * 2. **Executes** a series of one or more provided "middle" calls (e.g., a swap).
+ * 3. **Drains** the resulting token from the handler back to a specified address.
+ *
+ * @param multicallHandlerAddress - The address of the deployed MulticallHandler on the destination chain.
+ * @param tokenToApprove - The address of the ERC20 token to approve (the input token).
+ * @param amountToApprove - The amount of the token to approve.
+ * @param spender - The address that will spend the approved token (e.g., a DEX router).
+ * @param middleCalls - An array of `AcrossCall` objects to execute after approval (the core logic).
+ * @param tokenToDrain - The address of the ERC20 token expected as output from the middle calls.
+ * @param fallbackAndDrainAddress - The single address that serves as both the safety net (fallback) and the destination for the drained tokens. This should be your wallet.
+ * @returns The final, ABI-encoded `message` as a hex string (`Hex`).
+ */
+export declare function createAcrossSwapMessage(multicallHandlerAddress: string, tokenToApprove: string, amountToApprove: bigint, spender: string, calls: EvmGenericCallInfo[], fallbackAndDrainAddress: string, tokensToDrain: string[]): Hex;
+export declare function createAcrossDrainMessage(multicallHandlerAddress: string, fallbackAndDrainAddress: string, tokensToDrain: string[]): Hex;
+//# sourceMappingURL=createAcrossMessage.d.ts.map

package/dist/composedTrades/across/calldata/createAcrossMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAcrossMessage.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/across/calldata/createAcrossMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EAA+B,GAAG,EAAY,MAAM,MAAM,CAAA;AAKjE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,uBAAuB,EAAE,MAAM,EAC/B,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,kBAAkB,EAAE,EAC3B,uBAAuB,EAAE,MAAM,EAC/B,aAAa,EAAE,MAAM,EAAE,GACtB,GAAG,CAsCL;AAED,wBAAgB,wBAAwB,CACtC,uBAAuB,EAAE,MAAM,EAC/B,uBAAuB,EAAE,MAAM,EAC/B,aAAa,EAAE,MAAM,EAAE,GACtB,GAAG,CAWL"}

package/dist/composedTrades/across/calldata/createAcrossMessage.js

@@ -0,0 +1,69 @@
+import { encodeFunctionData, parseAbi } from 'viem';
+import { createAcrossMultiCallMessage } from './createAcrossMultiCallMessage';
+/**
+ * Creates the ABI-encoded `message` for a complete "Approve -> Execute -> Drain" sequence
+ * using the Across MulticallHandler.
+ *
+ * This is a high-level helper that orchestrates the entire flow:
+ * 1. **Approves** an ERC20 token for a spender.
+ * 2. **Executes** a series of one or more provided "middle" calls (e.g., a swap).
+ * 3. **Drains** the resulting token from the handler back to a specified address.
+ *
+ * @param multicallHandlerAddress - The address of the deployed MulticallHandler on the destination chain.
+ * @param tokenToApprove - The address of the ERC20 token to approve (the input token).
+ * @param amountToApprove - The amount of the token to approve.
+ * @param spender - The address that will spend the approved token (e.g., a DEX router).
+ * @param middleCalls - An array of `AcrossCall` objects to execute after approval (the core logic).
+ * @param tokenToDrain - The address of the ERC20 token expected as output from the middle calls.
+ * @param fallbackAndDrainAddress - The single address that serves as both the safety net (fallback) and the destination for the drained tokens. This should be your wallet.
+ * @returns The final, ABI-encoded `message` as a hex string (`Hex`).
+ */
+export function createAcrossSwapMessage(multicallHandlerAddress, tokenToApprove, amountToApprove, spender, calls, fallbackAndDrainAddress, tokensToDrain) {
+    if (calls.some((call) => !call.to || !call.calldata)) {
+        throw new Error('Invalid call data');
+    }
+    const erc20ApproveAbi = parseAbi([
+        'function approve(address spender, uint256 amount)',
+    ]);
+    const approveCalldata = encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: 'approve',
+        args: [spender, amountToApprove],
+    });
+    const approveCall = {
+        target: tokenToApprove,
+        callData: approveCalldata,
+        value: 0n,
+    };
+    const middleCalls = calls.map((call) => ({
+        target: call.to,
+        callData: call.calldata,
+        value: BigInt(call.value ?? 0n),
+    }));
+    const drainCalls = createDrainCalls(multicallHandlerAddress, fallbackAndDrainAddress, tokensToDrain);
+    const allCalls = [approveCall, ...middleCalls, ...drainCalls];
+    return createAcrossMultiCallMessage(allCalls, fallbackAndDrainAddress);
+}
+export function createAcrossDrainMessage(multicallHandlerAddress, fallbackAndDrainAddress, tokensToDrain) {
+    const drainCalls = createDrainCalls(multicallHandlerAddress, fallbackAndDrainAddress, tokensToDrain);
+    return createAcrossMultiCallMessage(drainCalls, fallbackAndDrainAddress);
+}
+function createDrainCalls(multicallHandlerAddress, receiverAddress, tokensToDrain) {
+    const multicallHandlerDrainAbi = parseAbi([
+        'function drainLeftoverTokens(address token, address destination)',
+    ]);
+    const drainCalls = tokensToDrain.map((tokenToDrain) => {
+        const drainCalldata = encodeFunctionData({
+            abi: multicallHandlerDrainAbi,
+            functionName: 'drainLeftoverTokens',
+            args: [tokenToDrain, receiverAddress],
+        });
+        const drainCall = {
+            target: multicallHandlerAddress,
+            callData: drainCalldata,
+            value: 0n,
+        };
+        return drainCall;
+    });
+    return drainCalls;
+}

package/dist/composedTrades/across/calldata/createAcrossMultiCallMessage.d.ts

@@ -0,0 +1,14 @@
+import { Address, Hex } from 'viem';
+import { AcrossCall } from './types';
+/**
+ * Creates the ABI-encoded `message` for the Across MulticallHandler contract.
+ *
+ * This function takes a sequence of calls and a fallback recipient and encodes them
+ * into the `Instructions` struct format expected by the handler.
+ *
+ * @param calls - An array of `AcrossCall` objects, defining the sequence of contract calls to execute on the destination chain.
+ * @param fallbackAddress - The "safety net" address that receives the funds if any call fails, or any leftover tokens after successful execution.
+ * @returns The ABI-encoded `message` as a hex string (`Hex`).
+ */
+export declare function createAcrossMultiCallMessage(calls: AcrossCall[], fallbackRecipient: Address): Hex;
+//# sourceMappingURL=createAcrossMultiCallMessage.d.ts.map

package/dist/composedTrades/across/calldata/createAcrossMultiCallMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAcrossMultiCallMessage.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/across/calldata/createAcrossMultiCallMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAuB,GAAG,EAAE,MAAM,MAAM,CAAA;AAExD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEpC;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,UAAU,EAAE,EACnB,iBAAiB,EAAE,OAAO,GACzB,GAAG,CAiCL"}

package/dist/composedTrades/across/calldata/createAcrossMultiCallMessage.js

@@ -0,0 +1,38 @@
+import { encodeAbiParameters } from 'viem';
+/**
+ * Creates the ABI-encoded `message` for the Across MulticallHandler contract.
+ *
+ * This function takes a sequence of calls and a fallback recipient and encodes them
+ * into the `Instructions` struct format expected by the handler.
+ *
+ * @param calls - An array of `AcrossCall` objects, defining the sequence of contract calls to execute on the destination chain.
+ * @param fallbackAddress - The "safety net" address that receives the funds if any call fails, or any leftover tokens after successful execution.
+ * @returns The ABI-encoded `message` as a hex string (`Hex`).
+ */
+export function createAcrossMultiCallMessage(calls, fallbackRecipient) {
+    if (!fallbackRecipient ||
+        fallbackRecipient === '0x0000000000000000000000000000000000000000') {
+        throw new Error('Using a zero address for fallbackAddress is highly discouraged. Funds may be unrecoverable on failure.');
+    }
+    const instructionsAbi = [
+        {
+            type: 'tuple',
+            components: [
+                {
+                    type: 'tuple[]',
+                    name: 'calls',
+                    components: [
+                        { type: 'address', name: 'target' },
+                        { type: 'bytes', name: 'callData' },
+                        { type: 'uint256', name: 'value' },
+                    ],
+                },
+                { type: 'address', name: 'fallbackRecipient' },
+            ],
+        },
+    ];
+    const message = encodeAbiParameters(instructionsAbi, [
+        { calls, fallbackRecipient },
+    ]);
+    return message;
+}

package/dist/composedTrades/across/calldata/types.d.ts

@@ -0,0 +1,7 @@
+import { Address, Hex } from 'viem';
+export type AcrossCall = {
+    target: Address;
+    callData: Hex;
+    value: bigint;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/composedTrades/across/calldata/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/across/calldata/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAEnC,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,GAAG,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA"}

package/dist/composedTrades/across/calldata/types.js

@@ -0,0 +1 @@
+export {};

package/dist/composedTrades/axelar/AxelarWithSwaps.d.ts

@@ -0,0 +1,5 @@
+import { GenericTrade, RawCurrency, useGeneralPricesCallbackType } from '@1delta/lib-utils';
+import { BridgeInput } from '../../types';
+export declare const fetchAxelarTradeWithSwaps: (input: BridgeInput, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency | undefined, getPrices: useGeneralPricesCallbackType, controller?: AbortController) => Promise<GenericTrade | undefined>;
+export default fetchAxelarTradeWithSwaps;
+//# sourceMappingURL=AxelarWithSwaps.d.ts.map

package/dist/composedTrades/axelar/AxelarWithSwaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AxelarWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/AxelarWithSwaps.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,YAAY,EAMZ,WAAW,EAGX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAA;AAmB1D,eAAO,MAAM,yBAAyB,GACpC,OAAO,WAAW,EAClB,aAAa,CACX,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,KAC7B,WAAW,GAAG,SAAS,EAC5B,WAAW,4BAA4B,EACvC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CA8JlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}