@1delta/trade-sdk 0.1.0

package/dist/composedTrades/utils/createSwapAndBridgeCalldata.js

@@ -0,0 +1,146 @@
+import { Bridge } from '@1delta/bridge-configs';
+import { encodeAcrossBridgeNative, encodeAcrossBridgeToken, encodeApprove, encodeExternalCall, encodeGasZipEvmBridge, encodeSquidRouterCall, encodeStargateV2BridgeSimpleTaxi, encodeSweep, encodeTransferIn, encodeTryExternalCall, SweepType, } from '@1delta/calldatalib';
+import { buildMetaSwapParams, CurrencyHandler, encodeComposerCompose, getDeltaComposerProxyAddress, getForwarderAddress, minimumAmountInFromAmount, packCommands, TradeUtils, } from '@1delta/lib-utils';
+import { encodePacked, pad } from 'viem';
+export async function createSwapAndBridgeCalldata(trades, account, bridgeReceiver, sweep, fundsToPull = [], catchRevert = true, sweepDust = false) {
+    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 forwarder = getForwarderAddress(sourceChainId);
+    if (!forwarder)
+        throw new Error(`CallForwarder contract does not exist on chain ${sourceChainId}`);
+    const composerProxy = getDeltaComposerProxyAddress(sourceChainId);
+    if (!composerProxy)
+        throw new Error(`ComposerProxy contract does not exist on chain ${sourceChainId}`);
+    const commands = [];
+    const sweepTokens = TradeUtils.groupCurrency({
+        trades,
+        getCurrency: (t) => t.inputAmount.currency,
+    });
+    for (let i = 0; i < trades.length; i++) {
+        const currentTrade = trades[i];
+        const { aggregator, approvalTarget, target, inputAmount, outputAmount, crossChainParams, } = currentTrade;
+        const isFirstTrade = !!currentTrade.debitAmount;
+        if (!CurrencyHandler.isNative(inputAmount.currency) && approvalTarget) {
+            const approveCall = encodeApprove(inputAmount.currency.address, approvalTarget);
+            commands.push(approveCall);
+        }
+        if (aggregator === Bridge.ACROSS) {
+            if (!target)
+                throw new Error('Trade target not defined');
+            if (!crossChainParams)
+                throw new Error('Cross-chain params not defined');
+            const fixedFee = safeBigInt(crossChainParams.fixedFee);
+            const percFee = Number(safeBigInt(crossChainParams.percFee));
+            const message = !!crossChainParams.message
+                ? crossChainParams.message
+                : '0x';
+            const deadline = Math.floor(Date.now() / 1000) + 180; // now + 3 minutes
+            /**
+             * Safely get the explicit currencies from the Across query
+             * Trade input/output are not reliable as they can be composite trades
+             */
+            if (!crossChainParams.fromTokenDecimals)
+                throw new Error('From decimals not provided');
+            if (!crossChainParams.toTokenDecimals)
+                throw new Error('To decimals not provided');
+            const fromDecimals = Number(crossChainParams.fromTokenDecimals);
+            const toDecimals = Number(crossChainParams.toTokenDecimals);
+            if (CurrencyHandler.isNative(inputAmount.currency)) {
+                const bridgeCall = encodeAcrossBridgeNative(target, account, crossChainParams.fromTokenAddress, addressToBytes32Hex(crossChainParams.toTokenAddress), isFirstTrade ? inputAmount.amount : 0n, fixedFee, percFee, Number(crossChainParams.toChainId), fromDecimals, toDecimals, addressToBytes32Hex(bridgeReceiver), deadline, message);
+                commands.push(bridgeCall);
+            }
+            else {
+                const bridgeCall = encodeAcrossBridgeToken(target, account, crossChainParams.fromTokenAddress, addressToBytes32Hex(crossChainParams.toTokenAddress), isFirstTrade ? inputAmount.amount : 0n, fixedFee, percFee, Number(crossChainParams.toChainId), fromDecimals, toDecimals, addressToBytes32Hex(bridgeReceiver), deadline, message);
+                commands.push(bridgeCall);
+            }
+        }
+        else if (aggregator === Bridge.STARGATE_TAXI) {
+            if (!crossChainParams)
+                throw new Error('Cross-chain params not defined');
+            const dstEid = Number(crossChainParams.dstEid);
+            const nativeFee = safeBigInt(crossChainParams.nativeFee);
+            const slippage = Number(crossChainParams.slippage);
+            const bridgeCall = encodeStargateV2BridgeSimpleTaxi(inputAmount.currency.address, target, dstEid, addressToBytes32Hex(bridgeReceiver), account, 0n, CurrencyHandler.isNative(inputAmount.currency), slippage, nativeFee);
+            commands.push(bridgeCall);
+        }
+        else if (aggregator === Bridge.AXELAR) {
+            if (!crossChainParams)
+                throw new Error('Cross-chain params not defined');
+            const message = !!crossChainParams.message
+                ? crossChainParams.message
+                : '0x';
+            const bridgeCall = encodeSquidRouterCall(inputAmount.currency.address, crossChainParams.contractAddress, encodePackedString(crossChainParams.bridgeTokenSymbol), safeBigInt(0n), encodePackedString(crossChainParams.destinationChain), encodePackedString(crossChainParams.destinationAddress), message, account, crossChainParams.isExpressSupported, safeBigInt(crossChainParams.totalFeeInNative));
+            commands.push(bridgeCall);
+        }
+        else if (aggregator === Bridge.GASZIP) {
+            if (!crossChainParams)
+                throw new Error('Cross-chain params not defined');
+            const gasZipDestChainId = BigInt(crossChainParams.gasZipDestChainId);
+            const bridgeCall = encodeGasZipEvmBridge(crossChainParams.contractAddress, bridgeReceiver, safeBigInt(0n), gasZipDestChainId);
+            commands.push(bridgeCall);
+        }
+        else {
+            const { calldata, value, target, isSelfBalance } = await buildMetaSwapParams(currentTrade);
+            if (catchRevert) {
+                const sweepOnCatchCall = createCatchSweep(sweepTokens, account);
+                const swapCall = encodeTryExternalCall(target, value, isSelfBalance, false, calldata, sweepOnCatchCall);
+                commands.push(swapCall);
+            }
+            else {
+                const swapCall = encodeExternalCall(target, value, isSelfBalance, calldata);
+                commands.push(swapCall);
+            }
+            const sweepOutputToken = outputAmount.currency;
+            sweepTokens.push(sweepOutputToken);
+        }
+    }
+    if (sweep) {
+        const sameChainTrades = trades.filter((t) => t.inputAmount.currency.chainId === t.outputAmount.currency.chainId);
+        const currencyToAmount = TradeUtils.groupAmountByCurrency({
+            trades: sameChainTrades,
+            getCurrency: (t) => t.outputAmount.currency,
+            getAmount: (t) => minimumAmountInFromAmount(t.outputAmount, t.slippage),
+        });
+        for (const [currency, amount] of currencyToAmount.entries()) {
+            const sweepCall = encodeSweep(currency.address, account, sweepDust ? 0n : amount, SweepType.VALIDATE);
+            commands.push(sweepCall);
+        }
+    }
+    let value = 0n;
+    const transferInCommands = [];
+    for (const { address, amount } of fundsToPull) {
+        if (CurrencyHandler.isNativeAddress(address, sourceChainId))
+            value += amount;
+        else
+            transferInCommands.push(encodeTransferIn(address, forwarder, amount));
+    }
+    const calldata = encodeComposerCompose(packCommands([
+        ...transferInCommands,
+        encodeExternalCall(forwarder, value, false, packCommands(commands)),
+    ]));
+    return { calldata, value, to: composerProxy };
+}
+function createCatchSweep(sweepTokens, receiver) {
+    const sweepCalls = sweepTokens.map((token) => encodeSweep(token.address, receiver, 0n, SweepType.VALIDATE));
+    return packCommands(sweepCalls);
+}
+const safeBigInt = (value) => {
+    try {
+        return BigInt(value);
+    }
+    catch {
+        return 0n;
+    }
+};
+const isSameSourceChainId = (trades) => {
+    const chainId = trades[0].inputAmount.currency.chainId;
+    return trades.every((trade) => trade.inputAmount.currency.chainId === chainId);
+};
+function addressToBytes32Hex(address) {
+    const addre32Bytes = pad(address, { size: 32, dir: 'left' });
+    return addre32Bytes;
+}
+function encodePackedString(data) {
+    return encodePacked(['string'], [data]);
+}

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

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

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

