@1delta/trade-sdk 0.1.0

package/dist/composedTrades/axelar/AxelarWithSwaps.js

@@ -0,0 +1,117 @@
+import { convertRawAmount } from '@1delta/aggregators';
+import { CurrencyHandler, getDeltaComposerProxyAddress, getForwarderAddress, getSafeChainId, minimumAmountOutFromTrade, splitSlippage, TradeType, } from '@1delta/lib-utils';
+import { fetchBestTrade, increaseAmountBySlippage } from '../utils';
+import { createSwapAndBridgeCalldata } from '../utils/createSwapAndBridgeCalldata';
+import { fetchAxelarRoute } from './axelarRoutes';
+import fetchAxelarTradeWithSwap from './axelarWithSwap';
+// 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 fetchAxelarTradeWithSwaps = async (input, getCurrency, getPrices, controller) => {
+    if (!input.fromCurrency || !input.toCurrency)
+        return undefined;
+    if (input.tradeType === TradeType.EXACT_OUTPUT)
+        throw new Error('Exact-out not supported for composed Axelar trade!');
+    // use a dummy to make axelar 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 route = await fetchAxelarRoute(fromChainId, toChainId);
+    if (!route)
+        return undefined;
+    const fromBridgeCurrency = getCurrency(fromChainId, route.fromBridgeToken);
+    const toBridgeCurrency = getCurrency(toChainId, route.toBridgeToken);
+    const outputIsBridgeAsset = CurrencyHandler.equal(CurrencyHandler.wrapped(input.toCurrency), toBridgeCurrency);
+    const inputIsBridgeAsset = CurrencyHandler.equal(CurrencyHandler.wrapped(input.fromCurrency), fromBridgeCurrency);
+    const [swapSlippage, bridgeSlippage] = splitSlippage(input.slippage, inputIsBridgeAsset, outputIsBridgeAsset);
+    if (!inputIsBridgeAsset) {
+        const sourceSwapInput = {
+            chainId: fromChainId,
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency: input.fromCurrency,
+            toCurrency: fromBridgeCurrency,
+            slippage: swapSlippage,
+            swapAmount: input.swapAmount,
+            txOrigin: input.caller,
+            caller: forwarder,
+            receiver: forwarder,
+            flashSwap: undefined,
+        };
+        sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
+    }
+    const bridgeExtendedAmount = sourceSwapTrade
+        ? minimumAmountOutFromTrade(sourceSwapTrade, sourceSwapTrade.slippage).amount.toString()
+        : input.swapAmount;
+    const bridgeExtendedInput = {
+        ...input,
+        slippage: bridgeSlippage,
+        swapAmount: bridgeExtendedAmount,
+        fromCurrency: fromBridgeCurrency,
+        bridgeToCurrency: toBridgeCurrency,
+        caller: forwarder,
+        receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
+    };
+    const { trade: bridgeTradeWithSwap, gasTrade, receiver: bridgeReceiver, } = await fetchAxelarTradeWithSwap(bridgeExtendedInput, getPrices, controller);
+    if (!bridgeTradeWithSwap)
+        return undefined;
+    const trades = [];
+    if (sourceSwapTrade)
+        trades.push(sourceSwapTrade);
+    if (gasTrade)
+        trades.push(gasTrade);
+    trades.push(bridgeTradeWithSwap);
+    const assemble = async () => {
+        if (isDummy)
+            return undefined;
+        const fundsToPull = [
+            {
+                address: input.fromCurrency.address,
+                amount: BigInt(input.swapAmount),
+            },
+        ];
+        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, bridgeReceiver, true, fundsToPull, false, true);
+        return {
+            EVM: {
+                to,
+                calldata,
+                value: value.toString(),
+            },
+        };
+    };
+    const refresh = async (inputOverride) => {
+        const newAggregatorInput = {
+            ...input,
+            slippage: inputOverride?.slippage ?? input.slippage,
+        };
+        return fetchAxelarTradeWithSwaps(newAggregatorInput, getCurrency, getPrices);
+    };
+    const outputAmount = !!sourceSwapTrade
+        ? increaseAmountBySlippage(bridgeTradeWithSwap.outputAmount.amount, Number(swapSlippage))
+        : bridgeTradeWithSwap.outputAmount.amount;
+    return {
+        ...bridgeTradeWithSwap,
+        inputAmount: CurrencyHandler.fromRawAmount(input.fromCurrency, input.swapAmount),
+        inputAmountRealized: convertRawAmount(input.swapAmount, input.fromCurrency.decimals),
+        outputAmount: CurrencyHandler.fromRawAmount(bridgeTradeWithSwap.outputAmount.currency, outputAmount),
+        outputAmountRealized: convertRawAmount(outputAmount, bridgeTradeWithSwap.outputAmount.currency.decimals),
+        stringified: trades.map((t) => t.stringified).join('-'),
+        target: composer,
+        approvalTarget: composer,
+        slippage: input.slippage,
+        assemble,
+        refresh,
+        gasAmount: undefined,
+    };
+};
+export default fetchAxelarTradeWithSwaps;

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

