@1delta/trade-sdk 0.1.1 → 0.1.3

package/README.md

@@ -18,7 +18,7 @@ pnpm add @1delta/trade-sdk
 ## Basic Usage
 
 ```typescript
-import { initialize, fetchBridgeTrade, fetchAggregatorTrade } from '@1delta/trade-sdk';
+import { initialize, fetchBridgeTrade, fetchAggregatorTrade, Bridge } from '@1delta/trade-sdk';
 import { WalletClient } from 'viem';
 
 // Initialize the SDK
@@ -34,13 +34,16 @@ const walletClient: WalletClient = /* your wallet client */;
 setWalletClient(walletClient);
 
 // Fetch a bridge trade
-const trade = await fetchBridgeTrade(bridge, {
-  fromCurrency: fromToken,
-  toCurrency: toToken,
-  amount: '1000000000000000000', // 1.0 in wei
-  receiver: '0x...',
-  caller: '0x...',
-  slippage: 0.5, // 0.5%
+const trade = await fetchBridgeTrade({
+  bridge: Bridge.ACROSS,
+  input: {
+    fromCurrency: fromToken,
+    toCurrency: toToken,
+    amount: '1000000000000000000', // 1.0 in wei
+    receiver: '0x...',
+    caller: '0x...',
+    slippage: 0.5, // 0.5%
+  }
 });
 ```
 
@@ -54,7 +57,7 @@ Initializes the SDK with the given configuration.
 
 Sets the wallet client for transaction signing.
 
-### `fetchBridgeTrade(bridge: Bridge, input: BridgeInput): Promise<GenericTrade>`
+### `fetchBridgeTrade(input: BridgeInput): Promise<GenericTrade>`
 
 Fetches a bridge trade quote.
 

package/dist/aggregator/fetchAggregatorTrade.d.ts

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

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;AACtC,OAAO,EAGL,eAAe,EAChB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,MAAM,EAAsB,MAAM,wBAAwB,CAAA;AACnE,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACd,MAAM,mBAAmB,CAAA;AAI1B,eAAO,MAAM,oBAAoB,GAC/B,YAAY,eAAe,GAAG,MAAM,EACpC,OAAO,kBAAkB,GAAG,aAAa,EACzC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAgBlC,CAAA"}
+{"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"}

package/dist/aggregator/fetchAggregatorTrade.js

@@ -1,7 +1,8 @@
 export * from './fetchAggregatorTrade';
-import { fetchAggregatorTrade as fetchAggregatorTradeWithoutConfigs, getAvailableAggregators, } from '@1delta/aggregators';
+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;

