@1delta/trade-sdk 0.1.2 → 0.1.3

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

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

package/dist/bridge/fetchBridgeTrade.js

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"acrossWithSwap.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossWithSwap.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,YAAY,EAKZ,WAAW,EAEZ,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAmB,eAAe,EAAE,MAAM,aAAa,CAAA;AAO9D,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,gBAAgB,EAAE,WAAW,GAAG,SAAS,CAAA;CAC1C;AAED,eAAO,MAAM,wBAAwB,GACnC,OAAO,mBAAmB,EAC1B,aAAa,eAAe,KAC3B,OAAO,CAAC;IAAE,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA6C/D,CAAA;AAED,eAAe,wBAAwB,CAAA"}
+{"version":3,"file":"acrossWithSwap.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossWithSwap.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,YAAY,EAKZ,WAAW,EAEZ,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAmB,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAOhE,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,gBAAgB,EAAE,WAAW,GAAG,SAAS,CAAA;CAC1C;AAED,eAAO,MAAM,wBAAwB,GACnC,OAAO,mBAAmB,EAC1B,aAAa,eAAe,KAC3B,OAAO,CAAC;IAAE,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAgD/D,CAAA;AAED,eAAe,wBAAwB,CAAA"}

package/dist/composedTrades/across/acrossWithSwap.js

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

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

@@ -1,5 +1,5 @@
 import { GenericTrade, RawCurrency } from '@1delta/lib-utils';
-import { BaseBridgeInput } from '../../types';
-export declare const fetchAcrossTradeWithSwaps: (input: BaseBridgeInput, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency | undefined, controller?: AbortController) => Promise<GenericTrade | undefined>;
+import { BaseComposedInput } from '../../types';
+export declare const fetchAcrossTradeWithSwaps: (input: BaseComposedInput, getCurrency: (chainId: string | undefined, tokenAddress: string | undefined) => RawCurrency | undefined, controller?: AbortController) => Promise<GenericTrade | undefined>;
 export default fetchAcrossTradeWithSwaps;
 //# sourceMappingURL=acrossWithSwaps.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"acrossWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossWithSwaps.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,YAAY,EAOZ,WAAW,EAGZ,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAmB,eAAe,EAAE,MAAM,aAAa,CAAA;AAsB9D,eAAO,MAAM,yBAAyB,GACpC,OAAO,eAAe,EACtB,aAAa,CACX,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,KAC7B,WAAW,GAAG,SAAS,EAC5B,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAoKlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}