@@ -0,0 +1,7 @@
+interface AxelarRoute {
+    fromBridgeToken: string;
+    toBridgeToken: string;
+}
+export declare function fetchAxelarRoute(fromChainId: string, toChainId: string): Promise<AxelarRoute | undefined>;
+export {};
+//# sourceMappingURL=axelarRoutes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"axelarRoutes.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarRoutes.ts"],"names":[],"mappings":"AAcA,UAAU,WAAW;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAWlC"}

package/dist/composedTrades/axelar/axelarRoutes.js

@@ -0,0 +1,31 @@
+import { getAxelarTokenAddress, getCachedAxelarConfig, } from '@1delta/bridge-configs';
+import { devLog } from '@1delta/lib-utils';
+import { AxelarTokenSymbol } from './constants';
+const BRIDGE_TOKENS_ORDERED = [
+    AxelarTokenSymbol.axlUSDC,
+    AxelarTokenSymbol.axlETH,
+    AxelarTokenSymbol.axlUSDT,
+];
+export async function fetchAxelarRoute(fromChainId, toChainId) {
+    for (const axelarToken of BRIDGE_TOKENS_ORDERED) {
+        const bridgeTokens = await getBridgeTokens(fromChainId, toChainId, axelarToken);
+        if (bridgeTokens)
+            return bridgeTokens;
+    }
+    return undefined;
+}
+async function getBridgeTokens(fromChainId, toChainId, tokenSymbol) {
+    try {
+        const axelarConfig = await getCachedAxelarConfig();
+        const fromBridgeToken = getAxelarTokenAddress(axelarConfig, fromChainId, tokenSymbol);
+        const toBridgeToken = getAxelarTokenAddress(axelarConfig, toChainId, tokenSymbol);
+        return {
+            fromBridgeToken,
+            toBridgeToken,
+        };
+    }
+    catch (e) {
+        devLog('Axelar: invalid route', e);
+        return undefined;
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"axelarWithSwap.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarWithSwap.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,YAAY,EAGZ,WAAW,EAEX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAI1B,OAAO,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAA;AAK1D,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,gBAAgB,EAAE,WAAW,GAAG,SAAS,CAAA;CAC1C;AAED,eAAO,MAAM,wBAAwB,GACnC,OAAO,mBAAmB,EAC1B,WAAW,4BAA4B,EACvC,aAAa,eAAe,KAC3B,OAAO,CAAC;IACT,KAAK,EAAE,YAAY,GAAG,SAAS,CAAA;IAC/B,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CA2CA,CAAA;AAED,eAAe,wBAAwB,CAAA"}

package/dist/composedTrades/axelar/axelarWithSwap.js

@@ -0,0 +1,107 @@
+import { Bridge, createSquidPayload, getRequiredSquidMulticaller, getRequiredSquidRouter, } from '@1delta/bridge-configs';
+import { CurrencyHandler, normalizeDecimals, TradeType, } from '@1delta/lib-utils';
+import { fetchBridgeTrade } from '../../bridge/fetchBridgeTrade';
+import { fetchBridgeAndGasTrade } from '../utils/fetchBridgeAndGasTrade';
+import { fetchBestTrade } from '../utils/multichainUtils';
+import { createSquidSwapPayload } from './squid/createSquidPayload';
+export const fetchAxelarTradeWithSwap = async (input, getPrices, controller) => {
+    if (!input.bridgeToCurrency)
+        throw new Error('BridgeToCurrency undefined');
+    if (!input.toCurrency)
+        throw new Error('ToCurrency undefined');
+    const toChainId = input.toCurrency.chainId;
+    const toTokenIsBridgeToken = CurrencyHandler.equal(input.bridgeToCurrency, input.toCurrency);
+    const squidRouter = await getRequiredSquidRouter(toChainId);
+    if (toTokenIsBridgeToken) {
+        // direct case
+        const message = createSquidPayload(input.receiver);
+        const bridgeAndGasTrade = await fetchBridgeAndGasTrade(Bridge.AXELAR, { ...input, message }, getPrices, controller);
+        return {
+            trade: bridgeAndGasTrade?.bridgeTrade,
+            gasTrade: bridgeAndGasTrade?.gasTrade,
+            receiver: squidRouter,
+        };
+    }
+    else {
+        // swap case
+        const bridgeAndGasTrade = await fetchAxelarTradeWithDestinationSwap(input, getPrices, controller);
+        return {
+            trade: bridgeAndGasTrade?.bridgeTrade,
+            gasTrade: bridgeAndGasTrade?.gasTrade,
+            receiver: squidRouter,
+        };
+    }
+};
+export default fetchAxelarTradeWithSwap;
+const fetchAxelarTradeWithDestinationSwap = async (input, getPrices, 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 squidMulticall = await getRequiredSquidMulticaller(toChainId);
+    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: squidMulticall,
+            caller: squidMulticall,
+            receiver: squidMulticall,
+            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 = createSquidSwapPayload(destinationSwapTrade.inputAmount.currency.address, destinationSwapTrade.inputAmount.amount, destinationSwapTrade.target, [tx.EVM], input.receiver, [
+            destinationSwapTrade.inputAmount.currency.address,
+            destinationSwapTrade.outputAmount.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 axelarInput = {
+        ...input,
+        toCurrency: input.bridgeToCurrency,
+        message: swap.message,
+        destinationGasLimit: 1000000n,
+    };
+    const bridgeAndGasTrade = await fetchBridgeAndGasTrade(Bridge.AXELAR, axelarInput, getPrices, controller);
+    if (!bridgeAndGasTrade)
+        return undefined;
+    const { bridgeTrade, gasTrade } = bridgeAndGasTrade;
+    const updatedSwap = await fetchSwapAndMessage(bridgeTrade.outputAmount.amount);
+    if (!updatedSwap)
+        return undefined;
+    const updatedAxelarTrade = await fetchBridgeTrade(Bridge.AXELAR, { ...axelarInput, message: updatedSwap.message }, controller);
+    if (!updatedAxelarTrade)
+        return undefined;
+    const refresh = async (inputOverride) => {
+        const newAggregatorInput = {
+            ...input,
+            slippage: inputOverride?.slippage ?? input.slippage,
+        };
+        return (await fetchAxelarTradeWithSwap(newAggregatorInput, getPrices)).trade;
+    };
+    const composedTrade = {
+        ...updatedAxelarTrade,
+        outputAmount: updatedSwap.destinationSwapTrade.outputAmount,
+        outputAmountRealized: updatedSwap.destinationSwapTrade.outputAmountRealized,
+        stringified: `${updatedAxelarTrade?.stringified}-${updatedSwap.destinationSwapTrade.stringified}`,
+        refresh,
+    };
+    return { bridgeTrade: composedTrade, gasTrade };
+};

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

@@ -0,0 +1,9 @@
+export declare enum AxelarTokenSymbol {
+    axlUSDC = "uusdc",
+    AXL = "uaxl",
+    axlDAI = "dai-wei",
+    axlUSDT = "uusdt",
+    axlWBTC = "wbtc-satoshi",
+    axlETH = "weth-wei"
+}
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/constants.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IAC3B,OAAO,UAAU;IACjB,GAAG,SAAS;IACZ,MAAM,YAAY;IAClB,OAAO,UAAU;IACjB,OAAO,iBAAiB;IACxB,MAAM,aAAa;CACpB"}

package/dist/composedTrades/axelar/constants.js

@@ -0,0 +1,9 @@
+export var AxelarTokenSymbol;
+(function (AxelarTokenSymbol) {
+    AxelarTokenSymbol["axlUSDC"] = "uusdc";
+    AxelarTokenSymbol["AXL"] = "uaxl";
+    AxelarTokenSymbol["axlDAI"] = "dai-wei";
+    AxelarTokenSymbol["axlUSDT"] = "uusdt";
+    AxelarTokenSymbol["axlWBTC"] = "wbtc-satoshi";
+    AxelarTokenSymbol["axlETH"] = "weth-wei";
+})(AxelarTokenSymbol || (AxelarTokenSymbol = {}));

package/dist/composedTrades/axelar/squid/createSquidPayload.d.ts

@@ -0,0 +1,22 @@
+import { EvmGenericCallInfo } from '@1delta/lib-utils';
+import { Hex } from 'viem';
+/**
+ * Creates the final `payload` for a complete "Approve -> Execute -> Drain" sequence
+ * using the Squid multicaller.
+ *
+ * This is a high-level helper that orchestrates the entire flow:
+ * 1. **TransferFrom** pull funds from caller to SquidMulticaller.
+ * 1. **Approves** an ERC20 token for a spender.
+ * 2. **Executes** a series of one or more "middle" calls (e.g., a swap).
+ * 3. **Drains** the resulting tokens from the multicall contract back to a specified address.
+ *
+ * @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 calls - An array of generic call objects to execute after approval.
+ * @param refundAndDrainAddress - The single address that serves as both the refund recipient (safety net) and the destination for the drained tokens.
+ * @param tokensToDrain - An array of ERC20 token addresses expected as output from the middle calls.
+ * @returns The final, ABI-encoded `payload` as a hex string (`Hex`).
+ */
+export declare function createSquidSwapPayload(tokenToApprove: string, amountToApprove: bigint, spender: string, calls: EvmGenericCallInfo[], refundAndDrainAddress: string, tokensToDrain: string[]): Hex;
+//# sourceMappingURL=createSquidPayload.d.ts.map

package/dist/composedTrades/axelar/squid/createSquidPayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSquidPayload.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/axelar/squid/createSquidPayload.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EAIL,GAAG,EAIJ,MAAM,MAAM,CAAA;AAiEb;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,kBAAkB,EAAE,EAC3B,qBAAqB,EAAE,MAAM,EAC7B,aAAa,EAAE,MAAM,EAAE,GACtB,GAAG,CAqDL"}

package/dist/composedTrades/axelar/squid/createSquidPayload.js

@@ -0,0 +1,112 @@
+import { createSquidPayload } from '@1delta/bridge-configs';
+import { encodeAbiParameters, encodeFunctionData, parseAbi, parseAbiParameters, zeroAddress, } from 'viem';
+import { SquidCallType } from './types';
+/**
+ * [Helper] Creates the specific "drain" calls for the SquidMulticall contract.
+ *
+ * This function constructs standard ERC20 `transfer` calls but uses the special
+ * `FULL_TOKEN_BALANCE` callType. This instructs the multicall contract to
+ * substitute the transfer `amount` with its entire balance of the token at execution time.
+ *
+ * @param receiverAddress - The destination address for the drained tokens.
+ * @param tokensToDrain - An array of ERC20 token addresses to drain from the multicall contract.
+ * @returns An array of `SquidCall` objects configured for draining.
+ */
+function createSquidDrainCalls(receiverAddress, tokensToDrain) {
+    const erc20TransferAbi = parseAbi([
+        'function transfer(address recipient, uint256 amount)',
+    ]);
+    const fullTokenBalancePayloadAbi = parseAbiParameters('address, uint256');
+    const drainCalls = tokensToDrain.map((tokenToDrain) => {
+        const isNative = tokenToDrain === zeroAddress;
+        if (isNative) {
+            const nativeDrainCall = {
+                callType: SquidCallType.FULL_NATIVE_BALANCE,
+                target: receiverAddress,
+                value: 0n,
+                callData: '0x',
+                payload: '0x',
+            };
+            return nativeDrainCall;
+        }
+        const transferCalldata = encodeFunctionData({
+            abi: erc20TransferAbi,
+            functionName: 'transfer',
+            args: [receiverAddress, 0n], // Amount is a placeholder
+        });
+        const specialPayload = encodeAbiParameters(fullTokenBalancePayloadAbi, [
+            tokenToDrain,
+            1n, // The `amount` is the parameter at index 1
+        ]);
+        const drainCall = {
+            callType: SquidCallType.FULL_TOKEN_BALANCE,
+            target: tokenToDrain,
+            value: 0n,
+            callData: transferCalldata,
+            payload: specialPayload,
+        };
+        return drainCall;
+    });
+    return drainCalls;
+}
+/**
+ * Creates the final `payload` for a complete "Approve -> Execute -> Drain" sequence
+ * using the Squid multicaller.
+ *
+ * This is a high-level helper that orchestrates the entire flow:
+ * 1. **TransferFrom** pull funds from caller to SquidMulticaller.
+ * 1. **Approves** an ERC20 token for a spender.
+ * 2. **Executes** a series of one or more "middle" calls (e.g., a swap).
+ * 3. **Drains** the resulting tokens from the multicall contract back to a specified address.
+ *
+ * @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 calls - An array of generic call objects to execute after approval.
+ * @param refundAndDrainAddress - The single address that serves as both the refund recipient (safety net) and the destination for the drained tokens.
+ * @param tokensToDrain - An array of ERC20 token addresses expected as output from the middle calls.
+ * @returns The final, ABI-encoded `payload` as a hex string (`Hex`).
+ */
+export function createSquidSwapPayload(tokenToApprove, amountToApprove, spender, calls, refundAndDrainAddress, tokensToDrain) {
+    if (calls.some((call) => !call.to || !call.calldata)) {
+        throw new Error('Invalid call data');
+    }
+    const tokenAddressPayload = encodeAbiParameters(parseAbiParameters('address'), [tokenToApprove]);
+    const transferFromCall = {
+        callType: SquidCallType.COLLECT_TOKEN_BALANCE,
+        target: zeroAddress,
+        value: 0n,
+        callData: '0x',
+        payload: tokenAddressPayload,
+    };
+    const erc20ApproveAbi = parseAbi([
+        'function approve(address spender, uint256 amount)',
+    ]);
+    const approveCalldata = encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: 'approve',
+        args: [spender, amountToApprove],
+    });
+    const approveCall = {
+        callType: SquidCallType.DEFAULT,
+        target: tokenToApprove,
+        value: 0n,
+        callData: approveCalldata,
+        payload: '0x',
+    };
+    const middleCalls = calls.map((call) => ({
+        callType: SquidCallType.DEFAULT,
+        target: call.to,
+        callData: call.calldata,
+        value: BigInt(call.value ?? 0n),
+        payload: '0x',
+    }));
+    const drainCalls = createSquidDrainCalls(refundAndDrainAddress, tokensToDrain);
+    const allCalls = [
+        transferFromCall,
+        approveCall,
+        ...middleCalls,
+        ...drainCalls,
+    ];
+    return createSquidPayload(refundAndDrainAddress, allCalls);
+}

package/dist/composedTrades/axelar/squid/types.d.ts

@@ -0,0 +1,15 @@
+import { Address, Hex } from 'viem';
+export declare enum SquidCallType {
+    DEFAULT = 0,
+    FULL_TOKEN_BALANCE = 1,
+    FULL_NATIVE_BALANCE = 2,
+    COLLECT_TOKEN_BALANCE = 3
+}
+export interface SquidCall {
+    callType: SquidCallType;
+    target: Address;
+    value: bigint;
+    callData: Hex;
+    payload: Hex;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/composedTrades/axelar/squid/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/axelar/squid/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAEnC,oBAAY,aAAa;IACvB,OAAO,IAAI;IACX,kBAAkB,IAAI;IACtB,mBAAmB,IAAI;IACvB,qBAAqB,IAAI;CAC1B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,aAAa,CAAA;IACvB,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,GAAG,CAAA;IACb,OAAO,EAAE,GAAG,CAAA;CACb"}

package/dist/composedTrades/axelar/squid/types.js

@@ -0,0 +1,7 @@
+export var SquidCallType;
+(function (SquidCallType) {
+    SquidCallType[SquidCallType["DEFAULT"] = 0] = "DEFAULT";
+    SquidCallType[SquidCallType["FULL_TOKEN_BALANCE"] = 1] = "FULL_TOKEN_BALANCE";
+    SquidCallType[SquidCallType["FULL_NATIVE_BALANCE"] = 2] = "FULL_NATIVE_BALANCE";
+    SquidCallType[SquidCallType["COLLECT_TOKEN_BALANCE"] = 3] = "COLLECT_TOKEN_BALANCE";
+})(SquidCallType || (SquidCallType = {}));

package/dist/composedTrades/gaszip/gaszipWithSwaps.d.ts

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

package/dist/composedTrades/gaszip/gaszipWithSwaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaszipWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/gaszip/gaszipWithSwaps.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,YAAY,EASb,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAA;AAoB1D,eAAO,MAAM,yBAAyB,GACpC,OAAO,WAAW,EAClB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAkJlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/composedTrades/gaszip/gaszipWithSwaps.js

@@ -0,0 +1,114 @@
+import { convertRawAmount } from '@1delta/aggregators';
+import { Bridge } from '@1delta/bridge-configs';
+import { CurrencyHandler, getDeltaComposerProxyAddress, getForwarderAddress, getSafeChainId, minimumAmountOutFromTrade, nativeOnChain, splitSlippage, TradeType, } from '@1delta/lib-utils';
+import { fetchBridgeTrade } from '../../bridge';
+import { createSwapAndBridgeCalldata } from '../utils/createSwapAndBridgeCalldata';
+import { fetchBestTrade, increaseAmountBySlippage, } from '../utils/multichainUtils';
+// 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 fetchGaszipTradeWithSwaps = async (input, controller) => {
+    if (!input.fromCurrency || !input.toCurrency)
+        return undefined;
+    // if (input.tradeType === TradeType.EXACT_OUTPUT)
+    //   throw new Error('Exact-out not supported for composed Gaszip trade!')
+    if (!CurrencyHandler.isNative(input.toCurrency))
+        throw new Error('Gaszip only supports Native as output token!');
+    // use a dummy to make gaszip 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 fromGaszipCurrency = nativeOnChain(fromChainId);
+    const toGaszipCurrency = nativeOnChain(toChainId);
+    const inputIsGaszipAsset = CurrencyHandler.equal(input.fromCurrency, fromGaszipCurrency);
+    const [swapSlippage, gaszipSlippage] = splitSlippage(input.slippage, inputIsGaszipAsset, true);
+    if (!inputIsGaszipAsset) {
+        const sourceSwapInput = {
+            chainId: fromChainId,
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency: input.fromCurrency,
+            toCurrency: fromGaszipCurrency,
+            slippage: swapSlippage,
+            swapAmount: input.swapAmount,
+            txOrigin: input.caller,
+            caller: forwarder,
+            receiver: forwarder,
+            flashSwap: undefined,
+        };
+        sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
+    }
+    const gaszipExtendedAmount = sourceSwapTrade
+        ? minimumAmountOutFromTrade(sourceSwapTrade, sourceSwapTrade.slippage).amount.toString()
+        : input.swapAmount;
+    const gaszipInput = {
+        tradeType: TradeType.EXACT_INPUT,
+        caller: isDummy ? DUMMY_ADDRESS : input.caller,
+        receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
+        slippage: gaszipSlippage,
+        swapAmount: gaszipExtendedAmount,
+        fromCurrency: fromGaszipCurrency,
+        toCurrency: toGaszipCurrency,
+        order: 'CHEAPEST',
+    };
+    const gaszipTrade = await fetchBridgeTrade(Bridge.GASZIP, gaszipInput, controller);
+    if (!gaszipTrade)
+        return undefined;
+    const trades = sourceSwapTrade
+        ? [sourceSwapTrade, gaszipTrade]
+        : [gaszipTrade];
+    const assemble = async () => {
+        if (isDummy)
+            return undefined;
+        const fundsToPull = [
+            {
+                address: input.fromCurrency.address,
+                amount: BigInt(input.swapAmount),
+            },
+        ];
+        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, input.receiver, false, fundsToPull, false);
+        return {
+            EVM: {
+                to,
+                calldata,
+                value: value.toString(),
+            },
+        };
+    };
+    const refresh = async (inputOverride) => {
+        const newAggregatorInput = {
+            ...input,
+            slippage: inputOverride?.slippage ?? input.slippage,
+        };
+        return fetchGaszipTradeWithSwaps(newAggregatorInput);
+    };
+    const outputAmount = !!sourceSwapTrade
+        ? increaseAmountBySlippage(gaszipTrade.outputAmount.amount, Number(swapSlippage))
+        : gaszipTrade.outputAmount.amount;
+    return {
+        ...gaszipTrade,
+        inputAmount: sourceSwapTrade?.inputAmount ?? gaszipTrade.inputAmount,
+        inputAmountRealized: sourceSwapTrade?.inputAmountRealized ?? gaszipTrade.inputAmountRealized,
+        outputAmount: CurrencyHandler.fromRawAmount(gaszipTrade.outputAmount.currency, outputAmount),
+        outputAmountRealized: convertRawAmount(outputAmount, gaszipTrade.outputAmount.currency.decimals),
+        stringified: sourceSwapTrade
+            ? `${sourceSwapTrade?.stringified}-${gaszipTrade.stringified}`
+            : gaszipTrade.stringified,
+        target: composer,
+        approvalTarget: composer,
+        slippage: input.slippage,
+        assemble,
+        refresh,
+    };
+};
+export default fetchGaszipTradeWithSwaps;

