@1delta/trade-sdk 0.1.7 → 0.1.9

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.map

@@ -1 +1 @@
-{"version":3,"file":"fetchAggregatorTrade.d.ts","sourceRoot":"","sources":["../../src/aggregator/fetchAggregatorTrade.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,kBAAkB,EAIlB,YAAY,EACZ,aAAa,EACd,MAAM,mBAAmB,CAAA;AAQ1B,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":"AAMA,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,10 +1,18 @@
-import { fetchAggregatorTrade as fetchAggregatorTradeWithoutConfigs, } from '@1delta/aggregators';
+import { fetchAggregatorTrade as fetchAggregatorTradeWithoutConfigs, TradeAggregator, } from '@1delta/aggregators';
 import { getSwapAggregators } from '@1delta/bridge-configs';
-import { ChainType, ChainUtils, } from '@1delta/lib-utils';
+import { getAllConfigs } from '@1delta/bridge-core';
+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.additionalCalls && input.additionalCalls.length > 0;
+    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`);
@@ -24,7 +32,7 @@ const fetchAggregatorWithComposerTrade = async (aggregator, input, controller) =
         throw new Error(`Aggregator ${aggregator.toString()} does not support composer`);
     const assemble = async () => {
         try {
-            const chainId = input.fromCurrency.chainId;
+            const chainId = trade.inputAmount.currency.chainId;
             if (ChainUtils.isEvm(chainId)) {
                 const fundsToPull = [
                     {
@@ -32,7 +40,7 @@ const fetchAggregatorWithComposerTrade = async (aggregator, input, controller) =
                         amount: trade.inputAmount.amount,
                     },
                 ];
-                const tx = await createSwapAndBridgeCalldata([trade], input.caller, input.receiver, true, fundsToPull, false, true, input.additionalCalls);
+                const tx = await createSwapAndBridgeCalldata([trade], input.caller, input.receiver, true, fundsToPull, false, true, input.preCalls, input.postCalls);
                 return {
                     [ChainType.EVM]: {
                         calldata: tx.calldata,
@@ -56,10 +64,35 @@ const fetchAggregatorWithComposerTrade = async (aggregator, input, controller) =
     };
 };
 const fetchSwapTrade = async (aggregator, input, controller) => {
-    if (getSwapAggregators().includes(aggregator)) {
+    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) ||
+        getAllConfigs().some((config) => config.name === 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) {

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,CAsKlC,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);
@@ -83,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,
@@ -97,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/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) => {
@@ -100,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;
@@ -120,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,
@@ -135,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,CAsKlC,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);
@@ -63,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 = [];
@@ -87,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,
@@ -101,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/utils/createSwapAndBridgeCalldata.d.ts

@@ -1,8 +1,8 @@
-import { DeltaCall, 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, additionalCalls?: DeltaCall[]): 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,EAGL,SAAS,EAKT,aAAa,EAKd,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,eAAe,GAAE,SAAS,EAAO;;;;GA2OlC"}
+{"version":3,"file":"createSwapAndBridgeCalldata.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/createSwapAndBridgeCalldata.ts"],"names":[],"mappings":"AAcA,OAAO,EAQL,aAAa,EAIb,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;;;;GAiThC"}

package/dist/composedTrades/utils/createSwapAndBridgeCalldata.js

@@ -1,12 +1,16 @@
 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 { buildMetaSwapParams, CurrencyHandler, DeltaCallType, encodeComposerCompose, getDeltaComposerProxyAddress, getForwarderAddress, LendingCall, minimumAmountInFromAmount, packCommands, TradeUtils, } from '@1delta/lib-utils';
 import { encodePacked, pad } from 'viem';
 import { createDeltaCalls } from '../../deltaCall';
-export async function createSwapAndBridgeCalldata(trades, account, bridgeReceiver, sweep, fundsToPull = [], catchRevert = true, sweepDust = false, additionalCalls = []) {
+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}`);
@@ -96,7 +100,10 @@ export async function createSwapAndBridgeCalldata(trades, account, bridgeReceive
             sweepTokens.push(sweepOutputToken);
         }
     }