+{"version":3,"file":"acrossWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossWithSwaps.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,YAAY,EAOZ,WAAW,EAGZ,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAmB,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAsBhE,eAAO,MAAM,yBAAyB,GACpC,OAAO,iBAAiB,EACxB,aAAa,CACX,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,KAC7B,WAAW,GAAG,SAAS,EAC5B,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAqKlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/composedTrades/across/acrossWithSwaps.js

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

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

@@ -1,5 +1,7 @@
-import { EvmGenericCallInfo } from '@1delta/lib-utils';
 import { Hex } from 'viem';
+import { DeltaCall } from '../../../types/deltaCall';
+import { DestinationSwapData } from '../../../types/destinationSwapData';
+import { AcrossCall } from './types';
 /**
  * Creates the ABI-encoded `message` for a complete "Approve -> Execute -> Drain" sequence
  * using the Across MulticallHandler.
@@ -18,6 +20,7 @@ import { Hex } from 'viem';
  * @param fallbackAndDrainAddress - The single address that serves as both the safety net (fallback) and the destination for the drained tokens. This should be your wallet.
  * @returns The final, ABI-encoded `message` as a hex string (`Hex`).
  */
-export declare function createAcrossSwapMessage(multicallHandlerAddress: string, tokenToApprove: string, amountToApprove: bigint, spender: string, calls: EvmGenericCallInfo[], fallbackAndDrainAddress: string, tokensToDrain: string[]): Hex;
+export declare function createAcrossSwapMessage(multicallHandlerAddress: string, chainId: string, inputToken: string | undefined, outputToken: string, refundAndDrainAddress: string, additionalCalls: DeltaCall[], destinationSwapData?: DestinationSwapData): Hex;
+export declare function createAcrossSwapCalls(destinationSwapData: DestinationSwapData): AcrossCall[];
 export declare function createAcrossDrainMessage(multicallHandlerAddress: string, fallbackAndDrainAddress: string, tokensToDrain: string[]): Hex;
 //# sourceMappingURL=createAcrossMessage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createAcrossMessage.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/across/calldata/createAcrossMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EAA+B,GAAG,EAAY,MAAM,MAAM,CAAA;AAKjE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,uBAAuB,EAAE,MAAM,EAC/B,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,kBAAkB,EAAE,EAC3B,uBAAuB,EAAE,MAAM,EAC/B,aAAa,EAAE,MAAM,EAAE,GACtB,GAAG,CAsCL;AAED,wBAAgB,wBAAwB,CACtC,uBAAuB,EAAE,MAAM,EAC/B,uBAAuB,EAAE,MAAM,EAC/B,aAAa,EAAE,MAAM,EAAE,GACtB,GAAG,CAWL"}
+{"version":3,"file":"createAcrossMessage.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/across/calldata/createAcrossMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,GAAG,EAAY,MAAM,MAAM,CAAA;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 { BaseAxelarComposedInput } from '../../types';
-export interface AxelarWithSwapInput extends BaseAxelarComposedInput {
+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,EAEL,uBAAuB,EAExB,MAAM,aAAa,CAAA;AAKpB,MAAM,WAAW,mBAAoB,SAAQ,uBAAuB;IAClE,gBAAgB,EAAE,WAAW,GAAG,SAAS,CAAA;CAC1C;AAED,eAAO,MAAM,wBAAwB,GACnC,OAAO,mBAAmB,EAC1B,WAAW,4BAA4B,EACvC,aAAa,eAAe,KAC3B,OAAO,CAAC;IACT,KAAK,EAAE,YAAY,GAAG,SAAS,CAAA;IAC/B,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CA8CA,CAAA;AAED,eAAe,wBAAwB,CAAA"}
+{"version":3,"file":"axelarWithSwap.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarWithSwap.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,YAAY,EAGZ,WAAW,EAEX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAI1B,OAAO,EAGL,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

@@ -68,10 +68,7 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
             const tx = await destinationSwapTrade.assemble();
             if (!tx?.EVM)
                 return undefined;
-            const message = createSquidDestinationPayload(input.receiver, [
-                destinationSwapTrade.inputAmount.currency.address,
-                destinationSwapTrade.outputAmount.currency.address,
-            ], additionalCalls, {
+            const message = createSquidDestinationPayload(toChainId, destinationSwapTrade.inputAmount.currency.address, destinationSwapTrade.outputAmount.currency.address, input.receiver, additionalCalls, {
                 tokenToApprove: destinationSwapTrade.inputAmount.currency.address,
                 amountToApprove: destinationSwapTrade.inputAmount.amount,
                 spender: destinationSwapTrade.target,
@@ -81,7 +78,7 @@ const fetchAxelarTradeWithDestinationCalls = async (input, getPrices, controller
         }
         else if (additionalCalls.length > 0) {
             // Handle only destination calls case
-            const message = createSquidDestinationPayload(input.receiver, [input.bridgeToCurrency.address], additionalCalls);
+            const message = createSquidDestinationPayload(toChainId, undefined, input.bridgeToCurrency.address, input.receiver, additionalCalls);
             return { message, destinationSwapTrade: undefined };
         }
         return undefined;

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

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

@@ -1 +1 @@
-{"version":3,"file":"axelarWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarWithSwaps.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,YAAY,EAMZ,WAAW,EAGX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAmB,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAmBtE,eAAO,MAAM,yBAAyB,GACpC,OAAO,uBAAuB,EAC9B,aAAa,CACX,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,KAC7B,WAAW,GAAG,SAAS,EAC5B,WAAW,4BAA4B,EACvC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CA8JlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}
+{"version":3,"file":"axelarWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarWithSwaps.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,YAAY,EAMZ,WAAW,EAGX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAmB,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

@@ -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,30 +1,28 @@
-import { EvmGenericCallInfo } from '@1delta/lib-utils';
 import { Hex } from 'viem';
-import { SimpleSquidCall } from './types';
+import { DeltaCall } from '../../../types/deltaCall';
+import { DestinationSwapData } from '../../../types/destinationSwapData';
 /**
- * Creates the final `payload` for a complete "Approve -> Execute -> Drain" sequence
- * using the Squid multicaller.
+ * Creates the final `payload` for a complete cross-chain swap using Squid.
  *
- * This is a high-level helper that orchestrates the entire flow:
- * 1. **TransferFrom** pull funds from caller to SquidMulticaller.
- * 1. **Approves** an ERC20 token for a spender.
- * 2. **Executes** a series of one or more "middle" calls (e.g., a swap).
- * 3. **Drains** the resulting tokens from the multicall contract back to a specified address.
+ * This function supports two main flows:
  *
- * @param tokenToApprove - The address of the ERC20 token to approve (the input token).
- * @param amountToApprove - The amount of the token to approve.
- * @param spender - The address that will spend the approved token (e.g., a DEX router).
- * @param calls - An array of generic call objects to execute after approval.
- * @param refundAndDrainAddress - The single address that serves as both the refund recipient (safety net) and the destination for the drained tokens.
- * @param tokensToDrain - An array of ERC20 token addresses expected as output from the middle calls.
- * @returns The final, ABI-encoded `payload` as a hex string (`Hex`).
+ * 1. **Normal Flow** (when no additional calls are provided):
+ *    - Executes swap calls if destination swap data is provided
+ *    - Drains all relevant tokens (input and output) to the refundAndDrainAddress
+ *
+ * 2. **Composer Flow** (when additional calls are provided):
+ *    - Executes swap calls if destination swap data is provided
+ *    - Drains input token (if any) to refundAndDrainAddress
+ *    - Drains output token to the Delta Forwarder contract
+ *    - Creates and appends a Delta Composer call to execute additional operations
+ *
+ * @param chainId - The ID of the destination chain
+ * @param inputToken - The address of the input token (optional)
+ * @param outputToken - The address of the output token
+ * @param refundAndDrainAddress - The address that receives refunds and drained tokens
+ * @param additionalCalls - Optional array of DeltaCall objects for the composer flow
+ * @param destinationSwapData - Optional swap data for destination chain swaps
+ * @returns The final, ABI-encoded `payload` as a hex string (`Hex`)
  */
-export declare function createSquidDestinationPayload(refundAndDrainAddress: string, tokensToDrain: string[], additionalCalls: SimpleSquidCall[], destinationSwapData?: DestinationSwapData): Hex;
-interface DestinationSwapData {
-    tokenToApprove: string;
-    amountToApprove: bigint;
-    spender: string;
-    calls: EvmGenericCallInfo[];
-}
-export {};
+export declare function createSquidDestinationPayload(chainId: string, inputToken: string | undefined, outputToken: string, refundAndDrainAddress: string, additionalCalls: DeltaCall[], destinationSwapData?: DestinationSwapData): Hex;
 //# sourceMappingURL=createSquidPayload.d.ts.map

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

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

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

@@ -1,5 +1,8 @@
 import { createSquidPayload } from '@1delta/bridge-configs';
+import { CurrencyHandler } from '@1delta/lib-utils';
 import { encodeFunctionData, parseAbi, zeroAddress } from 'viem';
+import { createDeltaComposerCalldata } from '../../utils/deltaComposeCall/createDeltaComposerCalldata';
+import { requireDeltaContracts } from '../../utils/requireDeltaContracts';
 import { toSquidCall } from './simpleSquidCall';
 import { SimpleSquidCallType } from './types';
 /**
@@ -44,35 +47,66 @@ function createSquidDrainCalls(receiverAddress, tokensToDrain) {
     return drainCalls;
 }
 /**
- * Creates the final `payload` for a complete "Approve -> Execute -> Drain" sequence
- * using the Squid multicaller.
+ * Creates the final `payload` for a complete cross-chain swap using Squid.
  *
- * This is a high-level helper that orchestrates the entire flow:
- * 1. **TransferFrom** pull funds from caller to SquidMulticaller.
- * 1. **Approves** an ERC20 token for a spender.
- * 2. **Executes** a series of one or more "middle" calls (e.g., a swap).
- * 3. **Drains** the resulting tokens from the multicall contract back to a specified address.
+ * This function supports two main flows:
  *
- * @param tokenToApprove - The address of the ERC20 token to approve (the input token).
- * @param amountToApprove - The amount of the token to approve.
- * @param spender - The address that will spend the approved token (e.g., a DEX router).
- * @param calls - An array of generic call objects to execute after approval.
- * @param refundAndDrainAddress - The single address that serves as both the refund recipient (safety net) and the destination for the drained tokens.
- * @param tokensToDrain - An array of ERC20 token addresses expected as output from the middle calls.
- * @returns The final, ABI-encoded `payload` as a hex string (`Hex`).
+ * 1. **Normal Flow** (when no additional calls are provided):
+ *    - Executes swap calls if destination swap data is provided
+ *    - Drains all relevant tokens (input and output) to the refundAndDrainAddress
+ *
+ * 2. **Composer Flow** (when additional calls are provided):
+ *    - Executes swap calls if destination swap data is provided
+ *    - Drains input token (if any) to refundAndDrainAddress
+ *    - Drains output token to the Delta Forwarder contract
+ *    - Creates and appends a Delta Composer call to execute additional operations
+ *
+ * @param chainId - The ID of the destination chain
+ * @param inputToken - The address of the input token (optional)
+ * @param outputToken - The address of the output token
+ * @param refundAndDrainAddress - The address that receives refunds and drained tokens
+ * @param additionalCalls - Optional array of DeltaCall objects for the composer flow
+ * @param destinationSwapData - Optional swap data for destination chain swaps
+ * @returns The final, ABI-encoded `payload` as a hex string (`Hex`)
  */
-export function createSquidDestinationPayload(refundAndDrainAddress, tokensToDrain, additionalCalls, destinationSwapData) {
+export function createSquidDestinationPayload(chainId, inputToken, outputToken, refundAndDrainAddress, additionalCalls, destinationSwapData) {
     const swapCalls = destinationSwapData
         ? createSquidSwapCalls(destinationSwapData)
         : [];
-    const drainCalls = createSquidDrainCalls(refundAndDrainAddress, tokensToDrain);
-    const allCalls = [...swapCalls, ...additionalCalls, ...drainCalls];
-    const allSquidCalls = allCalls.map((call) => toSquidCall(call));
-    return createSquidPayload(refundAndDrainAddress, allSquidCalls);
+    if (additionalCalls.length === 0) {
+        // normal case: do calls and sweep to user
+        const tokensToDrain = inputToken ? [inputToken, outputToken] : [outputToken];
+        const drainCalls = createSquidDrainCalls(refundAndDrainAddress, tokensToDrain);
+        const allCalls = [...swapCalls, ...drainCalls];
+        const allSquidCalls = allCalls.map((call) => toSquidCall(call));
+        return createSquidPayload(refundAndDrainAddress, allSquidCalls);
+    }
+    else {
+        // composer case: do calls and continue in composer
+        const { forwarder } = requireDeltaContracts(chainId);
+        const tokensToDrain = inputToken ? [inputToken] : [];
+        const drainToUserCall = createSquidDrainCalls(refundAndDrainAddress, tokensToDrain);
+        const drainToForwarder = CurrencyHandler.isNativeAddress(outputToken, chainId)
+            ? []
+            : createSquidDrainCalls(forwarder, [outputToken]);
+        const deltaComposerCall = createDeltaComposerCalldata(chainId, [outputToken], refundAndDrainAddress, additionalCalls);
+        const callToComposer = {
+            callType: SimpleSquidCallType.FULL_NATIVE_BALANCE,
+            target: deltaComposerCall.to,
+            callData: deltaComposerCall.calldata,
+        };
+        const allCalls = [
+            ...swapCalls,
+            ...drainToUserCall,
+            ...drainToForwarder,
+            callToComposer,
+        ];
+        const allSquidCalls = allCalls.map((call) => toSquidCall(call));
+        return createSquidPayload(refundAndDrainAddress, allSquidCalls);
+    }
 }
 function createSquidSwapCalls(destinationSwapData) {
     const { tokenToApprove, amountToApprove, spender, calls } = destinationSwapData;
-    console.log('Axelar destinationSwapData', destinationSwapData);
     if (calls.some((call) => !call.to || !call.calldata)) {
         throw new Error('Invalid call data');
     }

package/dist/composedTrades/gaszip/gaszipWithSwaps.js

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

package/dist/composedTrades/utils/deltaComposeCall/createDeltaComposerCalldata.d.ts

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

package/dist/composedTrades/utils/deltaComposeCall/createDeltaComposerCalldata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDeltaComposerCalldata.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/utils/deltaComposeCall/createDeltaComposerCalldata.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAIpD,eAAO,MAAM,2BAA2B,GACtC,SAAS,MAAM,EACf,eAAe,MAAM,EAAE,EACvB,UAAU,MAAM,EAChB,OAAO,SAAS,EAAE,KACjB;IACD,QAAQ,EAAE,GAAG,CAAA;IACb,EAAE,EAAE,OAAO,CAAA;CA6BZ,CAAA"}

package/dist/composedTrades/utils/deltaComposeCall/createDeltaComposerCalldata.js

@@ -0,0 +1,17 @@
+import { encodeExternalCall, encodeSweep, SweepType } from '@1delta/calldatalib';
+import { encodeComposerCompose, packCommands } from '@1delta/lib-utils';
+import { requireDeltaContracts } from '../requireDeltaContracts';
+import { toComposerCall } from './toComposerCall';
+export const createDeltaComposerCalldata = (chainId, tokensToSweep, receiver, calls) => {
+    const { forwarder, composer } = requireDeltaContracts(chainId);
+    const commands = calls.map((call) => toComposerCall(call));
+    // sweep tokens at the end
+    for (const tokenAddress of tokensToSweep) {
+        const sweepCall = encodeSweep(tokenAddress, receiver, 0n, SweepType.VALIDATE);
+        commands.push(sweepCall);
+    }
+    const calldata = encodeComposerCompose(packCommands([
+        encodeExternalCall(forwarder, 0n, true, packCommands(commands)),
+    ]));
+    return { calldata, to: composer };
+};

package/dist/composedTrades/utils/deltaComposeCall/toComposerCall.d.ts

@@ -0,0 +1,4 @@
+import { Hex } from 'viem';
+import { DeltaCall } from '../../../types/deltaCall';
+export declare function toComposerCall(call: DeltaCall): Hex;
+//# sourceMappingURL=toComposerCall.d.ts.map

package/dist/composedTrades/utils/deltaComposeCall/toComposerCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toComposerCall.d.ts","sourceRoot":"","sources":["../../../../src/composedTrades/utils/deltaComposeCall/toComposerCall.ts"],"names":[],"mappings":"AAMA,OAAO,EAAW,GAAG,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,EAAE,SAAS,EAAiB,MAAM,0BAA0B,CAAA;AAEnE,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,GAAG,CAiCnD"}

package/dist/composedTrades/utils/deltaComposeCall/toComposerCall.js

@@ -0,0 +1,19 @@
+import { encodeExternalCall, encodeExternalCallWithReplace, encodeSweep, SweepType, } from '@1delta/calldatalib';
+import { DeltaCallType } from '../../../types/deltaCall';
+export function toComposerCall(call) {
+    switch (call.callType) {
+        case DeltaCallType.FULL_TOKEN_BALANCE: {
+            const replaceOffset = 32 * call.balanceOfInjectIndex;
+            return encodeExternalCallWithReplace(call.target, call.value ?? 0n, false, call.tokenAddress, replaceOffset, call.callData);
+        }
+        case DeltaCallType.FULL_NATIVE_BALANCE: {
+            return encodeExternalCall(call.target, 0n, true, call.callData);
+        }
+        case DeltaCallType.SWEEP_WITH_VALIDATION: {
+            return encodeSweep(call.tokenAddress, call.receiver, call.limit, SweepType.VALIDATE);
+        }
+        default: {
+            return encodeExternalCall(call.target, call.value ?? 0n, false, call.callData);
+        }
+    }
+}

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

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

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

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

package/dist/composedTrades/utils/requireDeltaContracts.js

@@ -0,0 +1,10 @@
+import { getDeltaComposerProxyAddress, getForwarderAddress, } from '@1delta/lib-utils';
+export const requireDeltaContracts = (fromChainId) => {
+    const forwarder = getForwarderAddress(fromChainId);
+    if (!forwarder)
+        throw new Error('Forwarder contract not found');
+    const composer = getDeltaComposerProxyAddress(fromChainId);
+    if (!composer)
+        throw new Error('Composer proxy contract not found');
+    return { forwarder, composer };
+};

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 export { fetchAggregatorTrade, getAvailableAggregators } from './aggregator';
 export { fetchBridgeTrade as fetchBridgeTradeWithoutComposed } from './bridge';
-export type { SimpleSquidCall, SimpleSquidCallType, } from './composedTrades/axelar/squid/types';
 export * from './core';
 export * from './initialize';
-export type { BridgeInput } from './types';
+export type { BridgeInput, DeltaCall, DeltaCallType } from './types';
 export { TradeAggregator } from '@1delta/aggregators';
-export { Bridge } from '@1delta/bridge-configs';
-export { getStatus as getBridgeStatus } from '@1delta/bridge-core';
-export type { useGeneralPricesCallbackType } from '@1delta/lib-utils';
+export { Bridge, getBridges, getCowSwapSlippage, getSwapAggregators, } from '@1delta/bridge-configs';
+export type { Params as BridgeParams, Status as BridgeStatus, } from '@1delta/bridge-core';
+export { getBridgeIcon, getStatus as getBridgeStatus, } from '@1delta/bridge-core';
+export type { AggregatorApiInput, useGeneralPricesCallbackType, } from '@1delta/lib-utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAC5E,OAAO,EAAE,gBAAgB,IAAI,+BAA+B,EAAE,MAAM,UAAU,CAAA;AAC9E,YAAY,EACV,eAAe,EACf,mBAAmB,GACpB,MAAM,qCAAqC,CAAA;AAC5C,cAAc,QAAQ,CAAA;AACtB,cAAc,cAAc,CAAA;AAC5B,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAE,SAAS,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAClE,YAAY,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAC5E,OAAO,EAAE,gBAAgB,IAAI,+BAA+B,EAAE,MAAM,UAAU,CAAA;AAC9E,cAAc,QAAQ,CAAA;AACtB,cAAc,cAAc,CAAA;AAC5B,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EACL,MAAM,EACN,UAAU,EACV,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EACV,MAAM,IAAI,YAAY,EACtB,MAAM,IAAI,YAAY,GACvB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,aAAa,EACb,SAAS,IAAI,eAAe,GAC7B,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EACV,kBAAkB,EAClB,4BAA4B,GAC7B,MAAM,mBAAmB,CAAA"}

package/dist/index.js

@@ -3,5 +3,5 @@ export { fetchBridgeTrade as fetchBridgeTradeWithoutComposed } from './bridge';
 export * from './core';
 export * from './initialize';
 export { TradeAggregator } from '@1delta/aggregators';
-export { Bridge } from '@1delta/bridge-configs';
-export { getStatus as getBridgeStatus } from '@1delta/bridge-core';
+export { Bridge, getBridges, getCowSwapSlippage, getSwapAggregators, } from '@1delta/bridge-configs';
+export { getBridgeIcon, getStatus as getBridgeStatus, } from '@1delta/bridge-core';

package/dist/initialize.d.ts

@@ -5,7 +5,30 @@ type SdkConfig = {
     loadSquidData: boolean;
     load1deltaConfigs: boolean;
 };
+/**
+ * Initializes the 1Delta SDK with the provided configuration.
+ * This function sets up the production environment flag, loads bridge configurations,
+ * initializes chain data, and caches Squid chains based on the provided configuration.
+ *
+ * @async
+ * @param {SdkConfig} config - The configuration object for initializing the SDK
+ * @param {boolean} config.isProductionEnv - Whether the environment is production
+ * @param {boolean} config.loadChainData - Whether to initialize chain data.
+ *        When using outside of the 1delta UI, set this to true to load required chain data.
+ * @param {boolean} config.loadSquidData - Whether to fetch and cache Squid chains data.
+ *        When using outside of the 1delta UI, set this to true to load Squid data.
+ * @param {boolean} config.load1deltaConfigs - Whether to load and register 1Delta bridge configurations.
+ *        When using outside of the 1delta UI, set this to true to load bridge configs.
+ * @returns {Promise<void>} A promise that resolves when initialization is complete
+ *
+ * @note When using this SDK outside of the 1delta UI, you should set all parameters to `true`
+ *       as the data loading is handled by the 1delta UI itself in that context.
+ */
 export declare const initialize: (config: SdkConfig) => Promise<void>;
+/**
+ * Sets the wallet client for the SDK and configures bridge settings.
+ * This is required for CowSwap functionality to work properly.
+ */
 export declare const setWalletClient: (walletClient: WalletClient) => void;
 export {};
 //# sourceMappingURL=initialize.d.ts.map

package/dist/initialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../src/initialize.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAInC,KAAK,SAAS,GAAG;IACf,eAAe,EAAE,OAAO,CAAA;IACxB,aAAa,EAAE,OAAO,CAAA;IACtB,aAAa,EAAE,OAAO,CAAA;IACtB,iBAAiB,EAAE,OAAO,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,UAAU,GAAU,QAAQ,SAAS,KAAG,OAAO,CAAC,IAAI,CAKhE,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,cAAc,YAAY,SAEzD,CAAA"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../src/initialize.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAInC,KAAK,SAAS,GAAG;IACf,eAAe,EAAE,OAAO,CAAA;IACxB,aAAa,EAAE,OAAO,CAAA;IACtB,aAAa,EAAE,OAAO,CAAA;IACtB,iBAAiB,EAAE,OAAO,CAAA;CAC3B,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,GAAU,QAAQ,SAAS,KAAG,OAAO,CAAC,IAAI,CAMhE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,cAAc,YAAY,SAEzD,CAAA"}

package/dist/initialize.js

@@ -1,7 +1,26 @@
 import { fetchAndCacheSquidChains, getAllBridgeConfigs, setWalletClient as setWalletClientBridgeConfigs, } from '@1delta/bridge-configs';
 import { registerConfig } from '@1delta/bridge-core';
-import { setIsProduction } from '@1delta/lib-utils';
+import { cleanupExpiredCache, setIsProduction } from '@1delta/lib-utils';
 import { inititalizeChainData } from './data/chainData';
+/**
+ * Initializes the 1Delta SDK with the provided configuration.
+ * This function sets up the production environment flag, loads bridge configurations,
+ * initializes chain data, and caches Squid chains based on the provided configuration.
+ *
+ * @async
+ * @param {SdkConfig} config - The configuration object for initializing the SDK
+ * @param {boolean} config.isProductionEnv - Whether the environment is production
+ * @param {boolean} config.loadChainData - Whether to initialize chain data.
+ *        When using outside of the 1delta UI, set this to true to load required chain data.
+ * @param {boolean} config.loadSquidData - Whether to fetch and cache Squid chains data.
+ *        When using outside of the 1delta UI, set this to true to load Squid data.
+ * @param {boolean} config.load1deltaConfigs - Whether to load and register 1Delta bridge configurations.
+ *        When using outside of the 1delta UI, set this to true to load bridge configs.
+ * @returns {Promise<void>} A promise that resolves when initialization is complete
+ *
+ * @note When using this SDK outside of the 1delta UI, you should set all parameters to `true`
+ *       as the data loading is handled by the 1delta UI itself in that context.
+ */
 export const initialize = async (config) => {
     setIsProduction(config.isProductionEnv);
     if (config.load1deltaConfigs)
@@ -10,7 +29,12 @@ export const initialize = async (config) => {
         await inititalizeChainData();
     if (config.loadSquidData)
         await fetchAndCacheSquidChains();
+    cleanupExpiredCache();
 };
+/**
+ * Sets the wallet client for the SDK and configures bridge settings.
+ * This is required for CowSwap functionality to work properly.
+ */
 export const setWalletClient = (walletClient) => {
     setWalletClientBridgeConfigs(walletClient);
 };

package/dist/types/aggregatorInput.d.ts

@@ -0,0 +1,3 @@
+import { AggregatorApiInput, OneDeltaInput } from '@1delta/lib-utils';
+export type AggregatorInput = AggregatorApiInput | OneDeltaInput;
+//# sourceMappingURL=aggregatorInput.d.ts.map

package/dist/types/aggregatorInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregatorInput.d.ts","sourceRoot":"","sources":["../../src/types/aggregatorInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAErE,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAAG,aAAa,CAAA"}

package/dist/types/bridgeInput.d.ts

@@ -1,6 +1,6 @@
 import { Bridge } from '@1delta/bridge-configs';
 import { RawCurrency, TradeType } from '@1delta/lib-utils';
-import { SimpleSquidCall } from '../composedTrades/axelar/squid/types';
+import { DeltaCall } from './deltaCall';
 export interface BaseBridgeInput {
     slippage: number;
     tradeType: TradeType;
@@ -14,17 +14,17 @@ export interface BaseBridgeInput {
     usePermit?: boolean;
     destinationGasLimit?: bigint;
 }
-export interface BaseAxelarComposedInput extends BaseBridgeInput {
-    additionalCalls?: SimpleSquidCall[];
-}
-interface AxelarComposedInput {
-    bridge: Bridge.AXELAR;
-    input: BaseAxelarComposedInput;
+export interface BaseComposedInput extends BaseBridgeInput {
+    additionalCalls?: DeltaCall[];
 }
+type ComposedInput = {
+    bridge: Bridge.ACROSS | Bridge.AXELAR;
+    input: BaseComposedInput;
+};
 interface DefaultBridgeInput extends BaseBridgeInput {
-    bridge: Exclude<Bridge, Bridge.AXELAR>;
+    bridge: Exclude<Bridge, Bridge.AXELAR | Bridge.ACROSS>;
     input: BaseBridgeInput;
 }
-export type BridgeInput = AxelarComposedInput | DefaultBridgeInput;
+export type BridgeInput = ComposedInput | DefaultBridgeInput;
 export {};
 //# sourceMappingURL=bridgeInput.d.ts.map

package/dist/types/bridgeInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bridgeInput.d.ts","sourceRoot":"","sources":["../../src/types/bridgeInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAA;AAEtE,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;IACpB,YAAY,EAAE,WAAW,GAAG,SAAS,CAAA;IACrC,UAAU,EAAE,WAAW,GAAG,SAAS,CAAA;IACnC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,UAAU,GAAG,SAAS,CAAA;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,uBAAwB,SAAQ,eAAe;IAC9D,eAAe,CAAC,EAAE,eAAe,EAAE,CAAA;CACpC;AAED,UAAU,mBAAmB;IAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,CAAA;IACrB,KAAK,EAAE,uBAAuB,CAAA;CAC/B;AAED,UAAU,kBAAmB,SAAQ,eAAe;IAClD,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACtC,KAAK,EAAE,eAAe,CAAA;CACvB;AAED,MAAM,MAAM,WAAW,GAAG,mBAAmB,GAAG,kBAAkB,CAAA"}
+{"version":3,"file":"bridgeInput.d.ts","sourceRoot":"","sources":["../../src/types/bridgeInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAE1D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;IACpB,YAAY,EAAE,WAAW,GAAG,SAAS,CAAA;IACrC,UAAU,EAAE,WAAW,GAAG,SAAS,CAAA;IACnC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,UAAU,GAAG,SAAS,CAAA;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,eAAe,CAAC,EAAE,SAAS,EAAE,CAAA;CAC9B;AAED,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;IACrC,KAAK,EAAE,iBAAiB,CAAA;CACzB,CAAA;AAED,UAAU,kBAAmB,SAAQ,eAAe;IAClD,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;IACtD,KAAK,EAAE,eAAe,CAAA;CACvB;AAED,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,kBAAkB,CAAA"}

package/dist/types/deltaCall.d.ts

@@ -0,0 +1,32 @@
+import { Hex } from 'viem';
+export declare enum DeltaCallType {
+    DEFAULT = 0,
+    FULL_TOKEN_BALANCE = 1,
+    FULL_NATIVE_BALANCE = 2,
+    SWEEP_WITH_VALIDATION = 3
+}
+interface BaseCall {
+    target: string;
+    value?: bigint;
+    callData: Hex;
+}
+interface FullTokenBalanceCall extends BaseCall {
+    callType: DeltaCallType.FULL_TOKEN_BALANCE;
+    tokenAddress: string;
+    balanceOfInjectIndex: number;
+}
+interface FullNativeBalanceCall extends Omit<BaseCall, 'value'> {
+    callType: DeltaCallType.FULL_NATIVE_BALANCE;
+}
+interface SweepWithValidationCall {
+    callType: DeltaCallType.SWEEP_WITH_VALIDATION;
+    tokenAddress: string;
+    limit: bigint;
+    receiver: string;
+}
+interface DefaultCall extends BaseCall {
+    callType: DeltaCallType.DEFAULT;
+}
+export type DeltaCall = FullTokenBalanceCall | FullNativeBalanceCall | SweepWithValidationCall | DefaultCall;
+export {};
+//# sourceMappingURL=deltaCall.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deltaCall.d.ts","sourceRoot":"","sources":["../../src/types/deltaCall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAE1B,oBAAY,aAAa;IACvB,OAAO,IAAI;IACX,kBAAkB,IAAI;IACtB,mBAAmB,IAAI;IACvB,qBAAqB,IAAI;CAC1B;AAED,UAAU,QAAQ;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,GAAG,CAAA;CACd;AAED,UAAU,oBAAqB,SAAQ,QAAQ;IAC7C,QAAQ,EAAE,aAAa,CAAC,kBAAkB,CAAA;IAC1C,YAAY,EAAE,MAAM,CAAA;IACpB,oBAAoB,EAAE,MAAM,CAAA;CAC7B;AAED,UAAU,qBAAsB,SAAQ,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC7D,QAAQ,EAAE,aAAa,CAAC,mBAAmB,CAAA;CAC5C;AAED,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,aAAa,CAAC,qBAAqB,CAAA;IAC7C,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,WAAY,SAAQ,QAAQ;IACpC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAA;CAChC;AAED,MAAM,MAAM,SAAS,GACjB,oBAAoB,GACpB,qBAAqB,GACrB,uBAAuB,GACvB,WAAW,CAAA"}

package/dist/types/deltaCall.js

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

package/dist/types/destinationSwapData.d.ts

@@ -0,0 +1,8 @@
+import { EvmGenericCallInfo } from '@1delta/lib-utils';
+export interface DestinationSwapData {
+    tokenToApprove: string;
+    amountToApprove: bigint;
+    spender: string;
+    calls: EvmGenericCallInfo[];
+}
+//# sourceMappingURL=destinationSwapData.d.ts.map

package/dist/types/destinationSwapData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destinationSwapData.d.ts","sourceRoot":"","sources":["../../src/types/destinationSwapData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAEtD,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,kBAAkB,EAAE,CAAA;CAC5B"}

package/dist/types/destinationSwapData.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -1,3 +1,5 @@
-export * from './aggregator';
+export * from './aggregatorInput';
 export * from './bridgeInput';
+export * from './deltaCall';
+export * from './destinationSwapData';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,uBAAuB,CAAA"}

package/dist/types/index.js

@@ -1,2 +1,4 @@
-export * from './aggregator';
+export * from './aggregatorInput';
 export * from './bridgeInput';
+export * from './deltaCall';
+export * from './destinationSwapData';

package/dist/utils/utils.js

@@ -1,4 +1,4 @@
-import { convertRawAmount, convertTokenAmount } from '@1delta/aggregators';
+import { convertRawAmount, convertTokenAmount } from '@1delta/lib-utils';
 import { CurrencyHandler, skimToBigNumber, TradeType, } from '@1delta/lib-utils';
 import { formatUnits } from 'viem';
 export const emptyAggregatorInput = {

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@1delta/trade-sdk",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "1Delta Trade SDK for handling cross-chain swaps and bridges",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "1deltaDAO",
   "license": "UNLICENSED",
   "dependencies": {
-    "@1delta/calldatalib": "^0.0.42",
+    "@1delta/calldatalib": "^0.0.46",
     "viem": "^2.33.0",
     "@1delta/data-sdk": "^0.0.8",
-    "@1delta/bridge-configs": "0.1.2",
-    "@1delta/aggregators": "0.1.2",
+    "@1delta/aggregators": "0.1.3",
+    "@1delta/bridge-configs": "0.1.3",
     "@1delta/bridge-core": "0.1.1",
     "@1delta/lib-utils": "0.1.3"
   },

package/dist/types/aggregator.d.ts

@@ -1,11 +0,0 @@
-import { AggregatorApiInput, GenericTrade, OneDeltaInput, RawCurrency, RawCurrencyAmount } from '@1delta/lib-utils';
-export type AggregatorState = GenericTrade;
-export type AggregatorInput = AggregatorApiInput | OneDeltaInput;
-export type MultiSwapAggregatorApiInput = Omit<AggregatorApiInput, 'swapAmount' | 'fromCurrency' | 'chainId'> & {
-    swapAmounts: string[];
-    fromCurrencies: RawCurrency[];
-    parsedAmount: RawCurrencyAmount | undefined;
-    destinationGasToSwap: bigint;
-};
-export type AggregatorApiValueSetter = (params: AggregatorApiInput) => void;
-//# sourceMappingURL=aggregator.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"aggregator.d.ts","sourceRoot":"","sources":["../../src/types/aggregator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,WAAW,EACX,iBAAiB,EAClB,MAAM,mBAAmB,CAAA;AAE1B,MAAM,MAAM,eAAe,GAAG,YAAY,CAAA;AAE1C,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAAG,aAAa,CAAA;AAEhE,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAC5C,kBAAkB,EAClB,YAAY,GAAG,cAAc,GAAG,SAAS,CAC1C,GAAG;IACF,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,cAAc,EAAE,WAAW,EAAE,CAAA;IAC7B,YAAY,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAC3C,oBAAoB,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAA"}