@@ -0,0 +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,WAAW,EAAE,MAAM,aAAa,CAAA;AAGzC,eAAO,MAAM,sBAAsB,GACjC,YAAY,MAAM,EAClB,OAAO,WAAW,EAClB,WAAW,4BAA4B,EACvC,aAAa,eAAe,KAC3B,OAAO,CACR;IAAE,WAAW,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAAA;CAAE,GAAG,SAAS,CAwE9E,CAAA"}

package/dist/composedTrades/utils/fetchBridgeAndGasTrade.js

@@ -0,0 +1,41 @@
+import { CurrencyHandler, nativeOnChain, } from '@1delta/lib-utils';
+import { fetchBridgeTrade } from '../../bridge/fetchBridgeTrade';
+import { getExactOutputTrade } from './multichainUtils';
+export const fetchBridgeAndGasTrade = async (aggregator, input, getPrices, 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);
+        return gasTrade;
+    };
+    const bridgeTrade = await fetchBridgeTrade(aggregator, input, controller);
+    if (!bridgeTrade)
+        return undefined;
+    if (!bridgeTrade.gasAmount || bridgeTrade.gasAmount === 0n)
+        return { gasTrade: undefined, bridgeTrade };
+    const bridgeTokenIsNative = CurrencyHandler.isNative(input.fromCurrency);
+    if (bridgeTokenIsNative) {
+        const adjustedAmount = BigInt(input.swapAmount) - bridgeTrade.gasAmount;
+        const updatedStargateTrade = await fetchBridgeTrade(aggregator, {
+            ...input,
+            swapAmount: adjustedAmount.toString(),
+        }, controller);
+        if (updatedStargateTrade)
+            return { gasTrade: undefined, bridgeTrade: updatedStargateTrade };
+    }
+    const adjustedGasAmount = (bridgeTrade.gasAmount * 110n + BigInt(gasTradeSlippage)) / 100n; // increase by 10% + gas trade slippage
+    const gasTrade = await fetchGasTrade(adjustedGasAmount);
+    if (gasTrade) {
+        const adjustedAmount = BigInt(input.swapAmount) - gasTrade.inputAmount.amount;
+        const updatedStargateTrade = await fetchBridgeTrade(aggregator, {
+            ...input,
+            swapAmount: adjustedAmount.toString(),
+        }, controller);
+        const isEnoughGas = gasTrade.outputAmount.amount >= (updatedStargateTrade?.gasAmount ?? 0n);
+        if (isEnoughGas && updatedStargateTrade)
+            return { gasTrade, bridgeTrade: updatedStargateTrade };
+    }
+    return undefined;
+};

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

