@1delta/trade-sdk 0.1.2 → 0.1.4

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

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

package/dist/aggregator/fetchAggregatorTrade.js

@@ -2,10 +2,7 @@ export * from './fetchAggregatorTrade';
 import { fetchAggregatorTrade as fetchAggregatorTradeWithoutConfigs, } from '@1delta/aggregators';
 import { getSwapAggregators } from '@1delta/bridge-configs';
 import { fetchBridgeTrade } from '../bridge';
-import { getAvailableAggregators } from './getAvailableAggregators';
 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);
     }

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

@@ -1 +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,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,OAAO,eAAe,EACtB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAiMlC,CAAA"}
+{"version":3,"file":"fetchBridgeTrade.d.ts","sourceRoot":"","sources":["../../src/bridge/fetchBridgeTrade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAW/C,OAAO,EAKL,YAAY,EAWb,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,OAAO,eAAe,EACtB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAiMlC,CAAA"}

package/dist/bridge/fetchBridgeTrade.js

@@ -1,6 +1,6 @@
-import { convertRawAmount } from '@1delta/aggregators';
 import { Bridge } from '@1delta/bridge-configs';
 import { buildTransactionData, getQuote, getRoute, getStatus, } from '@1delta/bridge-core';
+import { convertRawAmount } from '@1delta/lib-utils';
 import { ChainType, ChainUtils, CurrencyHandler, isDirectlyPermittable, NATIVE_PLACEHOLDER, PermitShared, TradeType, } from '@1delta/lib-utils';
 export const fetchBridgeTrade = async (bridge, input, controller) => {
     const inputSlippage = input.slippage;

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

@@ -1,6 +1,6 @@
 import { GenericTrade, RawCurrency } from '@1delta/lib-utils';
-import { BaseBridgeInput } from '../../types';
-export interface AcrossWithSwapInput extends BaseBridgeInput {
+import { BaseComposedInput } from '../../types';
+export interface AcrossWithSwapInput extends BaseComposedInput {
     bridgeToCurrency: RawCurrency | undefined;
 }
 export declare const fetchAcrossTradeWithSwap: (input: AcrossWithSwapInput, controller?: AbortController) => Promise<{

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

@@ -1 +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,eAAe,EAAE,MAAM,aAAa,CAAA;AAO9D,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,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"}
+{"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,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAOhE,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,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,CAgD/D,CAAA;AAED,eAAe,wBAAwB,CAAA"}

package/dist/composedTrades/across/acrossWithSwap.js

@@ -8,7 +8,8 @@ export const fetchAcrossTradeWithSwap = async (input, controller) => {
         throw new Error('BridgeToCurrency undefined');
     const toChainId = getSafeChainId(input.toCurrency?.chainId);
     const toTokenIsBridgeToken = CurrencyHandler.equal(input.bridgeToCurrency, CurrencyHandler.wrapped(input.toCurrency));
-    if (toTokenIsBridgeToken) {
+    const needDestinationCalls = (input.additionalCalls?.length ?? 0) > 0 || !toTokenIsBridgeToken;
+    if (!needDestinationCalls) {
         const toTokenIsWNative = CurrencyHandler.isWNative(input.toCurrency);
         if (toTokenIsWNative) {
             // special case: to receive wrapped native receiver must be contract
@@ -28,7 +29,7 @@ export const fetchAcrossTradeWithSwap = async (input, controller) => {
         }
     }
     else {
-        const acrossTrade = await fetchAcrossTradeWithDestinationSwap(input, controller);
+        const acrossTrade = await fetchAcrossTradeWithDestinationCalls(input, controller);
         return {
             trade: acrossTrade,
             receiver: getAcrossMulticallHandler(toChainId),
@@ -55,7 +56,7 @@ const fetchAcrossTradeWithSweep = async (input, controller) => {
         return undefined;
     return acrossTrade;
 };
-const fetchAcrossTradeWithDestinationSwap = async (input, controller) => {
+const fetchAcrossTradeWithDestinationCalls = async (input, controller) => {
     if (!input.swapAmount)
         throw new Error('Swap amount undefined');
     if (!input.fromCurrency)
@@ -65,27 +66,43 @@ const fetchAcrossTradeWithDestinationSwap = async (input, controller) => {
     if (!input.bridgeToCurrency)
         throw new Error('BridgeToCurrency undefined');
     const toChainId = input.toCurrency.chainId;
+    const additionalCalls = input.additionalCalls ?? [];
+    const needsSwap = !CurrencyHandler.equal(input.bridgeToCurrency, input.toCurrency);
     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 };
+        if (needsSwap) {
+            // Handle destination swap case
+            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), toChainId, destinationSwapTrade.inputAmount.currency.address, destinationSwapTrade.outputAmount.currency.address, input.receiver, additionalCalls, {
+                tokenToApprove: destinationSwapTrade.inputAmount.currency.address,
+                amountToApprove: destinationSwapTrade.inputAmount.amount,
+                spender: destinationSwapTrade.target,
+                calls: [tx.EVM],
+            });
+            return { message, destinationSwapTrade };
+        }
+        else if (additionalCalls.length > 0) {
+            // Handle only destination calls case
+            const message = createAcrossSwapMessage(getAcrossMulticallHandler(toChainId), toChainId, undefined, input.bridgeToCurrency.address, input.receiver, additionalCalls);
+            return { message, destinationSwapTrade: undefined };
+        }
+        return undefined;
     };
     const destinationSwapAmount = normalizeDecimals(BigInt(input.swapAmount), input.fromCurrency.decimals, input.bridgeToCurrency.decimals);
     const swap = await fetchSwapAndMessage(destinationSwapAmount);
@@ -114,9 +131,13 @@ const fetchAcrossTradeWithDestinationSwap = async (input, controller) => {
     };
     return {
         ...updatedAcrossTrade,
-        outputAmount: updatedSwap.destinationSwapTrade.outputAmount,
-        outputAmountRealized: updatedSwap.destinationSwapTrade.outputAmountRealized,
-        stringified: `${updatedAcrossTrade?.stringified}-${updatedSwap.destinationSwapTrade.stringified}`,
+        outputAmount: updatedSwap.destinationSwapTrade?.outputAmount ??
+            updatedAcrossTrade.outputAmount,
+        outputAmountRealized: updatedSwap.destinationSwapTrade?.outputAmountRealized ??
+            updatedAcrossTrade.outputAmountRealized,
+        stringified: updatedSwap.destinationSwapTrade
+            ? `${updatedAcrossTrade?.stringified}-${updatedSwap.destinationSwapTrade.stringified}`
+            : updatedAcrossTrade.stringified,
         refresh,
     };
 };

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

@@ -1,5 +1,5 @@
 import { GenericTrade, RawCurrency } from '@1delta/lib-utils';
-import { BaseBridgeInput } from '../../types';
-export declare const fetchAcrossTradeWithSwaps: (input: BaseBridgeInput, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency | undefined, controller?: AbortController) => Promise<GenericTrade | undefined>;
+import { BaseComposedInput } from '../../types';
+export declare const fetchAcrossTradeWithSwaps: (input: BaseComposedInput, 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

@@ -1 +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,eAAe,EAAE,MAAM,aAAa,CAAA;AAsB9D,eAAO,MAAM,yBAAyB,GACpC,OAAO,eAAe,EACtB,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"}
+{"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,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAsBhE,eAAO,MAAM,yBAAyB,GACpC,OAAO,iBAAiB,EACxB,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,CAqKlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/composedTrades/across/acrossWithSwaps.js

@@ -1,4 +1,4 @@
-import { convertRawAmount } from '@1delta/aggregators';
+import { convertRawAmount } from '@1delta/lib-utils';
 import { CurrencyHandler, getDeltaComposerProxyAddress, getForwarderAddress, getSafeChainId, minimumAmountOutFromTrade, nativeOnChain, splitSlippage, TradeType, } from '@1delta/lib-utils';
 import { createSwapAndBridgeCalldata } from '../utils/createSwapAndBridgeCalldata';
 import { fetchBestTrade, increaseAmountBySlippage, } from '../utils/multichainUtils';

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

@@ -1,5 +1,7 @@
-import { EvmGenericCallInfo } from '@1delta/lib-utils';
 import { Hex } from 'viem';
+import { DeltaCall } from '../../../types/deltaCall';
+import { DestinationSwapData } from '../../../types/destinationSwapData';
+import { AcrossCall } from './types';
 /**
  * Creates the ABI-encoded `message` for a complete "Approve -> Execute -> Drain" sequence
  * using the Across MulticallHandler.
@@ -18,6 +20,7 @@ import { Hex } from 'viem';
  * @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 createAcrossSwapMessage(multicallHandlerAddress: string, chainId: string, inputToken: string | undefined, outputToken: string, refundAndDrainAddress: string, additionalCalls: DeltaCall[], destinationSwapData?: DestinationSwapData): Hex;
+export declare function createAcrossSwapCalls(destinationSwapData: DestinationSwapData): AcrossCall[];
 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

@@ -1 +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"}
+{"version":3,"file":"createAcrossMessage.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/across/calldata/createAcrossMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,GAAG,EAAY,MAAM,MAAM,CAAA;AAGjE,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAA;AAGxE,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,uBAAuB,EAAE,MAAM,EAC/B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,WAAW,EAAE,MAAM,EACnB,qBAAqB,EAAE,MAAM,EAC7B,eAAe,EAAE,SAAS,EAAE,EAC5B,mBAAmB,CAAC,EAAE,mBAAmB,GACxC,GAAG,CA4DL;AAED,wBAAgB,qBAAqB,CACnC,mBAAmB,EAAE,mBAAmB,GACvC,UAAU,EAAE,CA8Bd;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

@@ -1,4 +1,6 @@
 import { encodeFunctionData, parseAbi } from 'viem';
+import { createDeltaCallsCalldata } from '../../../deltaCall/createDeltaCallsCalldata';
+import { requireDeltaContracts } from '../../utils/requireDeltaContracts';
 import { createAcrossMultiCallMessage } from './createAcrossMultiCallMessage';
 /**
  * Creates the ABI-encoded `message` for a complete "Approve -> Execute -> Drain" sequence
@@ -18,7 +20,43 @@ import { createAcrossMultiCallMessage } from './createAcrossMultiCallMessage';
  * @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) {
+export function createAcrossSwapMessage(multicallHandlerAddress, chainId, inputToken, outputToken, refundAndDrainAddress, additionalCalls, destinationSwapData) {
+    const swapCalls = destinationSwapData
+        ? createAcrossSwapCalls(destinationSwapData)
+        : [];
+    if (additionalCalls.length === 0) {
+        // normal case: do calls and sweep to user
+        const tokensToDrain = inputToken ? [inputToken, outputToken] : [outputToken];
+        const drainCalls = createDrainCalls(multicallHandlerAddress, refundAndDrainAddress, tokensToDrain);
+        const allCalls = [...swapCalls, ...drainCalls];
+        return createAcrossMultiCallMessage(allCalls, refundAndDrainAddress);
+    }
+    else {
+        // composer case: do calls and continue in composer
+        const { forwarder } = requireDeltaContracts(chainId);
+        const tokensToDrain = inputToken ? [inputToken] : [];
+        const drainToUserCall = createDrainCalls(multicallHandlerAddress, refundAndDrainAddress, tokensToDrain);
+        const drainToForwarder = createDrainCalls(multicallHandlerAddress, forwarder, [outputToken]);
+        const deltaComposerCall = createDeltaCallsCalldata(chainId, additionalCalls, {
+            tokensToSweep: [outputToken],
+            receiver: refundAndDrainAddress,
+        });
+        const callToComposer = {
+            target: deltaComposerCall.to,
+            callData: deltaComposerCall.calldata,
+            value: 0n,
+        };
+        const allCalls = [
+            ...swapCalls,
+            ...drainToUserCall,
+            ...drainToForwarder,
+            callToComposer,
+        ];
+        return createAcrossMultiCallMessage(allCalls, refundAndDrainAddress);
+    }
+}
+export function createAcrossSwapCalls(destinationSwapData) {
+    const { tokenToApprove, amountToApprove, spender, calls } = destinationSwapData;
     if (calls.some((call) => !call.to || !call.calldata)) {
         throw new Error('Invalid call data');
     }
@@ -40,9 +78,7 @@ export function createAcrossSwapMessage(multicallHandlerAddress, tokenToApprove,
         callData: call.calldata,
         value: BigInt(call.value ?? 0n),
     }));
-    const drainCalls = createDrainCalls(multicallHandlerAddress, fallbackAndDrainAddress, tokensToDrain);
-    const allCalls = [approveCall, ...middleCalls, ...drainCalls];
-    return createAcrossMultiCallMessage(allCalls, fallbackAndDrainAddress);
+    return [approveCall, ...middleCalls];
 }
 export function createAcrossDrainMessage(multicallHandlerAddress, fallbackAndDrainAddress, tokensToDrain) {
     const drainCalls = createDrainCalls(multicallHandlerAddress, fallbackAndDrainAddress, tokensToDrain);

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

@@ -1,6 +1,6 @@
 import { GenericTrade, RawCurrency, useGeneralPricesCallbackType } from '@1delta/lib-utils';
-import { BaseAxelarComposedInput } from '../../types';
-export interface AxelarWithSwapInput extends BaseAxelarComposedInput {
+import { BaseComposedWithGasLimitInput } from '../../types';
+export interface AxelarWithSwapInput extends BaseComposedWithGasLimitInput {
     bridgeToCurrency: RawCurrency | undefined;
 }
 export declare const fetchAxelarTradeWithSwap: (input: AxelarWithSwapInput, getPrices: useGeneralPricesCallbackType, controller?: AbortController) => Promise<{

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

@@ -1 +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,EAEL,uBAAuB,EAExB,MAAM,aAAa,CAAA;AAKpB,MAAM,WAAW,mBAAoB,SAAQ,uBAAuB;IAClE,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,CA8CA,CAAA;AAED,eAAe,wBAAwB,CAAA"}
+{"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,EAGL,6BAA6B,EAC9B,MAAM,aAAa,CAAA;AASpB,MAAM,WAAW,mBAAoB,SAAQ,6BAA6B;IACxE,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,CA8CA,CAAA;AAED,eAAe,wBAAwB,CAAA"}

package/dist/composedTrades/axelar/axelarWithSwap.js

@@ -3,6 +3,7 @@ import { CurrencyHandler, normalizeDecimals, TradeType, } from '@1delta/lib-util
 import { fetchBridgeTrade } from '../../bridge/fetchBridgeTrade';
 import { fetchBridgeAndGasTrade } from '../utils/fetchBridgeAndGasTrade';
 import { fetchBestTrade } from '../utils/multichainUtils';
+import { ADDITIONAL_CALLS_GAS_LIMIT, DESTINATION_SWAP_GAS_LIMIT, } from './constants';
 import { createSquidDestinationPayload } from './squid/createSquidPayload';
 export const fetchAxelarTradeWithSwap = async (input, getPrices, controller) => {
     if (!input.bridgeToCurrency)
@@ -11,7 +12,7 @@ export const fetchAxelarTradeWithSwap = async (input, getPrices, controller) =>
         throw new Error('ToCurrency undefined');
     const toChainId = input.toCurrency.chainId;
     const toTokenIsBridgeToken = CurrencyHandler.equal(input.bridgeToCurrency, input.toCurrency);
-    const needDestinationCalls = (input.additionalCalls?.length ?? 0) > 0 || !toTokenIsBridgeToken;
+    const needDestinationCalls = (input.additionalCalls?.calls.length ?? 0) > 0 || !toTokenIsBridgeToken;
     const squidRouter = await getRequiredSquidRouter(toChainId);
     if (!needDestinationCalls) {
         // direct case
@@ -45,7 +46,9 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
         throw new Error('BridgeToCurrency undefined');
     const toChainId = input.toCurrency.chainId;
     const squidMulticall = await getRequiredSquidMulticaller(toChainId);
-    const additionalCalls = input.additionalCalls ?? [];
+    const additionalCallsGasLimit = input.additionalCalls?.gasLimit ?? ADDITIONAL_CALLS_GAS_LIMIT;
+    const additionalCalls = input.additionalCalls?.calls ?? [];
+    const needsAdditionalCalls = additionalCalls.length > 0;
     const needsSwap = !CurrencyHandler.equal(input.bridgeToCurrency, input.toCurrency);
     const fetchSwapAndMessage = async (amount) => {
         if (needsSwap) {
@@ -68,21 +71,21 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
             const tx = await destinationSwapTrade.assemble();
             if (!tx?.EVM)
                 return undefined;
-            const message = createSquidDestinationPayload(input.receiver, [
-                destinationSwapTrade.inputAmount.currency.address,
-                destinationSwapTrade.outputAmount.currency.address,
-            ], additionalCalls, {
+            const message = createSquidDestinationPayload(toChainId, destinationSwapTrade.inputAmount.currency.address, destinationSwapTrade.outputAmount.currency.address, input.receiver, additionalCalls, {
                 tokenToApprove: destinationSwapTrade.inputAmount.currency.address,
                 amountToApprove: destinationSwapTrade.inputAmount.amount,
                 spender: destinationSwapTrade.target,
                 calls: [tx.EVM],
             });
-            return { message, destinationSwapTrade };
+            const gasLimit = DESTINATION_SWAP_GAS_LIMIT +
+                (needsAdditionalCalls ? additionalCallsGasLimit : 0n);
+            return { message, destinationSwapTrade, gasLimit };
         }
-        else if (additionalCalls.length > 0) {
+        else if (needsAdditionalCalls) {
             // Handle only destination calls case
-            const message = createSquidDestinationPayload(input.receiver, [input.bridgeToCurrency.address], additionalCalls);
-            return { message, destinationSwapTrade: undefined };
+            const message = createSquidDestinationPayload(toChainId, undefined, input.bridgeToCurrency.address, input.receiver, additionalCalls);
+            const gasLimit = additionalCallsGasLimit;
+            return { message, destinationSwapTrade: undefined, gasLimit };
         }
         return undefined;
     };
@@ -94,7 +97,7 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
         ...input,
         toCurrency: input.bridgeToCurrency,
         message: swap.message,
-        destinationGasLimit: 1000000n,
+        destinationGasLimit: swap.gasLimit,
     };
     const bridgeAndGasTrade = await fetchBridgeAndGasTrade(Bridge.AXELAR, axelarInput, getPrices, controller);
     if (!bridgeAndGasTrade)

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

@@ -1,5 +1,5 @@
 import { GenericTrade, RawCurrency, useGeneralPricesCallbackType } from '@1delta/lib-utils';
-import { BaseAxelarComposedInput } from '../../types';
-export declare const fetchAxelarTradeWithSwaps: (input: BaseAxelarComposedInput, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency | undefined, getPrices: useGeneralPricesCallbackType, controller?: AbortController) => Promise<GenericTrade | undefined>;
+import { BaseComposedWithGasLimitInput } from '../../types';
+export declare const fetchAxelarTradeWithSwaps: (input: BaseComposedWithGasLimitInput, 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

@@ -1 +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,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAmBtE,eAAO,MAAM,yBAAyB,GACpC,OAAO,uBAAuB,EAC9B,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"}
+{"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,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAmB5E,eAAO,MAAM,yBAAyB,GACpC,OAAO,6BAA6B,EACpC,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"}

package/dist/composedTrades/axelar/axelarWithSwaps.js

@@ -1,4 +1,4 @@
-import { convertRawAmount } from '@1delta/aggregators';
+import { convertRawAmount } from '@1delta/lib-utils';
 import { CurrencyHandler, getDeltaComposerProxyAddress, getForwarderAddress, getSafeChainId, minimumAmountOutFromTrade, splitSlippage, TradeType, } from '@1delta/lib-utils';
 import { fetchBestTrade, increaseAmountBySlippage } from '../utils';
 import { createSwapAndBridgeCalldata } from '../utils/createSwapAndBridgeCalldata';

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

@@ -6,4 +6,6 @@ export declare enum AxelarTokenSymbol {
     axlWBTC = "wbtc-satoshi",
     axlETH = "weth-wei"
 }
+export declare const DESTINATION_SWAP_GAS_LIMIT = 2000000n;
+export declare const ADDITIONAL_CALLS_GAS_LIMIT = 1000000n;
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +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"}
+{"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;AAED,eAAO,MAAM,0BAA0B,WAAa,CAAA;AAEpD,eAAO,MAAM,0BAA0B,WAAa,CAAA"}

package/dist/composedTrades/axelar/constants.js

@@ -7,3 +7,5 @@ export var AxelarTokenSymbol;
     AxelarTokenSymbol["axlWBTC"] = "wbtc-satoshi";
     AxelarTokenSymbol["axlETH"] = "weth-wei";
 })(AxelarTokenSymbol || (AxelarTokenSymbol = {}));
+export const DESTINATION_SWAP_GAS_LIMIT = 2000000n;
+export const ADDITIONAL_CALLS_GAS_LIMIT = 1000000n;

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

@@ -1,30 +1,28 @@
-import { EvmGenericCallInfo } from '@1delta/lib-utils';
 import { Hex } from 'viem';
-import { SimpleSquidCall } from './types';
+import { DeltaCall } from '../../../types/deltaCall';
+import { DestinationSwapData } from '../../../types/destinationSwapData';
 /**
- * Creates the final `payload` for a complete "Approve -> Execute -> Drain" sequence
- * using the Squid multicaller.
+ * Creates the final `payload` for a complete cross-chain swap using Squid.
  *
- * 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.
+ * This function supports two main flows:
  *
- * @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`).
+ * 1. **Normal Flow** (when no additional calls are provided):
+ *    - Executes swap calls if destination swap data is provided
+ *    - Drains all relevant tokens (input and output) to the refundAndDrainAddress
+ *
+ * 2. **Composer Flow** (when additional calls are provided):
+ *    - Executes swap calls if destination swap data is provided
+ *    - Drains input token (if any) to refundAndDrainAddress
+ *    - Drains output token to the Delta Forwarder contract
+ *    - Creates and appends a Delta Composer call to execute additional operations
+ *
+ * @param chainId - The ID of the destination chain
+ * @param inputToken - The address of the input token (optional)
+ * @param outputToken - The address of the output token
+ * @param refundAndDrainAddress - The address that receives refunds and drained tokens
+ * @param additionalCalls - Optional array of DeltaCall objects for the composer flow
+ * @param destinationSwapData - Optional swap data for destination chain swaps
+ * @returns The final, ABI-encoded `payload` as a hex string (`Hex`)
  */
-export declare function createSquidDestinationPayload(refundAndDrainAddress: string, tokensToDrain: string[], additionalCalls: SimpleSquidCall[], destinationSwapData?: DestinationSwapData): Hex;
-interface DestinationSwapData {
-    tokenToApprove: string;
-    amountToApprove: bigint;
-    spender: string;
-    calls: EvmGenericCallInfo[];
-}
-export {};
+export declare function createSquidDestinationPayload(chainId: string, inputToken: string | undefined, outputToken: string, refundAndDrainAddress: string, additionalCalls: DeltaCall[], destinationSwapData?: DestinationSwapData): Hex;
 //# sourceMappingURL=createSquidPayload.d.ts.map

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

@@ -1 +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,EAA+B,GAAG,EAAyB,MAAM,MAAM,CAAA;AAG9E,OAAO,EAAE,eAAe,EAAuB,MAAM,SAAS,CAAA;AAsD9D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,6BAA6B,CAC3C,qBAAqB,EAAE,MAAM,EAC7B,aAAa,EAAE,MAAM,EAAE,EACvB,eAAe,EAAE,eAAe,EAAE,EAClC,mBAAmB,CAAC,EAAE,mBAAmB,GACxC,GAAG,CAYL;AAED,UAAU,mBAAmB;IAC3B,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,kBAAkB,EAAE,CAAA;CAC5B"}
+{"version":3,"file":"createSquidPayload.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/axelar/squid/createSquidPayload.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+B,GAAG,EAAyB,MAAM,MAAM,CAAA;AAG9E,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAA;AAyDxE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,WAAW,EAAE,MAAM,EACnB,qBAAqB,EAAE,MAAM,EAC7B,eAAe,EAAE,SAAS,EAAE,EAC5B,mBAAmB,CAAC,EAAE,mBAAmB,GACxC,GAAG,CA6DL"}

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

@@ -1,5 +1,8 @@
 import { createSquidPayload } from '@1delta/bridge-configs';
+import { CurrencyHandler } from '@1delta/lib-utils';
 import { encodeFunctionData, parseAbi, zeroAddress } from 'viem';
+import { createDeltaCallsCalldata } from '../../../deltaCall/createDeltaCallsCalldata';
+import { requireDeltaContracts } from '../../utils/requireDeltaContracts';
 import { toSquidCall } from './simpleSquidCall';
 import { SimpleSquidCallType } from './types';
 /**
@@ -44,35 +47,69 @@ function createSquidDrainCalls(receiverAddress, tokensToDrain) {
     return drainCalls;
 }
 /**
- * Creates the final `payload` for a complete "Approve -> Execute -> Drain" sequence
- * using the Squid multicaller.
+ * Creates the final `payload` for a complete cross-chain swap using Squid.
  *
- * 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.
+ * This function supports two main flows:
  *
- * @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`).
+ * 1. **Normal Flow** (when no additional calls are provided):
+ *    - Executes swap calls if destination swap data is provided
+ *    - Drains all relevant tokens (input and output) to the refundAndDrainAddress
+ *
+ * 2. **Composer Flow** (when additional calls are provided):
+ *    - Executes swap calls if destination swap data is provided
+ *    - Drains input token (if any) to refundAndDrainAddress
+ *    - Drains output token to the Delta Forwarder contract
+ *    - Creates and appends a Delta Composer call to execute additional operations
+ *
+ * @param chainId - The ID of the destination chain
+ * @param inputToken - The address of the input token (optional)
+ * @param outputToken - The address of the output token
+ * @param refundAndDrainAddress - The address that receives refunds and drained tokens
+ * @param additionalCalls - Optional array of DeltaCall objects for the composer flow
+ * @param destinationSwapData - Optional swap data for destination chain swaps
+ * @returns The final, ABI-encoded `payload` as a hex string (`Hex`)
  */
-export function createSquidDestinationPayload(refundAndDrainAddress, tokensToDrain, additionalCalls, destinationSwapData) {
+export function createSquidDestinationPayload(chainId, inputToken, outputToken, refundAndDrainAddress, additionalCalls, destinationSwapData) {
     const swapCalls = destinationSwapData
         ? createSquidSwapCalls(destinationSwapData)
         : [];
-    const drainCalls = createSquidDrainCalls(refundAndDrainAddress, tokensToDrain);
-    const allCalls = [...swapCalls, ...additionalCalls, ...drainCalls];
-    const allSquidCalls = allCalls.map((call) => toSquidCall(call));
-    return createSquidPayload(refundAndDrainAddress, allSquidCalls);
+    if (additionalCalls.length === 0) {
+        // normal case: do calls and sweep to user
+        const tokensToDrain = inputToken ? [inputToken, outputToken] : [outputToken];
+        const drainCalls = createSquidDrainCalls(refundAndDrainAddress, tokensToDrain);
+        const allCalls = [...swapCalls, ...drainCalls];
+        const allSquidCalls = allCalls.map((call) => toSquidCall(call));
+        return createSquidPayload(refundAndDrainAddress, allSquidCalls);
+    }
+    else {
+        // composer case: do calls and continue in composer
+        const { forwarder } = requireDeltaContracts(chainId);
+        const tokensToDrain = inputToken ? [inputToken] : [];
+        const drainToUserCall = createSquidDrainCalls(refundAndDrainAddress, tokensToDrain);
+        const drainToForwarder = CurrencyHandler.isNativeAddress(outputToken, chainId)
+            ? []
+            : createSquidDrainCalls(forwarder, [outputToken]);
+        const deltaComposerCall = createDeltaCallsCalldata(chainId, additionalCalls, {
+            tokensToSweep: [outputToken],
+            receiver: refundAndDrainAddress,
+        });
+        const callToComposer = {
+            callType: SimpleSquidCallType.FULL_NATIVE_BALANCE,
+            target: deltaComposerCall.to,
+            callData: deltaComposerCall.calldata,
+        };
+        const allCalls = [
+            ...swapCalls,
+            ...drainToUserCall,
+            ...drainToForwarder,
+            callToComposer,
+        ];
+        const allSquidCalls = allCalls.map((call) => toSquidCall(call));
+        return createSquidPayload(refundAndDrainAddress, allSquidCalls);
+    }
 }
 function createSquidSwapCalls(destinationSwapData) {
     const { tokenToApprove, amountToApprove, spender, calls } = destinationSwapData;
-    console.log('Axelar destinationSwapData', destinationSwapData);
     if (calls.some((call) => !call.to || !call.calldata)) {
         throw new Error('Invalid call data');
     }

package/dist/composedTrades/gaszip/gaszipWithSwaps.js

@@ -1,5 +1,5 @@
-import { convertRawAmount } from '@1delta/aggregators';
 import { Bridge } from '@1delta/bridge-configs';
+import { convertRawAmount } from '@1delta/lib-utils';
 import { CurrencyHandler, getDeltaComposerProxyAddress, getForwarderAddress, getSafeChainId, minimumAmountOutFromTrade, nativeOnChain, splitSlippage, TradeType, } from '@1delta/lib-utils';
 import { fetchBridgeTrade } from '../../bridge';
 import { createSwapAndBridgeCalldata } from '../utils/createSwapAndBridgeCalldata';

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

@@ -0,0 +1,5 @@
+export declare const requireDeltaContracts: (fromChainId: string) => {
+    forwarder: string;
+    composer: string;
+};
+//# sourceMappingURL=requireDeltaContracts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requireDeltaContracts.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/requireDeltaContracts.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM;;;CAQxD,CAAA"}

package/dist/composedTrades/utils/requireDeltaContracts.js

@@ -0,0 +1,10 @@
+import { getDeltaComposerProxyAddress, getForwarderAddress, } from '@1delta/lib-utils';
+export const requireDeltaContracts = (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 };
+};

package/dist/deltaCall/createDeltaCallsCalldata.d.ts

@@ -0,0 +1,10 @@
+import { Address, Hex } from 'viem';
+import { DeltaCall } from '../types/deltaCall';
+export declare const createDeltaCallsCalldata: (chainId: string, calls: DeltaCall[], sweepProps?: {
+    tokensToSweep: string[];
+    receiver: string;
+}) => {
+    calldata: Hex;
+    to: Address;
+};
+//# sourceMappingURL=createDeltaCallsCalldata.d.ts.map

package/dist/deltaCall/createDeltaCallsCalldata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDeltaCallsCalldata.d.ts","sourceRoot":"","sources":["../../src/deltaCall/createDeltaCallsCalldata.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAGnC,OAAO,EAAuB,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAInE,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,EACf,OAAO,SAAS,EAAE,EAClB,aAAa;IACX,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;CACjB,KACA;IACD,QAAQ,EAAE,GAAG,CAAA;IACb,EAAE,EAAE,OAAO,CAAA;CAuCZ,CAAA"}