@1delta/trade-sdk 0.1.8 → 0.1.10

package/dist/composedTrades/across/acrossWithSwaps.js

@@ -1,124 +0,0 @@
-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';
-import fetchAcrossTradeWithSwap from './acrossWithSwap';
-// Extract contract address validation
-const validateContracts = (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 };
-};
-const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
-export const fetchAcrossTradeWithSwaps = async (input, controller) => {
-    if (!input.fromCurrency || !input.toCurrency)
-        return undefined;
-    if (input.tradeType === TradeType.EXACT_OUTPUT)
-        throw new Error('Exact-out not supported for composed Across trade!');
-    // use a dummy to make across quote without a user address
-    // IMPORTANT: block assemble in this case
-    const isDummy = !input.receiver || !input.caller;
-    let sourceSwapTrade = undefined;
-    const fromChainId = getSafeChainId(input.fromCurrency?.chainId);
-    const toChainId = getSafeChainId(input.toCurrency?.chainId);
-    const { forwarder, composer } = validateContracts(fromChainId);
-    const routes = await fetchAcrossRoutes(fromChainId, toChainId);
-    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);
-    const inputIsAcrossAsset = CurrencyHandler.equal(CurrencyHandler.wrapped(input.fromCurrency), fromAcrossCurrency);
-    const [swapSlippage, acrossSlippage] = splitSlippage(input.slippage, inputIsAcrossAsset, outputIsAcrossAsset);
-    if (!inputIsAcrossAsset) {
-        const sourceSwapInput = {
-            chainId: fromChainId,
-            tradeType: TradeType.EXACT_INPUT,
-            fromCurrency: input.fromCurrency,
-            toCurrency: fromAcrossCurrency,
-            slippage: swapSlippage,
-            swapAmount: input.swapAmount,
-            txOrigin: input.caller,
-            caller: forwarder,
-            receiver: forwarder,
-            flashSwap: undefined,
-            disableComposer: true,
-        };
-        sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
-    }
-    const acrossExtendedAmount = sourceSwapTrade
-        ? minimumAmountOutFromTrade(sourceSwapTrade, sourceSwapTrade.slippage).amount.toString()
-        : input.swapAmount;
-    const acrossExtendedInput = {
-        ...input,
-        caller: isDummy ? DUMMY_ADDRESS : input.caller, // placeholder addresses if we have no connection
-        receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
-        slippage: acrossSlippage,
-        swapAmount: acrossExtendedAmount,
-        fromCurrency: acrossRoute.isNative
-            ? nativeOnChain(acrossRoute.originChainId.toString())
-            : fromAcrossCurrency,
-        bridgeToCurrency: toAcrossCurrency,
-    };
-    const { trade: acrossTradeWithSwap, receiver: bridgeReceiver } = await fetchAcrossTradeWithSwap(acrossExtendedInput, controller);
-    if (!acrossTradeWithSwap)
-        return undefined;
-    const trades = sourceSwapTrade
-        ? [sourceSwapTrade, acrossTradeWithSwap]
-        : [acrossTradeWithSwap];
-    const assemble = async () => {
-        // block assemble if no user address
-        if (isDummy)
-            return undefined;
-        // otherwise continue
-        const fundsToPull = [
-            {
-                address: input.fromCurrency.address,
-                amount: BigInt(input.swapAmount),
-            },
-        ];
-        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, bridgeReceiver, false, fundsToPull, false, false, input.preCalls);
-        return {
-            EVM: {
-                to,
-                calldata,
-                value: value.toString(),
-            },
-        };
-    };
-    const refresh = async (inputOverride) => {
-        const newAggregatorInput = {
-            ...input,
-            slippage: inputOverride?.slippage ?? input.slippage,
-        };
-        return fetchAcrossTradeWithSwaps(newAggregatorInput);
-    };
-    const outputAmount = !!sourceSwapTrade
-        ? increaseAmountBySlippage(acrossTradeWithSwap.outputAmount.amount, Number(swapSlippage))
-        : acrossTradeWithSwap.outputAmount.amount;
-    return {
-        ...acrossTradeWithSwap,
-        inputAmount: sourceSwapTrade?.inputAmount ?? acrossTradeWithSwap.inputAmount,
-        inputAmountRealized: sourceSwapTrade?.inputAmountRealized ??
-            acrossTradeWithSwap.inputAmountRealized,
-        outputAmount: CurrencyHandler.fromRawAmount(acrossTradeWithSwap.outputAmount.currency, outputAmount),
-        outputAmountRealized: convertRawAmount(outputAmount, acrossTradeWithSwap.outputAmount.currency.decimals),
-        stringified: sourceSwapTrade
-            ? `${sourceSwapTrade?.stringified}-${acrossTradeWithSwap.stringified}`
-            : acrossTradeWithSwap.stringified,
-        target: composer,
-        approvalTarget: composer,
-        slippage: input.slippage,
-        assemble,
-        refresh,
-    };
-};
-export default fetchAcrossTradeWithSwaps;

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