@@ -0,0 +1,3 @@
+export * from './fetchBridgeAndGasTrade';
+export * from './multichainUtils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA"}

package/dist/composedTrades/utils/index.js

@@ -0,0 +1,2 @@
+export * from './fetchBridgeAndGasTrade';
+export * from './multichainUtils';

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

@@ -0,0 +1,10 @@
+import { GenericTrade, InternalTrade, RawCurrency, useGeneralPricesCallbackType } 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 increaseAmountBySlippage(amount: bigint, slippage: number): bigint;
+//# sourceMappingURL=multichainUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"multichainUtils.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/utils/multichainUtils.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,YAAY,EACZ,aAAa,EAEb,WAAW,EAEX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAE1B,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,CA0EvB;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,CAwCpC;AAID,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAKR"}

package/dist/composedTrades/utils/multichainUtils.js

@@ -0,0 +1,105 @@
+import { fetchAggregatorTrade, getAvailableAggregators, TradeAggregator, } from '@1delta/aggregators';
+import { devLog, PricePriority, TradeType, } from '@1delta/lib-utils';
+import { reverseQuote } from '../../utils';
+// --- Fetching Logic ---
+const AGGREGATOR_TIMEOUT_MS = 500;
+const PRIORITY_AGGREGATORS = [
+    TradeAggregator.Odos,
+    TradeAggregator.Kyberswap,
+];
+export async function fetchBestTrade(input, controller) {
+    const allAggregators = getAvailableAggregators(input.chainId).filter((aggregator) => aggregator !== TradeAggregator.Bebop &&
+        aggregator !== TradeAggregator.OneDelta &&
+        aggregator !== TradeAggregator.Wowmax);
+    const trades = [];
+    let timeout;
+    const collectionPromise = new Promise((resolve) => {
+        let settledCount = 0;
+        let isDone = false;
+        const done = () => {
+            if (!isDone) {
+                isDone = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                resolve();
+            }
+        };
+        if (allAggregators.length === 0) {
+            return done();
+        }
+        allAggregators.forEach((aggregator) => {
+            fetchAggregatorTrade(aggregator, input, controller)
+                .then((trade) => {
+                if (trade) {
+                    if (trades.length === 0) {
+                        timeout = setTimeout(done, AGGREGATOR_TIMEOUT_MS);
+                    }
+                    trades.push(trade);
+                }
+            })
+                .catch((error) => {
+                devLog(`Error for aggregator ${aggregator}`, error);
+            })
+                .finally(() => {
+                settledCount++;
+                if (settledCount === allAggregators.length) {
+                    done();
+                }
+            });
+        });
+    });
+    await collectionPromise;
+    if (trades.length === 0) {
+        throw new Error(`Could not fetch a trade from any aggregator for input: ${JSON.stringify(input)}`);
+    }
+    for (const aggregator of PRIORITY_AGGREGATORS) {
+        const priorityTrade = trades.find((trade) => trade.aggregator === aggregator);
+        if (priorityTrade) {
+            devLog(`Returning prioritized trade from ${aggregator}`);
+            return priorityTrade;
+        }
+    }
+    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) {
+    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 quoteInput = {
+        chainId: currencyIn.chainId,
+        tradeType: TradeType.EXACT_INPUT,
+        fromCurrency: currencyIn,
+        toCurrency: currencyOut,
+        swapAmount: inputAmount.toString(),
+        slippage,
+        txOrigin,
+        caller,
+        receiver: caller,
+        simpleRoute: true,
+        flashSwap: undefined,
+    };
+    return await fetchBestTrade(quoteInput, controller);
+}
+// --- Type Guards & Data Structuring ---
+export function increaseAmountBySlippage(amount, slippage) {
+    if (slippage > 100 || slippage < 0)
+        return 0n;
+    const slippageBps = BigInt(Math.round(slippage * 100));
+    const adjustedAmount = (amount * 10000n) / (10000n - slippageBps);
+    return adjustedAmount;
+}