package/dist/composedTrades/index.d.ts

@@ -0,0 +1,4 @@
+export * from './across/acrossWithSwaps';
+export * from './axelar/AxelarWithSwaps';
+export * from './gaszip/gaszipWithSwaps';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/composedTrades/index.js

@@ -0,0 +1,3 @@
+export * from './across/acrossWithSwaps';
+export * from './axelar/AxelarWithSwaps';
+export * from './gaszip/gaszipWithSwaps';

package/dist/composedTrades/utils/createSwapAndBridgeCalldata.d.ts

@@ -0,0 +1,10 @@
+import { InternalTrade } from '@1delta/lib-utils';
+export declare function createSwapAndBridgeCalldata(trades: InternalTrade[], account: string, bridgeReceiver: string, sweep: boolean, fundsToPull?: {
+    address: string;
+    amount: bigint;
+}[], catchRevert?: boolean, sweepDust?: boolean): Promise<{
+    calldata: `0x${string}`;
+    value: bigint;
+    to: string;
+}>;
+//# sourceMappingURL=createSwapAndBridgeCalldata.d.ts.map

package/dist/composedTrades/utils/createSwapAndBridgeCalldata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSwapAndBridgeCalldata.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/createSwapAndBridgeCalldata.ts"],"names":[],"mappings":"AAcA,OAAO,EAOL,aAAa,EAKd,MAAM,mBAAmB,CAAA;AAG1B,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,aAAa,EAAE,EACvB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,OAAO,EACd,WAAW,GAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAO,EACvD,WAAW,GAAE,OAAc,EAC3B,SAAS,GAAE,OAAe;;;;GAgO3B"}