@@ -1,5 +0,0 @@
-import { GenericTrade } from '@1delta/lib-utils';
-import { AxelarBaseInput } from '../../types';
-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 +0,0 @@
-{"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,126 +0,0 @@
-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';
-import fetchAxelarTradeWithSwap from './axelarWithSwap';
-// Extract contract address validation
-const validateContracts = (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 };
-};
-const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
-export const fetchAxelarTradeWithSwaps = async (input, controller) => {
-    if (!input.fromCurrency || !input.toCurrency)
-        return undefined;
-    if (input.tradeType === TradeType.EXACT_OUTPUT)
-        throw new Error('Exact-out not supported for composed Axelar trade!');
-    // use a dummy to make axelar quote without a user address
-    // IMPORTANT: block assemble in this case
-    const isDummy = !input.receiver || !input.caller;
-    let sourceSwapTrade = undefined;
-    const fromChainId = getSafeChainId(input.fromCurrency?.chainId);
-    const toChainId = getSafeChainId(input.toCurrency?.chainId);
-    const { forwarder, composer } = validateContracts(fromChainId);
-    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);
-    const inputIsBridgeAsset = CurrencyHandler.equal(CurrencyHandler.wrapped(input.fromCurrency), fromBridgeCurrency);
-    const [swapSlippage, bridgeSlippage] = splitSlippage(input.slippage, inputIsBridgeAsset, outputIsBridgeAsset);
-    if (!inputIsBridgeAsset) {
-        const sourceSwapInput = {
-            chainId: fromChainId,
-            tradeType: TradeType.EXACT_INPUT,
-            fromCurrency: input.fromCurrency,
-            toCurrency: fromBridgeCurrency,
-            slippage: swapSlippage,
-            swapAmount: input.swapAmount,
-            txOrigin: input.caller,
-            caller: forwarder,
-            receiver: forwarder,
-            flashSwap: undefined,
-            disableComposer: true,
-        };
-        sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
-    }
-    const bridgeExtendedAmount = sourceSwapTrade
-        ? minimumAmountOutFromTrade(sourceSwapTrade, sourceSwapTrade.slippage).amount.toString()
-        : input.swapAmount;
-    const bridgeExtendedInput = {
-        ...input,
-        slippage: bridgeSlippage,
-        swapAmount: bridgeExtendedAmount,
-        fromCurrency: fromBridgeCurrency,
-        bridgeToCurrency: toBridgeCurrency,
-        caller: forwarder,
-        receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
-    };
-    const { trade: bridgeTradeWithSwap, gasTrade, receiver: bridgeReceiver, } = await fetchAxelarTradeWithSwap(bridgeExtendedInput, controller);
-    if (!bridgeTradeWithSwap)
-        return undefined;
-    const trades = [];
-    if (sourceSwapTrade)
-        trades.push(sourceSwapTrade);
-    if (gasTrade)
-        trades.push(gasTrade);
-    trades.push(bridgeTradeWithSwap);
-    const assemble = async () => {
-        if (isDummy)
-            return undefined;
-        const fundsToPull = [
-            {
-                address: input.fromCurrency.address,
-                amount: BigInt(input.swapAmount),
-            },
-        ];
-        if (!gasTrade && bridgeTradeWithSwap.gasAmount) {
-            fundsToPull.push({
-                address: nativeOnChain(fromChainId).address,
-                amount: bridgeTradeWithSwap.gasAmount,
-            });
-        }
-        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, bridgeReceiver, true, fundsToPull, false, true, input.preCalls);
-        return {
-            EVM: {
-                to,
-                calldata,
-                value: value.toString(),
-            },
-        };
-    };
-    const refresh = async (inputOverride) => {
-        const newAggregatorInput = {
-            ...input,
-            slippage: inputOverride?.slippage ?? input.slippage,
-        };
-        return fetchAxelarTradeWithSwaps(newAggregatorInput);
-    };
-    const outputAmount = !!sourceSwapTrade
-        ? increaseAmountBySlippage(bridgeTradeWithSwap.outputAmount.amount, Number(swapSlippage))
-        : bridgeTradeWithSwap.outputAmount.amount;
-    return {
-        ...bridgeTradeWithSwap,
-        inputAmount: CurrencyHandler.fromRawAmount(input.fromCurrency, input.swapAmount),
-        inputAmountRealized: convertRawAmount(input.swapAmount, input.fromCurrency.decimals),
-        outputAmount: CurrencyHandler.fromRawAmount(bridgeTradeWithSwap.outputAmount.currency, outputAmount),
-        outputAmountRealized: convertRawAmount(outputAmount, bridgeTradeWithSwap.outputAmount.currency.decimals),
-        stringified: trades.map((t) => t.stringified).join('-'),
-        target: composer,
-        approvalTarget: composer,
-        slippage: input.slippage,
-        assemble,
-        refresh,
-        gasAmount: gasTrade ? undefined : bridgeTradeWithSwap.gasAmount,
-    };
-};
-export default fetchAxelarTradeWithSwaps;

package/dist/composedTrades/gaszip/gaszipWithSwaps.d.ts

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