package/dist/core.d.ts

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

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAC/C,OAAO,EACL,YAAY,EACZ,WAAW,EACX,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAS1B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAErC,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,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,CAWlC,CAAA"}

package/dist/core.js

@@ -0,0 +1,13 @@
+import { Bridge } from '@1delta/bridge-configs';
+import { isProductionEnv } from '@1delta/lib-utils';
+import { fetchBridgeTrade as fetchBridgeTradeInternal } from './bridge';
+import { fetchAcrossTradeWithSwaps, fetchAxelarTradeWithSwaps, fetchGaszipTradeWithSwaps, } from './composedTrades';
+export const fetchBridgeTrade = async (bridge, input, getPrices, getCurrency, controller) => {
+    if (bridge === Bridge.ACROSS)
+        return fetchAcrossTradeWithSwaps(input, getCurrency, controller);
+    if (bridge === Bridge.AXELAR)
+        return fetchAxelarTradeWithSwaps(input, getCurrency, getPrices, controller);
+    if (bridge === Bridge.GASZIP && !isProductionEnv())
+        return fetchGaszipTradeWithSwaps(input, controller);
+    return fetchBridgeTradeInternal(bridge, input, controller);
+};

package/dist/data/chainData.d.ts

@@ -0,0 +1,2 @@
+export declare function inititalizeChainData(): Promise<void>;
+//# sourceMappingURL=chainData.d.ts.map