package/dist/bridge/fetchBridgeTrade.d.ts

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

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,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,OAAO,WAAW,EAClB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAiMlC,CAAA"}
+{"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 { BridgeInput } from '../../types';
-export interface AcrossWithSwapInput extends BridgeInput {
+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,WAAW,EAAE,MAAM,aAAa,CAAA;AAO1D,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,gBAAgB,EAAE,WAAW,GAAG,SAAS,CAAA;CAC1C;AAED,eAAO,MAAM,wBAAwB,GACnC,OAAO,mBAAmB,EAC1B,aAAa,eAAe,KAC3B,OAAO,CAAC;IAAE,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA6C/D,CAAA;AAED,eAAe,wBAAwB,CAAA"}
+{"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 { BridgeInput } from '../../types';
-export declare const fetchAcrossTradeWithSwaps: (input: BridgeInput, 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,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"}
+{"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;AAEjE,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAA;AAIxE,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,CA0DL;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 { createDeltaComposerCalldata } from '../../utils/deltaComposeCall/createDeltaComposerCalldata';
+import { requireDeltaContracts } from '../../utils/requireDeltaContracts';
 import { createAcrossMultiCallMessage } from './createAcrossMultiCallMessage';
 /**
  * Creates the ABI-encoded `message` for a complete "Approve -> Execute -> Drain" sequence
@@ -18,7 +20,40 @@ 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 = createDeltaComposerCalldata(chainId, [outputToken], refundAndDrainAddress, additionalCalls);
+        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 +75,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 { BridgeInput } from '../../types';
-export interface AxelarWithSwapInput extends BridgeInput {
+import { BaseComposedInput } from '../../types';
+export interface AxelarWithSwapInput extends BaseComposedInput {
     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,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"}
+{"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,iBAAiB,EAClB,MAAM,aAAa,CAAA;AAKpB,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,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,7 +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 { createSquidSwapPayload } from './squid/createSquidPayload';
+import { createSquidDestinationPayload } from './squid/createSquidPayload';
 export const fetchAxelarTradeWithSwap = async (input, getPrices, controller) => {
     if (!input.bridgeToCurrency)
         throw new Error('BridgeToCurrency undefined');
@@ -11,8 +11,9 @@ 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 squidRouter = await getRequiredSquidRouter(toChainId);
-    if (toTokenIsBridgeToken) {
+    if (!needDestinationCalls) {
         // direct case
         const message = createSquidPayload(input.receiver);
         const bridgeAndGasTrade = await fetchBridgeAndGasTrade(Bridge.AXELAR, { ...input, message }, getPrices, controller);
@@ -23,8 +24,8 @@ export const fetchAxelarTradeWithSwap = async (input, getPrices, controller) =>
         };
     }
     else {
-        // swap case
-        const bridgeAndGasTrade = await fetchAxelarTradeWithDestinationSwap(input, getPrices, controller);
+        // destination calls case
+        const bridgeAndGasTrade = await fetchAxelarTradeWithDestinationCalls(input, getPrices, controller);
         return {
             trade: bridgeAndGasTrade?.bridgeTrade,
             gasTrade: bridgeAndGasTrade?.gasTrade,
@@ -33,7 +34,7 @@ export const fetchAxelarTradeWithSwap = async (input, getPrices, controller) =>
     }
 };
 export default fetchAxelarTradeWithSwap;
-const fetchAxelarTradeWithDestinationSwap = async (input, getPrices, controller) => {
+const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller) => {
     if (!input.swapAmount)
         throw new Error('Swap amount undefined');
     if (!input.fromCurrency)
@@ -44,30 +45,43 @@ const fetchAxelarTradeWithDestinationSwap = async (input, getPrices, controller)
         throw new Error('BridgeToCurrency undefined');
     const toChainId = input.toCurrency.chainId;
     const squidMulticall = await getRequiredSquidMulticaller(toChainId);
+    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: 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 };
+        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: 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 = 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 };
+        }
+        else if (additionalCalls.length > 0) {
+            // Handle only destination calls case
+            const message = createSquidDestinationPayload(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);
@@ -83,9 +97,14 @@ const fetchAxelarTradeWithDestinationSwap = async (input, getPrices, controller)
     if (!bridgeAndGasTrade)
         return undefined;
     const { bridgeTrade, gasTrade } = bridgeAndGasTrade;
-    const updatedSwap = await fetchSwapAndMessage(bridgeTrade.outputAmount.amount);
-    if (!updatedSwap)
-        return undefined;
+    // Only update swap if we actually need a swap
+    let updatedSwap = swap;
+    if (needsSwap) {
+        const newSwap = await fetchSwapAndMessage(bridgeTrade.outputAmount.amount);
+        if (!newSwap)
+            return undefined;
+        updatedSwap = newSwap;
+    }
     const updatedAxelarTrade = await fetchBridgeTrade(Bridge.AXELAR, { ...axelarInput, message: updatedSwap.message }, controller);
     if (!updatedAxelarTrade)
         return undefined;
@@ -98,9 +117,13 @@ const fetchAxelarTradeWithDestinationSwap = async (input, getPrices, controller)
     };
     const composedTrade = {
         ...updatedAxelarTrade,
-        outputAmount: updatedSwap.destinationSwapTrade.outputAmount,
-        outputAmountRealized: updatedSwap.destinationSwapTrade.outputAmountRealized,
-        stringified: `${updatedAxelarTrade?.stringified}-${updatedSwap.destinationSwapTrade.stringified}`,
+        outputAmount: updatedSwap.destinationSwapTrade?.outputAmount ??
+            updatedAxelarTrade.outputAmount,
+        outputAmountRealized: updatedSwap.destinationSwapTrade?.outputAmountRealized ??
+            updatedAxelarTrade.outputAmountRealized,
+        stringified: updatedSwap.destinationSwapTrade
+            ? `${updatedAxelarTrade?.stringified}-${updatedSwap.destinationSwapTrade.stringified}`
+            : updatedAxelarTrade.stringified,
         refresh,
     };
     return { bridgeTrade: composedTrade, gasTrade };

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

@@ -0,0 +1,5 @@
+import { GenericTrade, RawCurrency, useGeneralPricesCallbackType } from '@1delta/lib-utils';
+import { BaseComposedInput } from '../../types';
+export declare const fetchAxelarTradeWithSwaps: (input: BaseComposedInput, 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,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAmBhE,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,WAAW,4BAA4B,EACvC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CA8JlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/composedTrades/axelar/{AxelarWithSwaps.js → 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/squid/createSquidPayload.d.ts

@@ -1,22 +1,28 @@
-import { EvmGenericCallInfo } from '@1delta/lib-utils';
 import { Hex } from 'viem';
+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 createSquidSwapPayload(tokenToApprove: string, amountToApprove: bigint, spender: string, calls: EvmGenericCallInfo[], refundAndDrainAddress: string, tokensToDrain: string[]): Hex;
+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,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"}
+{"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;AAE9E,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAA;AA0DxE;;;;;;;;;;;;;;;;;;;;;;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,CA2DL"}