package/dist/composedTrades/gaszip/gaszipWithSwaps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gaszipWithSwaps.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/gaszip/gaszipWithSwaps.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,YAAY,EASb,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAmB,eAAe,EAAE,MAAM,aAAa,CAAA;AAoB9D,eAAO,MAAM,yBAAyB,GACpC,OAAO,eAAe,EACtB,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAmJlC,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/composedTrades/gaszip/gaszipWithSwaps.js

@@ -1,115 +0,0 @@
-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';
-import { fetchBestTrade, increaseAmountBySlippage, } from '../utils/multichainUtils';
-// Extract contract address validation
-const validateContracts = (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 };
-};
-const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
-export const fetchGaszipTradeWithSwaps = async (input, controller) => {
-    if (!input.fromCurrency || !input.toCurrency)
-        return undefined;
-    // if (input.tradeType === TradeType.EXACT_OUTPUT)
-    //   throw new Error('Exact-out not supported for composed Gaszip trade!')
-    if (!CurrencyHandler.isNative(input.toCurrency))
-        throw new Error('Gaszip only supports Native as output token!');
-    // use a dummy to make gaszip quote without a user address
-    // IMPORTANT: block assemble in this case
-    const isDummy = !input.receiver || !input.caller;
-    let sourceSwapTrade = undefined;
-    const fromChainId = getSafeChainId(input.fromCurrency?.chainId);
-    const toChainId = getSafeChainId(input.toCurrency?.chainId);
-    const { forwarder, composer } = validateContracts(fromChainId);
-    const fromGaszipCurrency = nativeOnChain(fromChainId);
-    const toGaszipCurrency = nativeOnChain(toChainId);
-    const inputIsGaszipAsset = CurrencyHandler.equal(input.fromCurrency, fromGaszipCurrency);
-    const [swapSlippage, gaszipSlippage] = splitSlippage(input.slippage, inputIsGaszipAsset, true);
-    if (!inputIsGaszipAsset) {
-        const sourceSwapInput = {
-            chainId: fromChainId,
-            tradeType: TradeType.EXACT_INPUT,
-            fromCurrency: input.fromCurrency,
-            toCurrency: fromGaszipCurrency,
-            slippage: swapSlippage,
-            swapAmount: input.swapAmount,
-            txOrigin: input.caller,
-            caller: forwarder,
-            receiver: forwarder,
-            flashSwap: undefined,
-            disableComposer: true,
-        };
-        sourceSwapTrade = await fetchBestTrade(sourceSwapInput, controller);
-    }
-    const gaszipExtendedAmount = sourceSwapTrade
-        ? minimumAmountOutFromTrade(sourceSwapTrade, sourceSwapTrade.slippage).amount.toString()
-        : input.swapAmount;
-    const gaszipInput = {
-        tradeType: TradeType.EXACT_INPUT,
-        caller: isDummy ? DUMMY_ADDRESS : input.caller,
-        receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
-        slippage: gaszipSlippage,
-        swapAmount: gaszipExtendedAmount,
-        fromCurrency: fromGaszipCurrency,
-        toCurrency: toGaszipCurrency,
-        order: 'CHEAPEST',
-    };
-    const gaszipTrade = await fetchBridgeTrade(Bridge.GASZIP, gaszipInput, controller);
-    if (!gaszipTrade)
-        return undefined;
-    const trades = sourceSwapTrade
-        ? [sourceSwapTrade, gaszipTrade]
-        : [gaszipTrade];
-    const assemble = async () => {
-        if (isDummy)
-            return undefined;
-        const fundsToPull = [
-            {
-                address: input.fromCurrency.address,
-                amount: BigInt(input.swapAmount),
-            },
-        ];
-        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, input.receiver, false, fundsToPull, false);
-        return {
-            EVM: {
-                to,
-                calldata,
-                value: value.toString(),
-            },
-        };
-    };
-    const refresh = async (inputOverride) => {
-        const newAggregatorInput = {
-            ...input,
-            slippage: inputOverride?.slippage ?? input.slippage,
-        };
-        return fetchGaszipTradeWithSwaps(newAggregatorInput);
-    };
-    const outputAmount = !!sourceSwapTrade
-        ? increaseAmountBySlippage(gaszipTrade.outputAmount.amount, Number(swapSlippage))
-        : gaszipTrade.outputAmount.amount;
-    return {
-        ...gaszipTrade,
-        inputAmount: sourceSwapTrade?.inputAmount ?? gaszipTrade.inputAmount,
-        inputAmountRealized: sourceSwapTrade?.inputAmountRealized ?? gaszipTrade.inputAmountRealized,
-        outputAmount: CurrencyHandler.fromRawAmount(gaszipTrade.outputAmount.currency, outputAmount),
-        outputAmountRealized: convertRawAmount(outputAmount, gaszipTrade.outputAmount.currency.decimals),
-        stringified: sourceSwapTrade
-            ? `${sourceSwapTrade?.stringified}-${gaszipTrade.stringified}`
-            : gaszipTrade.stringified,
-        target: composer,
-        approvalTarget: composer,
-        slippage: input.slippage,
-        assemble,
-        refresh,
-    };
-};
-export default fetchGaszipTradeWithSwaps;