package/dist/data/chainData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chainData.d.ts","sourceRoot":"","sources":["../../src/data/chainData.ts"],"names":[],"mappings":"AA2BA,wBAAsB,oBAAoB,kBAIzC"}

package/dist/data/chainData.js

@@ -0,0 +1,20 @@
+import { initializeChainData } from '@1delta/data-sdk';
+import { markChainsReady } from './readinessStore';
+const baseUrlChains = 'https://raw.githubusercontent.com/1delta-DAO/chains/main';
+const chains = baseUrlChains + '/data.json';
+function inititalize(params) {
+    const { chainsOverride } = params;
+    initializeChainData({ chainsOverride });
+    markChainsReady();
+}
+async function fetchChainDataFromDir() {
+    const promises = [chains].map(async (a) => fetch(a).then(async (b) => await b.json()));
+    const [chainsOverride] = await Promise.all(promises);
+    return {
+        chainsOverride,
+    };
+}
+export async function inititalizeChainData() {
+    const params = await fetchChainDataFromDir();
+    inititalize(params);
+}

package/dist/data/readinessStore.d.ts

@@ -0,0 +1,5 @@
+export declare function getReadySnapshot(): boolean;
+export declare function subscribeReady(listener: () => void): () => void;
+export declare function markChainsReady(): void;
+export declare function resetReady(): void;
+//# sourceMappingURL=readinessStore.d.ts.map

package/dist/data/readinessStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readinessStore.d.ts","sourceRoot":"","sources":["../../src/data/readinessStore.ts"],"names":[],"mappings":"AAUA,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAG/D;AAED,wBAAgB,eAAe,SAM9B;AAGD,wBAAgB,UAAU,SAGzB"}

package/dist/data/readinessStore.js

