@1delta/trade-sdk 0.1.6 → 0.1.8

package/README.md

@@ -18,15 +18,18 @@ pnpm add @1delta/trade-sdk
 ## Basic Usage
 
 ```typescript
-import { initialize, fetchBridgeTrade, fetchAggregatorTrade, Bridge } from '@1delta/trade-sdk';
+import { initialize, fetchBridgeTrade, fetchAggregatorTrade, Bridge, PriceGetter, CurrencyGetter } from '@1delta/trade-sdk';
 import { WalletClient } from 'viem';
 
 // Initialize the SDK
+const getPrice: PriceGetter = ...;
+
+const getCurrency: CurrencyGetter = ...;
+
 await initialize({
   isProductionEnv: true,
-  loadChainData: true,
-  loadSquidData: true,
-  load1deltaConfigs: true
+  priceGetter: getPrice,
+  currencyGetter: getCurrency,
 });
 
 // Set up wallet client

package/dist/aggregator/fetchAggregatorTrade.d.ts

@@ -1,4 +1,3 @@
-export * from './fetchAggregatorTrade';
 import { AggregatorApiInput, GenericTrade, OneDeltaInput } from '@1delta/lib-utils';
 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;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"}
+{"version":3,"file":"fetchAggregatorTrade.d.ts","sourceRoot":"","sources":["../../src/aggregator/fetchAggregatorTrade.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,kBAAkB,EAIlB,YAAY,EACZ,aAAa,EAEd,MAAM,mBAAmB,CAAA;AAe1B,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,EAClB,OAAO,kBAAkB,GAAG,aAAa,EACzC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAelC,CAAA"}

package/dist/aggregator/fetchAggregatorTrade.js

@@ -1,12 +1,96 @@
-export * from './fetchAggregatorTrade';
-import { fetchAggregatorTrade as fetchAggregatorTradeWithoutConfigs, } from '@1delta/aggregators';
+import { fetchAggregatorTrade as fetchAggregatorTradeWithoutConfigs, TradeAggregator, } from '@1delta/aggregators';
 import { getSwapAggregators } from '@1delta/bridge-configs';
-import { fetchBridgeTrade } from '../bridge';
+import { ChainType, ChainUtils, TradeType, } from '@1delta/lib-utils';
+import { fetchBridgeTrade } from '../bridge/fetchBridgeTrade';
+import { createSwapAndBridgeCalldata, requireDeltaContracts, } from '../composedTrades/utils';
+import { getPriceGetter } from '../registry';
+import { reverseQuote } from '../utils';
+const SUPPORT_EXACT_OUT = [
+    TradeAggregator.NativeWrapper,
+    TradeAggregator.ERC20Wrapper,
+];
 export const fetchAggregatorTrade = async (aggregator, input, controller) => {
+    const needsAdditionalCalls = (!!input.postCalls && input.postCalls.length > 0) ||
+        (!!input.preCalls && input.preCalls.length > 0);
+    if (input.disableComposer) {
+        if (needsAdditionalCalls)
+            throw new Error(`Aggregator ${aggregator.toString()} does not support additional calls without composer`);
+        return fetchSwapTrade(aggregator, input, controller);
+    }
+    else {
+        return fetchAggregatorWithComposerTrade(aggregator, input, controller);
+    }
+};
+const fetchAggregatorWithComposerTrade = async (aggregator, input, controller) => {
+    let trade = undefined;
+    const { forwarder, composer } = requireDeltaContracts(input.chainId);
+    trade = await fetchSwapTrade(aggregator, { ...input, caller: forwarder, receiver: forwarder }, controller);
+    if (!trade)
+        return undefined;
+    if (!trade.assemble)
+        throw new Error(`Aggregator ${aggregator.toString()} does not support composer`);
+    const assemble = async () => {
+        try {
+            const chainId = trade.inputAmount.currency.chainId;
+            if (ChainUtils.isEvm(chainId)) {
+                const fundsToPull = [
+                    {
+                        address: trade.inputAmount.currency.address,
+                        amount: trade.inputAmount.amount,
+                    },
+                ];
+                const tx = await createSwapAndBridgeCalldata([trade], input.caller, input.receiver, true, fundsToPull, false, true, input.preCalls, input.postCalls);
+                return {
+                    [ChainType.EVM]: {
+                        calldata: tx.calldata,
+                        value: tx.value.toString(),
+                        to: tx.to,
+                    },
+                };
+            }
+            return undefined;
+        }
+        catch (error) {
+            console.log(`cannot compose ${aggregator.toString()} swap tx:`, error);
+            return undefined;
+        }
+    };
+    return {
+        ...trade,
+        assemble,
+        approvalTarget: composer,
+        target: composer,
+    };
+};
+const fetchSwapTrade = async (aggregator, input, controller) => {
+    const reverseQuoteNeeded = input.tradeType === TradeType.EXACT_OUTPUT &&
+        !SUPPORT_EXACT_OUT.includes(aggregator);
+    if (reverseQuoteNeeded) {
+        const swapAmount = reverseQuote(input.fromCurrency, input.toCurrency, input.swapAmount).amount.toString();
+        return fetchExactInSwapTrade(aggregator, {
+            ...input,
+            tradeType: TradeType.EXACT_INPUT,
+            swapAmount,
+        }, controller);
+    }
+    return fetchExactInSwapTrade(aggregator, input, controller);
+};
+const fetchExactInSwapTrade = async (aggregator, input, controller) => {
     if (getSwapAggregators().includes(aggregator)) {
         return await fetchBridgeTrade(aggregator, { ...input, order: 'CHEAPEST' }, controller);
     }
     else {
-        return await fetchAggregatorTradeWithoutConfigs(aggregator, input, controller);
+        const getPrice = getPriceGetter();
+        const [priceIn, priceOut] = getPrice([
+            {
+                chainId: input.fromCurrency.chainId,
+                tokenAddress: input.fromCurrency.address,
+            },
+            {
+                chainId: input.toCurrency.chainId,
+                tokenAddress: input.toCurrency.address,
+            },
+        ]);
+        return await fetchAggregatorTradeWithoutConfigs(aggregator, { ...input, priceIn, priceOut }, controller);
     }
 };

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

@@ -1,6 +1,6 @@
 import { GenericTrade, RawCurrency } from '@1delta/lib-utils';
 import { AcrossBaseInput } from '../../types';
-export interface AcrossWithSwapInput extends AcrossBaseInput {
+export interface AcrossWithSwapInput extends Omit<AcrossBaseInput, 'preCalls'> {
     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,EAAE,eAAe,EAAmB,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,CAgD/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,EAAE,eAAe,EAAmB,MAAM,aAAa,CAAA;AAO9D,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC;IAC5E,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,7 @@ 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));
-    const needDestinationCalls = (input.additionalCalls?.length ?? 0) > 0 || !toTokenIsBridgeToken;
+    const needDestinationCalls = (input.postCalls?.length ?? 0) > 0 || !toTokenIsBridgeToken;
     if (!needDestinationCalls) {
         const toTokenIsWNative = CurrencyHandler.isWNative(input.toCurrency);
         if (toTokenIsWNative) {
@@ -66,7 +66,7 @@ const fetchAcrossTradeWithDestinationCalls = async (input, controller) => {
     if (!input.bridgeToCurrency)
         throw new Error('BridgeToCurrency undefined');
     const toChainId = input.toCurrency.chainId;
-    const additionalCalls = input.additionalCalls ?? [];
+    const additionalCalls = input.postCalls ?? [];
     const needsSwap = !CurrencyHandler.equal(input.bridgeToCurrency, input.toCurrency);
     const fetchSwapAndMessage = async (amount) => {
         if (needsSwap) {
@@ -82,6 +82,7 @@ const fetchAcrossTradeWithDestinationCalls = async (input, controller) => {
                 caller: getAcrossMulticallHandler(toChainId),
                 receiver: input.receiver,
                 flashSwap: undefined,
+                disableComposer: true,
             };
             const destinationSwapTrade = await fetchBestTrade(destinationSwapInput, controller);
             if (!destinationSwapTrade || !destinationSwapTrade.assemble)

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

@@ -1,5 +1,5 @@
-import { GenericTrade, RawCurrency } from '@1delta/lib-utils';
+import { GenericTrade } from '@1delta/lib-utils';
 import { AcrossBaseInput } from '../../types';
-export declare const fetchAcrossTradeWithSwaps: (input: AcrossBaseInput, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency | undefined, controller?: AbortController) => Promise<GenericTrade | undefined>;
+export declare const fetchAcrossTradeWithSwaps: (input: AcrossBaseInput, 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,EAAE,eAAe,EAAmB,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,CAqKlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}
+{"version":3,"file":"acrossWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossWithSwaps.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,YAAY,EASb,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAE,eAAe,EAAmB,MAAM,aAAa,CAAA;AAsB9D,eAAO,MAAM,yBAAyB,GACpC,OAAO,eAAe,EACtB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAyKlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/composedTrades/across/acrossWithSwaps.js

@@ -1,5 +1,6 @@
 import { convertRawAmount } from '@1delta/lib-utils';
 import { CurrencyHandler, getDeltaComposerProxyAddress, getForwarderAddress, getSafeChainId, minimumAmountOutFromTrade, nativeOnChain, splitSlippage, TradeType, } from '@1delta/lib-utils';
+import { getCurrencyGetter } from '../../registry';
 import { createSwapAndBridgeCalldata } from '../utils/createSwapAndBridgeCalldata';
 import { fetchBestTrade, increaseAmountBySlippage, } from '../utils/multichainUtils';
 import { fetchAcrossRoutes, selectAcrossRoute } from './acrossRoutes';
@@ -15,7 +16,7 @@ const validateContracts = (fromChainId) => {
     return { forwarder, composer };
 };
 const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
-export const fetchAcrossTradeWithSwaps = async (input, getCurrency, controller) => {
+export const fetchAcrossTradeWithSwaps = async (input, controller) => {
     if (!input.fromCurrency || !input.toCurrency)
         return undefined;
     if (input.tradeType === TradeType.EXACT_OUTPUT)
@@ -31,6 +32,7 @@ export const fetchAcrossTradeWithSwaps = async (input, getCurrency, controller)
     const acrossRoute = selectAcrossRoute(routes, input.fromCurrency, input.toCurrency);
     if (!acrossRoute)
         return undefined;
+    const getCurrency = getCurrencyGetter();
     const fromAcrossCurrency = getCurrency(acrossRoute.originChainId.toString(), acrossRoute.originToken);
     const toAcrossCurrency = getCurrency(acrossRoute.destinationChainId.toString(), acrossRoute.destinationToken);
     const outputIsAcrossAsset = CurrencyHandler.equal(CurrencyHandler.wrapped(input.toCurrency), toAcrossCurrency);
@@ -48,6 +50,7 @@ export const fetchAcrossTradeWithSwaps = async (input, getCurrency, controller)
             caller: forwarder,
             receiver: forwarder,
             flashSwap: undefined,
+            disableComposer: true,
         };
         sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
     }
@@ -82,7 +85,7 @@ export const fetchAcrossTradeWithSwaps = async (input, getCurrency, controller)
                 amount: BigInt(input.swapAmount),
             },
         ];
-        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, bridgeReceiver, false, fundsToPull, false);
+        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, bridgeReceiver, false, fundsToPull, false, false, input.preCalls);
         return {
             EVM: {
                 to,
@@ -96,7 +99,7 @@ export const fetchAcrossTradeWithSwaps = async (input, getCurrency, controller)
             ...input,
             slippage: inputOverride?.slippage ?? input.slippage,
         };
-        return fetchAcrossTradeWithSwaps(newAggregatorInput, getCurrency);
+        return fetchAcrossTradeWithSwaps(newAggregatorInput);
     };
     const outputAmount = !!sourceSwapTrade
         ? increaseAmountBySlippage(acrossTradeWithSwap.outputAmount.amount, Number(swapSlippage))

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

@@ -1,5 +1,5 @@
+import { DeltaCall } from '@1delta/lib-utils';
 import { Hex } from 'viem';
-import { DeltaCall } from '../../../types/deltaCall';
 import { DestinationSwapData } from '../../../types/destinationSwapData';
 import { AcrossCall } from './types';
 /**

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,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"}
+{"version":3,"file":"createAcrossMessage.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/across/calldata/createAcrossMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAA+B,GAAG,EAAY,MAAM,MAAM,CAAA;AAGjE,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/axelar/axelarWithSwap.d.ts

@@ -1,9 +1,9 @@
-import { GenericTrade, RawCurrency, useGeneralPricesCallbackType } from '@1delta/lib-utils';
+import { GenericTrade, RawCurrency } from '@1delta/lib-utils';
 import { AxelarBaseInput } from '../../types';
-export interface AxelarWithSwapInput extends AxelarBaseInput {
+export interface AxelarWithSwapInput extends Omit<AxelarBaseInput, 'preCalls'> {
     bridgeToCurrency: RawCurrency | undefined;
 }
-export declare const fetchAxelarTradeWithSwap: (input: AxelarWithSwapInput, getPrices: useGeneralPricesCallbackType, controller?: AbortController) => Promise<{
+export declare const fetchAxelarTradeWithSwap: (input: AxelarWithSwapInput, controller?: AbortController) => Promise<{
     trade: GenericTrade | undefined;
     gasTrade: GenericTrade | undefined;
     receiver: string;

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,eAAe,EAAmB,MAAM,aAAa,CAAA;AAS/E,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,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,EAEZ,MAAM,mBAAmB,CAAA;AAI1B,OAAO,EAAmB,eAAe,EAAmB,MAAM,aAAa,CAAA;AAS/E,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC;IAC5E,gBAAgB,EAAE,WAAW,GAAG,SAAS,CAAA;CAC1C;AAED,eAAO,MAAM,wBAAwB,GACnC,OAAO,mBAAmB,EAC1B,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,CA4CA,CAAA;AAED,eAAe,wBAAwB,CAAA"}

package/dist/composedTrades/axelar/axelarWithSwap.js

@@ -5,19 +5,19 @@ 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) => {
+export const fetchAxelarTradeWithSwap = async (input, 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 needDestinationCalls = (input.additionalCalls?.calls.length ?? 0) > 0 || !toTokenIsBridgeToken;
+    const needDestinationCalls = (input.postCalls?.calls.length ?? 0) > 0 || !toTokenIsBridgeToken;
     const squidRouter = await getRequiredSquidRouter(toChainId);
     if (!needDestinationCalls) {
         // direct case
         const message = createSquidPayload(input.receiver);
-        const bridgeAndGasTrade = await fetchAxelarTrade(input.payFeeWithNative, { ...input, message }, getPrices, controller);
+        const bridgeAndGasTrade = await fetchAxelarTrade(input.payFeeWithNative, { ...input, message }, controller);
         return {
             trade: bridgeAndGasTrade?.bridgeTrade,
             gasTrade: bridgeAndGasTrade?.gasTrade,
@@ -26,7 +26,7 @@ export const fetchAxelarTradeWithSwap = async (input, getPrices, controller) =>
     }
     else {
         // destination calls case
-        const bridgeAndGasTrade = await fetchAxelarTradeWithDestinationCalls(input, getPrices, controller);
+        const bridgeAndGasTrade = await fetchAxelarTradeWithDestinationCalls(input, controller);
         return {
             trade: bridgeAndGasTrade?.bridgeTrade,
             gasTrade: bridgeAndGasTrade?.gasTrade,
@@ -35,7 +35,7 @@ export const fetchAxelarTradeWithSwap = async (input, getPrices, controller) =>
     }
 };
 export default fetchAxelarTradeWithSwap;
-const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller) => {
+const fetchAxelarTradeWithDestinationCalls = async (input, controller) => {
     if (!input.swapAmount)
         throw new Error('Swap amount undefined');
     if (!input.fromCurrency)
@@ -46,8 +46,8 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
         throw new Error('BridgeToCurrency undefined');
     const toChainId = input.toCurrency.chainId;
     const squidMulticall = await getRequiredSquidMulticaller(toChainId);
-    const additionalCallsGasLimit = input.additionalCalls?.gasLimit ?? ADDITIONAL_CALLS_GAS_LIMIT;
-    const additionalCalls = input.additionalCalls?.calls ?? [];
+    const additionalCallsGasLimit = input.postCalls?.gasLimit ?? ADDITIONAL_CALLS_GAS_LIMIT;
+    const additionalCalls = input.postCalls?.calls ?? [];
     const needsAdditionalCalls = additionalCalls.length > 0;
     const needsSwap = !CurrencyHandler.equal(input.bridgeToCurrency, input.toCurrency);
     const fetchSwapAndMessage = async (amount) => {
@@ -64,6 +64,7 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
                 caller: squidMulticall,
                 receiver: squidMulticall,
                 flashSwap: undefined,
+                disableComposer: true,
             };
             const destinationSwapTrade = await fetchBestTrade(destinationSwapInput, controller);
             if (!destinationSwapTrade || !destinationSwapTrade.assemble)
@@ -99,7 +100,7 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
         message: swap.message,
         destinationGasLimit: swap.gasLimit,
     };
-    const bridgeAndGasTrade = await fetchAxelarTrade(input.payFeeWithNative, axelarInput, getPrices, controller);
+    const bridgeAndGasTrade = await fetchAxelarTrade(input.payFeeWithNative, axelarInput, controller);
     if (!bridgeAndGasTrade)
         return undefined;
     const { bridgeTrade, gasTrade } = bridgeAndGasTrade;
@@ -119,7 +120,7 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
             ...input,
             slippage: inputOverride?.slippage ?? input.slippage,
         };
-        return (await fetchAxelarTradeWithSwap(newAggregatorInput, getPrices)).trade;
+        return (await fetchAxelarTradeWithSwap(newAggregatorInput)).trade;
     };
     const composedTrade = {
         ...updatedAxelarTrade,
@@ -134,13 +135,13 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
     };
     return { bridgeTrade: composedTrade, gasTrade };
 };
-const fetchAxelarTrade = async (payFeeWithNative, input, getPrices, controller) => {
+const fetchAxelarTrade = async (payFeeWithNative, input, controller) => {
     if (payFeeWithNative) {
         const bridgeTrade = await fetchBridgeTrade(Bridge.AXELAR, input, controller);
         return bridgeTrade ? { bridgeTrade, gasTrade: undefined } : undefined;
     }
     else {
-        const bridgeAndGasTrade = await fetchBridgeAndGasTrade(Bridge.AXELAR, input, getPrices, controller);
+        const bridgeAndGasTrade = await fetchBridgeAndGasTrade(Bridge.AXELAR, input, controller);
         return bridgeAndGasTrade;
     }
 };

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

@@ -1,5 +1,5 @@
-import { GenericTrade, RawCurrency, useGeneralPricesCallbackType } from '@1delta/lib-utils';
+import { GenericTrade } from '@1delta/lib-utils';
 import { AxelarBaseInput } from '../../types';
-export declare const fetchAxelarTradeWithSwaps: (input: AxelarBaseInput, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency | undefined, getPrices: useGeneralPricesCallbackType, controller?: AbortController) => Promise<GenericTrade | undefined>;
+export declare const fetchAxelarTradeWithSwaps: (input: AxelarBaseInput, 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,eAAe,EAAE,MAAM,aAAa,CAAA;AAmB9D,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,WAAW,4BAA4B,EACvC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAqKlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}
+{"version":3,"file":"axelarWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarWithSwaps.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,YAAY,EAQb,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAmB,eAAe,EAAE,MAAM,aAAa,CAAA;AAmB9D,eAAO,MAAM,yBAAyB,GACpC,OAAO,eAAe,EACtB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAwKlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/composedTrades/axelar/axelarWithSwaps.js

@@ -1,5 +1,6 @@
 import { convertRawAmount, nativeOnChain } from '@1delta/lib-utils';
 import { CurrencyHandler, getDeltaComposerProxyAddress, getForwarderAddress, getSafeChainId, minimumAmountOutFromTrade, splitSlippage, TradeType, } from '@1delta/lib-utils';
+import { getCurrencyGetter } from '../../registry';
 import { fetchBestTrade, increaseAmountBySlippage } from '../utils';
 import { createSwapAndBridgeCalldata } from '../utils/createSwapAndBridgeCalldata';
 import { fetchAxelarRoute } from './axelarRoutes';
@@ -15,7 +16,7 @@ const validateContracts = (fromChainId) => {
     return { forwarder, composer };
 };
 const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
-export const fetchAxelarTradeWithSwaps = async (input, getCurrency, getPrices, controller) => {
+export const fetchAxelarTradeWithSwaps = async (input, controller) => {
     if (!input.fromCurrency || !input.toCurrency)
         return undefined;
     if (input.tradeType === TradeType.EXACT_OUTPUT)
@@ -30,6 +31,7 @@ export const fetchAxelarTradeWithSwaps = async (input, getCurrency, getPrices, c
     const route = await fetchAxelarRoute(fromChainId, toChainId);
     if (!route)
         return undefined;
+    const getCurrency = getCurrencyGetter();
     const fromBridgeCurrency = getCurrency(fromChainId, route.fromBridgeToken);
     const toBridgeCurrency = getCurrency(toChainId, route.toBridgeToken);
     const outputIsBridgeAsset = CurrencyHandler.equal(CurrencyHandler.wrapped(input.toCurrency), toBridgeCurrency);
@@ -47,6 +49,7 @@ export const fetchAxelarTradeWithSwaps = async (input, getCurrency, getPrices, c
             caller: forwarder,
             receiver: forwarder,
             flashSwap: undefined,
+            disableComposer: true,
         };
         sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
     }
@@ -62,7 +65,7 @@ export const fetchAxelarTradeWithSwaps = async (input, getCurrency, getPrices, c
         caller: forwarder,
         receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
     };
-    const { trade: bridgeTradeWithSwap, gasTrade, receiver: bridgeReceiver, } = await fetchAxelarTradeWithSwap(bridgeExtendedInput, getPrices, controller);
+    const { trade: bridgeTradeWithSwap, gasTrade, receiver: bridgeReceiver, } = await fetchAxelarTradeWithSwap(bridgeExtendedInput, controller);
     if (!bridgeTradeWithSwap)
         return undefined;
     const trades = [];
@@ -86,7 +89,7 @@ export const fetchAxelarTradeWithSwaps = async (input, getCurrency, getPrices, c
                 amount: bridgeTradeWithSwap.gasAmount,
             });
         }
-        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, bridgeReceiver, true, fundsToPull, false, true);
+        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, bridgeReceiver, true, fundsToPull, false, true, input.preCalls);
         return {
             EVM: {
                 to,
@@ -100,7 +103,7 @@ export const fetchAxelarTradeWithSwaps = async (input, getCurrency, getPrices, c
             ...input,
             slippage: inputOverride?.slippage ?? input.slippage,
         };
-        return fetchAxelarTradeWithSwaps(newAggregatorInput, getCurrency, getPrices);
+        return fetchAxelarTradeWithSwaps(newAggregatorInput);
     };
     const outputAmount = !!sourceSwapTrade
         ? increaseAmountBySlippage(bridgeTradeWithSwap.outputAmount.amount, Number(swapSlippage))

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

@@ -1,5 +1,5 @@
+import { DeltaCall } 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 cross-chain swap using Squid.

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":"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"}
+{"version":3,"file":"createSquidPayload.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/axelar/squid/createSquidPayload.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAA+B,GAAG,EAAyB,MAAM,MAAM,CAAA;AAG9E,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/gaszip/gaszipWithSwaps.d.ts.map

@@ -1 +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,eAAe,EAAE,MAAM,aAAa,CAAA;AAoB9D,eAAO,MAAM,yBAAyB,GACpC,OAAO,eAAe,EACtB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAkJlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}
+{"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,eAAe,EAAE,MAAM,aAAa,CAAA;AAoB9D,eAAO,MAAM,yBAAyB,GACpC,OAAO,eAAe,EACtB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAmJlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/composedTrades/gaszip/gaszipWithSwaps.js

@@ -45,6 +45,7 @@ export const fetchGaszipTradeWithSwaps = async (input, controller) => {
             caller: forwarder,
             receiver: forwarder,
             flashSwap: undefined,
+            disableComposer: true,
         };
         sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
     }

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

@@ -1,8 +1,8 @@
-import { InternalTrade } from '@1delta/lib-utils';
+import { InternalTrade, PostDeltaCall, PreDeltaCall } 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<{
+}[], catchRevert?: boolean, sweepDust?: boolean, preCalls?: PreDeltaCall[], postCalls?: PostDeltaCall[]): Promise<{
     calldata: `0x${string}`;
     value: bigint;
     to: string;

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

@@ -1 +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"}
+{"version":3,"file":"createSwapAndBridgeCalldata.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/createSwapAndBridgeCalldata.ts"],"names":[],"mappings":"AAcA,OAAO,EAOL,aAAa,EAGb,aAAa,EACb,YAAY,EAGb,MAAM,mBAAmB,CAAA;AAK1B,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,EAC1B,QAAQ,GAAE,YAAY,EAAO,EAC7B,SAAS,GAAE,aAAa,EAAO;;;;GAiRhC"}

package/dist/composedTrades/utils/createSwapAndBridgeCalldata.js

@@ -2,10 +2,15 @@ import { Bridge } from '@1delta/bridge-configs';
 import { encodeAcrossBridgeNative, encodeAcrossBridgeToken, encodeApprove, encodeExternalCall, encodeGasZipEvmBridge, encodeSquidRouterCall, encodeStargateV2BridgeSimpleTaxi, encodeSweep, encodeTransferIn, encodeTryExternalCall, SweepType, } from '@1delta/calldatalib';
 import { buildMetaSwapParams, CurrencyHandler, encodeComposerCompose, getDeltaComposerProxyAddress, getForwarderAddress, minimumAmountInFromAmount, packCommands, TradeUtils, } from '@1delta/lib-utils';
 import { encodePacked, pad } from 'viem';
-export async function createSwapAndBridgeCalldata(trades, account, bridgeReceiver, sweep, fundsToPull = [], catchRevert = true, sweepDust = false) {
+import { createDeltaCalls } from '../../deltaCall';
+export async function createSwapAndBridgeCalldata(trades, account, bridgeReceiver, sweep, fundsToPull = [], catchRevert = true, sweepDust = false, preCalls = [], postCalls = []) {
     if (!trades || trades.length === 0 || !isSameSourceChainId(trades))
         throw new Error(`Invalid trades array. Must have at least one trade and all trades must be on the same chain`);
     const sourceChainId = trades[0].inputAmount.currency.chainId;
+    const destChainId = trades[trades.length - 1].outputAmount.currency.chainId;
+    const isCrossChain = sourceChainId !== destChainId;
+    if (isCrossChain && postCalls.length > 0)
+        throw new Error('Post-calls are not supported for cross-chain trades');
     const forwarder = getForwarderAddress(sourceChainId);
     if (!forwarder)
         throw new Error(`CallForwarder contract does not exist on chain ${sourceChainId}`);
@@ -95,6 +100,10 @@ export async function createSwapAndBridgeCalldata(trades, account, bridgeReceive
             sweepTokens.push(sweepOutputToken);
         }
     }
+    const { composerCommands: preComposerCommands } = createDeltaCalls(sourceChainId, preCalls);
+    const { forwarderCommands: postForwarderCommands, composerCommands: postComposerCommands, } = createDeltaCalls(sourceChainId, postCalls);
+    const forwarderSweepCommands = [];
+    const composerSweepCommands = [];
     if (sweep) {
         const sameChainTrades = trades.filter((t) => t.inputAmount.currency.chainId === t.outputAmount.currency.chainId);
         const currencyToAmount = TradeUtils.groupAmountByCurrency({
@@ -102,9 +111,21 @@ export async function createSwapAndBridgeCalldata(trades, account, bridgeReceive
             getCurrency: (t) => t.outputAmount.currency,
             getAmount: (t) => minimumAmountInFromAmount(t.outputAmount, t.slippage),
         });
-        for (const [currency, amount] of currencyToAmount.entries()) {
-            const sweepCall = encodeSweep(currency.address, account, sweepDust ? 0n : amount, SweepType.VALIDATE);
-            commands.push(sweepCall);
+        if (postComposerCommands.length > 0) {
+            // special case: first sweep to composer and after post composer calls sweep dust to receiver
+            for (const [currency, amount] of currencyToAmount.entries()) {
+                const forwarderSweepCall = encodeSweep(currency.address, composerProxy, sweepDust ? 0n : amount, SweepType.VALIDATE);
+                forwarderSweepCommands.push(forwarderSweepCall);
+                const composerSweepCall = encodeSweep(currency.address, account, 0n, SweepType.VALIDATE);
+                composerSweepCommands.push(composerSweepCall);
+            }
+        }
+        else {
+            // normal case: sweep directly to receiver after forwarder calls
+            for (const [currency, amount] of currencyToAmount.entries()) {
+                const forwarderSweepCall = encodeSweep(currency.address, account, sweepDust ? 0n : amount, SweepType.VALIDATE);
+                forwarderSweepCommands.push(forwarderSweepCall);
+            }
         }
     }
     let value = 0n;
@@ -115,9 +136,16 @@ export async function createSwapAndBridgeCalldata(trades, account, bridgeReceive
         else
             transferInCommands.push(encodeTransferIn(address, forwarder, amount));
     }
+    const preCommands = preComposerCommands.length > 0 ? preComposerCommands : transferInCommands;
     const calldata = encodeComposerCompose(packCommands([
-        ...transferInCommands,
-        encodeExternalCall(forwarder, value, false, packCommands(commands)),
+        ...preCommands,
+        encodeExternalCall(forwarder, 0n, true, packCommands([
+            ...commands,
+            ...postForwarderCommands,
+            ...forwarderSweepCommands,
+        ])),
+        ...postComposerCommands,
+        ...composerSweepCommands,
     ]));
     return { calldata, value, to: composerProxy };
 }

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

@@ -1,7 +1,7 @@
 import { Bridge } from '@1delta/bridge-configs';
-import { GenericTrade, useGeneralPricesCallbackType } from '@1delta/lib-utils';
+import { GenericTrade } from '@1delta/lib-utils';
 import { BaseBridgeInput } from '../../types';
-export declare const fetchBridgeAndGasTrade: (aggregator: Bridge, input: BaseBridgeInput, getPrices: useGeneralPricesCallbackType, controller?: AbortController) => Promise<{
+export declare const fetchBridgeAndGasTrade: (aggregator: Bridge, input: BaseBridgeInput, controller?: AbortController) => Promise<{
     bridgeTrade: GenericTrade;
     gasTrade: GenericTrade | undefined;
 } | undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"fetchBridgeAndGasTrade.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/fetchBridgeAndGasTrade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAEL,YAAY,EAEZ,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,sBAAsB,GACjC,YAAY,MAAM,EAClB,OAAO,eAAe,EACtB,WAAW,4BAA4B,EACvC,aAAa,eAAe,KAC3B,OAAO,CACR;IAAE,WAAW,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAA;CAAE,GAAG,SAAS,CA6E9E,CAAA"}
+{"version":3,"file":"fetchBridgeAndGasTrade.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/fetchBridgeAndGasTrade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAmB,YAAY,EAAiB,MAAM,mBAAmB,CAAA;AAGhF,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,sBAAsB,GACjC,YAAY,MAAM,EAClB,OAAO,eAAe,EACtB,aAAa,eAAe,KAC3B,OAAO,CACR;IAAE,WAAW,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAA;CAAE,GAAG,SAAS,CA2E9E,CAAA"}