-    const sweepCommands = [];
+    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({
@@ -104,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);
-            sweepCommands.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;
@@ -117,15 +136,40 @@ export async function createSwapAndBridgeCalldata(trades, account, bridgeReceive
         else
             transferInCommands.push(encodeTransferIn(address, forwarder, amount));
     }
-    const { composerCommands, forwarderCommands } = createDeltaCalls(sourceChainId, additionalCalls);
+    const nativeWithdrawOrBorrowCalls = preCalls.filter((c) => c.callType === DeltaCallType.LENDING &&
+        (c.lendingAction === LendingCall.DeltaCallLendingAction.WITHDRAW ||
+            c.lendingAction === LendingCall.DeltaCallLendingAction.BORROW) &&
+        CurrencyHandler.isNativeAddress(c.tokenAddress, sourceChainId));
+    if (nativeWithdrawOrBorrowCalls.length > 0) {
+        const bridgeTrade = trades.find((t) => t.aggregator === Bridge.AXELAR ||
+            t.aggregator === Bridge.STARGATE_TAXI ||
+            t.aggregator === Bridge.GASZIP);
+        let requiredBridgeFee = 0n;
+        if (bridgeTrade?.crossChainParams) {
+            if (bridgeTrade.aggregator === Bridge.AXELAR) {
+                requiredBridgeFee = safeBigInt(bridgeTrade.crossChainParams.totalFeeInNative);
+            }
+            else {
+                requiredBridgeFee = safeBigInt(bridgeTrade.crossChainParams.nativeFee);
+            }
+        }
+        if (requiredBridgeFee > 0n) {
+            value = requiredBridgeFee;
+        }
+        else {
+            value = 0n;
+        }
+    }
+    const preCommands = preComposerCommands.length > 0 ? preComposerCommands : transferInCommands;
     const calldata = encodeComposerCompose(packCommands([
-        ...transferInCommands,
-        ...composerCommands,
-        encodeExternalCall(forwarder, value, false, packCommands([
+        ...preCommands,
+        encodeExternalCall(forwarder, 0n, true, packCommands([
             ...commands,
-            ...forwarderCommands,
-            ...sweepCommands,
+            ...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,CA4E9E,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"}

package/dist/composedTrades/utils/fetchBridgeAndGasTrade.js

@@ -1,13 +1,13 @@
-import { CurrencyHandler, nativeOnChain, } from '@1delta/lib-utils';
+import { CurrencyHandler, nativeOnChain } from '@1delta/lib-utils';
 import { fetchBridgeTrade } from '../../bridge/fetchBridgeTrade';
 import { getExactOutputTrade } from './multichainUtils';
-export const fetchBridgeAndGasTrade = async (aggregator, input, getPrices, controller) => {
+export const fetchBridgeAndGasTrade = async (aggregator, input, controller) => {
     if (!input.fromCurrency || !input.toCurrency || !input.swapAmount)
         return undefined;
     const fromChainId = input.fromCurrency?.chainId;
     const gasTradeSlippage = 1;
     const fetchGasTrade = async (gasAmount) => {
-        const gasTrade = await getExactOutputTrade(input.fromCurrency, nativeOnChain(fromChainId), gasAmount, gasTradeSlippage, input.caller, input.caller, getPrices, controller);
+        const gasTrade = await getExactOutputTrade(input.fromCurrency, nativeOnChain(fromChainId), gasAmount, gasTradeSlippage, input.caller, input.caller, controller);
         return gasTrade;
     };
     const bridgeTrade = await fetchBridgeTrade(aggregator, input, controller);

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

@@ -1,10 +1,10 @@
-import { GenericTrade, InternalTrade, RawCurrency, useGeneralPricesCallbackType } from '@1delta/lib-utils';
+import { GenericTrade, InternalTrade, RawCurrency } from '@1delta/lib-utils';
 import { AggregatorInput } from '../../types';
 export interface BridgeTradeWithGas {
     bridgeTrade: GenericTrade;
     gasTrade: GenericTrade | undefined;
 }
 export declare function fetchBestTrade(input: AggregatorInput, controller?: AbortController): Promise<GenericTrade>;
-export declare function getExactOutputTrade(currencyIn: RawCurrency, currencyOut: RawCurrency, outputAmount: bigint, slippage: number, txOrigin: string, caller: string, getPrices: useGeneralPricesCallbackType, controller?: AbortController): Promise<InternalTrade | undefined>;
+export declare function getExactOutputTrade(currencyIn: RawCurrency, currencyOut: RawCurrency, outputAmount: bigint, slippage: number, txOrigin: string, caller: string, controller?: AbortController): Promise<InternalTrade | undefined>;
 export declare function increaseAmountBySlippage(amount: bigint, slippage: number): bigint;
 //# sourceMappingURL=multichainUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"multichainUtils.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/multichainUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,YAAY,EACZ,aAAa,EAEb,WAAW,EAEX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAK7C,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,YAAY,CAAA;IACzB,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAA;CACnC;AAWD,wBAAsB,cAAc,CAClC,KAAK,EAAE,eAAe,EACtB,UAAU,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,YAAY,CAAC,CAyEvB;AAED,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,WAAW,EACvB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,4BAA4B,EACvC,UAAU,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAyCpC;AAID,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAKR"}
+{"version":3,"file":"multichainUtils.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/multichainUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,YAAY,EACZ,aAAa,EACb,WAAW,EAEZ,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAK7C,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,YAAY,CAAA;IACzB,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAA;CACnC;AAWD,wBAAsB,cAAc,CAClC,KAAK,EAAE,eAAe,EACtB,UAAU,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,YAAY,CAAC,CAyEvB;AAED,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,WAAW,EACvB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAoBpC;AAID,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAKR"}

package/dist/composedTrades/utils/multichainUtils.js

@@ -1,5 +1,5 @@
 import { TradeAggregator } from '@1delta/aggregators';
-import { devLog, PricePriority, TradeType, } from '@1delta/lib-utils';
+import { devLog, TradeType, } from '@1delta/lib-utils';
 import { fetchAggregatorTrade, getAvailableAggregators } from '../../aggregator';
 import { reverseQuote } from '../../utils';
 // --- Fetching Logic ---
@@ -62,24 +62,10 @@ export async function fetchBestTrade(input, controller) {
     const orderedTrades = trades.sort((a, b) => b.outputAmountRealized - a.outputAmountRealized);
     return orderedTrades[0];
 }
-export async function getExactOutputTrade(currencyIn, currencyOut, outputAmount, slippage, txOrigin, caller, getPrices, controller) {
+export async function getExactOutputTrade(currencyIn, currencyOut, outputAmount, slippage, txOrigin, caller, controller) {
     if (outputAmount === 0n)
         return undefined;
-    const [priceIn, priceOut] = getPrices([
-        {
-            asset: currencyIn.address,
-            chainId: currencyIn.chainId,
-            priority: PricePriority.ORACLE,
-        },
-        {
-            asset: currencyOut.address,
-            chainId: currencyOut.chainId,
-            priority: PricePriority.ORACLE,
-        },
-    ]);
-    if (priceIn <= 0 || priceOut <= 0)
-        throw new Error('Invalid price');
-    const inputAmount = reverseQuote(currencyIn, currencyOut, outputAmount, priceIn, priceOut).amount;
+    const inputAmount = reverseQuote(currencyIn, currencyOut, outputAmount).amount;
     const quoteInput = {
         chainId: currencyIn.chainId,
         tradeType: TradeType.EXACT_INPUT,

package/dist/core.d.ts

@@ -1,4 +1,8 @@
-import { GenericTrade, RawCurrency, useGeneralPricesCallbackType } from '@1delta/lib-utils';
+import { DeltaCall, EvmGenericCallInfo, GenericTrade } from '@1delta/lib-utils';
 import { BridgeInput } from './types';
-export declare const fetchBridgeTrade: (input: BridgeInput, getPrices: useGeneralPricesCallbackType, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency, controller: AbortController) => Promise<GenericTrade | undefined>;
+export declare const fetchBridgeTrade: (input: BridgeInput, controller: AbortController) => Promise<GenericTrade | undefined>;
+export declare const assembleDeltaCalls: (chainId: string, calls: DeltaCall[], value: bigint, sweepTokensProps?: {
+    tokensToSweep: string[];
+    receiver: string;
+}) => EvmGenericCallInfo;
 //# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AACA,OAAO,EACL,YAAY,EACZ,WAAW,EACX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAS1B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAErC,eAAO,MAAM,gBAAgB,GAC3B,OAAO,WAAW,EAClB,WAAW,4BAA4B,EACvC,aAAa,CACX,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,KAC7B,WAAW,EAChB,YAAY,eAAe,KAC1B,OAAO,CAAC,YAAY,GAAG,SAAS,CAiBlC,CAAA"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,YAAY,EAEb,MAAM,mBAAmB,CAAA;AAU1B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAGrC,eAAO,MAAM,gBAAgB,GAC3B,OAAO,WAAW,EAClB,YAAY,eAAe,KAC1B,OAAO,CAAC,YAAY,GAAG,SAAS,CA0BlC,CAAA;AAmBD,eAAO,MAAM,kBAAkB,GAC7B,SAAS,MAAM,EACf,OAAO,SAAS,EAAE,EAClB,OAAO,MAAM,EACb,mBAAmB;IACjB,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;CACjB,KACA,kBAOF,CAAA"}