@@ -0,0 +1,25 @@
+let state = { chains: false };
+const listeners = new Set();
+function emit() {
+    listeners.forEach((l) => l());
+}
+export function getReadySnapshot() {
+    return state !== false && state.chains;
+}
+export function subscribeReady(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function markChainsReady() {
+    if (state === false)
+        state = { chains: false };
+    if (!state.chains) {
+        state = { ...state, chains: true };
+        emit();
+    }
+}
+// Optional (tests / hot reload)
+export function resetReady() {
+    state = { chains: false };
+    emit();
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { fetchAggregatorTrade, getAvailableAggregators } from './aggregator';
+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';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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,cAAc,QAAQ,CAAA;AACtB,cAAc,cAAc,CAAA;AAC5B,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"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { fetchAggregatorTrade, getAvailableAggregators } from './aggregator';
+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';

package/dist/initialize.d.ts

@@ -0,0 +1,11 @@
+import { WalletClient } from 'viem';
+type SdkConfig = {
+    isProductionEnv: boolean;
+    loadChainData: boolean;
+    loadSquidData: boolean;
+    load1deltaConfigs: boolean;
+};
+export declare const initialize: (config: SdkConfig) => Promise<void>;
+export declare const setWalletClient: (walletClient: WalletClient) => void;
+export {};
+//# sourceMappingURL=initialize.d.ts.map

package/dist/initialize.d.ts.map

@@ -0,0 +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"}

package/dist/initialize.js

@@ -0,0 +1,16 @@
+import { fetchAndCacheSquidChains, getAllBridgeConfigs, setWalletClient as setWalletClientBridgeConfigs, } from '@1delta/bridge-configs';
+import { registerConfig } from '@1delta/bridge-core';
+import { setIsProduction } from '@1delta/lib-utils';
+import { inititalizeChainData } from './data/chainData';
+export const initialize = async (config) => {
+    setIsProduction(config.isProductionEnv);
+    if (config.load1deltaConfigs)
+        getAllBridgeConfigs().forEach(registerConfig);
+    if (config.loadChainData)
+        await inititalizeChainData();
+    if (config.loadSquidData)
+        await fetchAndCacheSquidChains();
+};
+export const setWalletClient = (walletClient) => {
+    setWalletClientBridgeConfigs(walletClient);
+};

package/dist/types/aggregator.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/dist/types/aggregator.js

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

package/dist/types/bridgeInput.d.ts

@@ -0,0 +1,32 @@
+import { GenericTrade, RawCurrency, RawCurrencyAmount, TradeType } from '@1delta/lib-utils';
+export type BridgeState = GenericTrade;
+export interface BridgeMultiInput {
+    slippage: number;
+    tradeType: TradeType;
+    fromCurrencies: RawCurrency[];
+    toCurrency: RawCurrency | undefined;
+    swapAmounts: string[];
+    caller: string;
+    receiver: string;
+    order: 'CHEAPEST' | 'FASTEST';
+    parsedAmount: RawCurrencyAmount | undefined;
+    usePermit?: boolean;
+}
+export interface BridgeInput {
+    slippage: number;
+    tradeType: TradeType;
+    fromCurrency: RawCurrency | undefined;
+    toCurrency: RawCurrency | undefined;
+    swapAmount: string | undefined;
+    caller: string;
+    receiver: string;
+    order: 'CHEAPEST' | 'FASTEST';
+    message?: string;
+    usePermit?: boolean;
+    destinationGasLimit?: bigint;
+}
+export interface BridgeApiInput extends Omit<BridgeInput, 'slippage'> {
+    slippage: number | 'auto';
+    defaultSlippage: number;
+}
+//# sourceMappingURL=bridgeInput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bridgeInput.d.ts","sourceRoot":"","sources":["../../src/types/bridgeInput.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,WAAW,EACX,iBAAiB,EACjB,SAAS,EACV,MAAM,mBAAmB,CAAA;AAE1B,MAAM,MAAM,WAAW,GAAG,YAAY,CAAA;AAEtC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;IACpB,cAAc,EAAE,WAAW,EAAE,CAAA;IAC7B,UAAU,EAAE,WAAW,GAAG,SAAS,CAAA;IACnC,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,UAAU,GAAG,SAAS,CAAA;IAC7B,YAAY,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAC3C,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,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,cAAe,SAAQ,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC;IACnE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;IACzB,eAAe,EAAE,MAAM,CAAA;CACxB"}

package/dist/types/bridgeInput.js

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

package/dist/types/index.d.ts

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

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

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

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from './aggregator';
+export * from './bridgeInput';

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from './utils';

package/dist/utils/utils.d.ts

@@ -0,0 +1,32 @@
+import { RawCurrency, TradeType } from '@1delta/lib-utils';
+export declare const emptyAggregatorInput: {
+    chainId: string;
+    fromCurrency: undefined;
+    toCurrency: undefined;
+    swapAmount: string;
+    slippage: number;
+    caller: string;
+    receiver: string;
+    tradeType: TradeType;
+    flashSwap: boolean;
+    routerConfig: {};
+};
+export declare const emptyMultiSwapAggregatorInput: {
+    fromCurrencies: never[];
+    toCurrency: undefined;
+    swapAmounts: never[];
+    slippage: number;
+    caller: string;
+    receiver: string;
+    tradeType: TradeType;
+    flashSwap: boolean;
+    routerConfig: {};
+    parsedAmount: undefined;
+    destinationGasToSwap: bigint;
+};
+export declare function reverseQuote(currencyIn: RawCurrency, currencyOut: RawCurrency, amountOut: string | bigint, priceIn: number, priceOut: number): {
+    currency: RawCurrency;
+    amount: bigint;
+};
+export declare function quote(currencyIn: RawCurrency, currencyOut: RawCurrency, amountIn: string | bigint, priceIn: number, priceOut: number): bigint;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,WAAW,EAEX,SAAS,EACV,MAAM,mBAAmB,CAAA;AAG1B,eAAO,MAAM,oBAAoB;;;;;;;;;;;CAWhC,CAAA;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;CAYzC,CAAA;AAED,wBAAgB,YAAY,CAC1B,UAAU,EAAE,WAAW,EACvB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM;;;EASjB;AAED,wBAAgB,KAAK,CACnB,UAAU,EAAE,WAAW,EACvB,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,MAAM,CAKR"}