@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/cjs/swappers/utils/test-data/setupSwapQuote.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupQuote = void 0;
+const types_1 = require("@shapeshiftoss/types");
+const types_2 = require("../../../types");
+const assets_1 = require("./assets");
+const setupQuote = () => {
+    const sellAsset = { ...assets_1.FOX_MAINNET };
+    const buyAsset = { ...assets_1.WETH };
+    const tradeQuote = {
+        quoteOrRate: 'quote',
+        id: 'foobar',
+        receiveAddress: '0x1234',
+        affiliateBps: '0',
+        slippageTolerancePercentageDecimal: '0',
+        rate: '1',
+        swapperName: types_2.SwapperName.Test,
+        steps: [
+            {
+                estimatedExecutionTimeMs: undefined,
+                allowanceContract: 'allowanceContractAddress',
+                buyAmountBeforeFeesCryptoBaseUnit: '',
+                buyAmountAfterFeesCryptoBaseUnit: '',
+                sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000',
+                sellAsset,
+                buyAsset,
+                accountNumber: 0,
+                feeData: {
+                    networkFeeCryptoBaseUnit: '0',
+                    protocolFees: {},
+                },
+                rate: '1',
+                source: types_2.SwapperName.Test,
+            },
+        ],
+    };
+    const quoteInput = {
+        chainId: types_1.KnownChainIds.EthereumMainnet,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000',
+        sellAsset,
+        buyAsset,
+        accountNumber: 0,
+        receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+        affiliateBps: '0',
+        supportsEIP1559: false,
+        allowMultiHop: false,
+        slippageTolerancePercentageDecimal: '0.002',
+        quoteOrRate: 'quote',
+    };
+    return { quoteInput, tradeQuote, buyAsset, sellAsset };
+};
+exports.setupQuote = setupQuote;

package/dist/cjs/thorchain-utils/checkTradeStatus.d.ts

@@ -0,0 +1,8 @@
+import type { CheckTradeStatusInput, TradeStatus } from '../types';
+type CheckTradeStatusInputExtended = CheckTradeStatusInput & {
+    nodeUrl: string;
+    apiUrl: string;
+    nativeChain: 'THOR' | 'MAYA';
+};
+export declare const checkTradeStatus: ({ txHash, chainId, address, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, nodeUrl, apiUrl, nativeChain, }: CheckTradeStatusInputExtended) => Promise<TradeStatus>;
+export {};

package/dist/cjs/thorchain-utils/checkTradeStatus.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTradeStatus = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../utils");
+const getLatestThorTxStatusMessage_1 = require("./getLatestThorTxStatusMessage");
+const parseBuyTxHash_1 = require("./parseBuyTxHash");
+const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, nodeUrl, apiUrl, nativeChain, }) => {
+    try {
+        const maybeSafeTransactionStatus = await (0, utils_1.checkSafeTransactionStatus)({
+            txHash,
+            chainId,
+            assertGetEvmChainAdapter,
+            address,
+            fetchIsSmartContractAddressQuery,
+        });
+        if (maybeSafeTransactionStatus) {
+            // return any safe transaction status that has not yet executed on chain (no buyTxHash)
+            if (!maybeSafeTransactionStatus.buyTxHash)
+                return maybeSafeTransactionStatus;
+            // The safe buyTxHash is the on chain transaction hash (not the safe transaction hash).
+            // Mutate txHash and continue with regular status check flow.
+            txHash = maybeSafeTransactionStatus.buyTxHash;
+        }
+        // check for native chain tx errors
+        if ((chainId === caip_1.thorchainChainId && nativeChain === 'THOR') ||
+            (chainId === caip_1.mayachainChainId && nativeChain === 'MAYA')) {
+            const { data: tx } = await axios_1.default.get(`${apiUrl}/tx/${txHash}`);
+            if (tx.events['0']?.error) {
+                return {
+                    status: unchained_client_1.TxStatus.Failed,
+                    buyTxHash: undefined,
+                    message: tx.events[0].error.message,
+                };
+            }
+        }
+        // not using monadic axios, this is intentional for simplicity in this non-monadic context
+        const [{ data: txData }, { data: txStatusData }] = await Promise.all([
+            axios_1.default.get(`${nodeUrl}/tx/${txHash.replace(/^0x/, '')}`),
+            axios_1.default.get(`${nodeUrl}/tx/status/${txHash.replace(/^0x/, '')}`),
+        ]);
+        // We care about txStatusData errors because it drives all of the status logic.
+        if ('error' in txStatusData) {
+            return { buyTxHash: undefined, status: unchained_client_1.TxStatus.Unknown, message: undefined };
+        }
+        // We use planned_out_txs to determine the number of out txs because we don't want to derive
+        // swap completion based on the length of out_txs which is populated as the trade executed
+        const numOutTxs = txStatusData.planned_out_txs?.length ?? 0;
+        const lastOutTx = txStatusData.out_txs?.[numOutTxs - 1];
+        const buyTxHash = (0, parseBuyTxHash_1.parseThorBuyTxHash)(txHash, lastOutTx, nativeChain);
+        const hasOutboundL1Tx = lastOutTx !== undefined && lastOutTx.chain !== nativeChain;
+        const hasOutboundNativeTx = lastOutTx !== undefined && lastOutTx.chain === nativeChain;
+        if (txStatusData.planned_out_txs?.some(plannedOutTx => plannedOutTx.refund)) {
+            return { buyTxHash, status: unchained_client_1.TxStatus.Failed, message: undefined };
+        }
+        // We consider the transaction confirmed as soon as we have a buyTxHash
+        // For UTXOs, this means that the swap will be confirmed as soon as Txs hit the mempool
+        // Which is actually correct, as we update UTXO balances optimistically
+        if (!('error' in txData) && buyTxHash && (hasOutboundL1Tx || hasOutboundNativeTx)) {
+            return { buyTxHash, status: unchained_client_1.TxStatus.Confirmed, message: undefined };
+        }
+        const message = (0, getLatestThorTxStatusMessage_1.getLatestThorTxStatusMessage)(txStatusData, hasOutboundL1Tx);
+        return { buyTxHash, status: unchained_client_1.TxStatus.Pending, message };
+    }
+    catch (e) {
+        console.error(e);
+        return { buyTxHash: undefined, status: unchained_client_1.TxStatus.Unknown, message: undefined };
+    }
+};
+exports.checkTradeStatus = checkTradeStatus;

package/dist/cjs/thorchain-utils/cosmossdk/getCosmosSdkTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedCosmosSdkTransactionArgs } from '../../types';
+export declare const getCosmosSdkTransactionFees: (args: GetUnsignedCosmosSdkTransactionArgs) => Promise<string>;

package/dist/cjs/thorchain-utils/cosmossdk/getCosmosSdkTransactionFees.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCosmosSdkTransactionFees = void 0;
+const utils_1 = require("../../utils");
+const getCosmosSdkTransactionFees = async (args) => {
+    const { stepIndex, tradeQuote, assertGetCosmosSdkChainAdapter } = args;
+    if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+        throw new Error('Unable to execute trade');
+    const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+    const { sellAsset } = step;
+    const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+    const { fast } = await adapter.getFeeData({});
+    return fast.txFee;
+};
+exports.getCosmosSdkTransactionFees = getCosmosSdkTransactionFees;

package/dist/cjs/thorchain-utils/cosmossdk/index.d.ts

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

package/dist/cjs/thorchain-utils/cosmossdk/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./getCosmosSdkTransactionFees"), exports);

package/dist/cjs/thorchain-utils/evm/getEvmData.d.ts

@@ -0,0 +1,13 @@
+import type { SwapperConfig, SwapperName, TradeQuoteStep } from '../../types';
+import type { ThorEvmTradeQuote } from '../types';
+type GetEvmDataArgs = {
+    config: SwapperConfig;
+    step: TradeQuoteStep;
+    tradeQuote: ThorEvmTradeQuote;
+    swapperName: SwapperName;
+};
+export declare const getEvmData: ({ config, step, tradeQuote, swapperName }: GetEvmDataArgs) => Promise<{
+    data: string;
+    to: string;
+}>;
+export {};

package/dist/cjs/thorchain-utils/evm/getEvmData.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEvmData = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const assert_1 = __importDefault(require("assert"));
+const getCallDataFromQuote_1 = require("../getCallDataFromQuote");
+const types_1 = require("../types");
+const getThorTxData_1 = require("./getThorTxData");
+const getEvmData = async ({ config, step, tradeQuote, swapperName }) => {
+    const { router, vault, aggregator, memo: tcMemo, tradeType, expiry, longtailData, slippageTolerancePercentageDecimal, } = tradeQuote;
+    if (!tcMemo)
+        throw new Error('Cannot execute Tx without a memo');
+    const { sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
+    switch (tradeType) {
+        case types_1.TradeType.L1ToL1: {
+            const data = await (0, getCallDataFromQuote_1.getCallDataFromQuote)({
+                data: tradeQuote.data,
+                tradeType,
+                sellAsset,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                longtailData,
+                slippageTolerancePercentageDecimal,
+                vault,
+                swapperName,
+            });
+            return { data, to: router };
+        }
+        case types_1.TradeType.LongTailToL1: {
+            (0, assert_1.default)(aggregator, 'aggregator required for thorchain longtail to l1 swaps');
+            const expectedAmountOut = longtailData?.longtailToL1ExpectedAmountOut ?? '0';
+            // Paranoia assertion - expectedAmountOut should never be 0 as it would likely lead to a loss of funds.
+            (0, assert_1.default)((0, utils_1.bnOrZero)(expectedAmountOut).gt(0), 'expected expectedAmountOut to be a positive amount');
+            const amountOutMin = BigInt((0, utils_1.bnOrZero)(expectedAmountOut)
+                .times((0, utils_1.bn)(1).minus(slippageTolerancePercentageDecimal ?? 0))
+                .toFixed(0, utils_1.BigNumber.ROUND_UP));
+            // Paranoia: ensure we have this to prevent sandwich attacks on the first step of a LongtailToL1 trade.
+            (0, assert_1.default)(amountOutMin > 0n, 'expected expectedAmountOut to be a positive amount');
+            const tcVault = vault;
+            const data = await (0, getCallDataFromQuote_1.getCallDataFromQuote)({
+                data: tradeQuote.data,
+                tradeType,
+                sellAsset,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                longtailData,
+                slippageTolerancePercentageDecimal,
+                vault: tcVault,
+                swapperName,
+            });
+            return { data, to: aggregator };
+        }
+        case types_1.TradeType.L1ToLongTail: {
+            const expectedAmountOut = longtailData?.L1ToLongtailExpectedAmountOut ?? '0';
+            // Paranoia assertion - expectedAmountOut should never be 0 as it would likely lead to a loss of funds.
+            (0, assert_1.default)((0, utils_1.bnOrZero)(expectedAmountOut).gt(0), 'expected expectedAmountOut to be a positive amount');
+            const { router: updatedRouter } = await (0, getThorTxData_1.getThorTxData)({
+                sellAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                swapperName,
+            });
+            (0, assert_1.default)(router, 'router required for l1 to thorchain longtail swaps');
+            const data = await (0, getCallDataFromQuote_1.getCallDataFromQuote)({
+                data: tradeQuote.data,
+                tradeType,
+                sellAsset,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                longtailData,
+                slippageTolerancePercentageDecimal,
+                vault,
+                swapperName,
+            });
+            return { data, to: updatedRouter };
+        }
+        case types_1.TradeType.LongTailToLongTail:
+            throw Error(`Unsupported trade type: ${types_1.TradeType}`);
+        default:
+            return (0, utils_1.assertUnreachable)(tradeType);
+    }
+};
+exports.getEvmData = getEvmData;

package/dist/cjs/thorchain-utils/evm/getEvmTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedEvmTransactionArgs, SwapperName } from '../../types';
+export declare const getEvmTransactionFees: (args: GetUnsignedEvmTransactionArgs, swapperName: SwapperName) => Promise<string>;

package/dist/cjs/thorchain-utils/evm/getEvmTransactionFees.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEvmTransactionFees = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const helpers_1 = require("../../swappers/utils/helpers/helpers");
+const utils_1 = require("../../utils");
+const getEvmData_1 = require("./getEvmData");
+const getEvmTransactionFees = async (args, swapperName) => {
+    const { from, stepIndex, supportsEIP1559, assertGetEvmChainAdapter, config } = args;
+    const tradeQuote = args.tradeQuote;
+    if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+    const { sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
+    const { data, to } = await (0, getEvmData_1.getEvmData)({ config, step, tradeQuote, swapperName });
+    const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+    const value = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+        ? sellAmountIncludingProtocolFeesCryptoBaseUnit
+        : '0';
+    const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+    return feeData.networkFeeCryptoBaseUnit;
+};
+exports.getEvmTransactionFees = getEvmTransactionFees;

package/dist/cjs/thorchain-utils/evm/getThorTxData.d.ts

@@ -0,0 +1,18 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Address } from 'viem';
+import type { SwapperConfig, SwapperName } from '../../types';
+type GetThorTxDataArgs = {
+    sellAsset: Asset;
+    sellAmountCryptoBaseUnit: string;
+    memo: string;
+    expiry: number;
+    config: SwapperConfig;
+    swapperName: SwapperName;
+};
+type GetThorTxDataReturn = {
+    data: string;
+    router: Address;
+    vault: Address;
+};
+export declare const getThorTxData: ({ sellAsset, sellAmountCryptoBaseUnit, memo, expiry, config, swapperName, }: GetThorTxDataArgs) => Promise<GetThorTxDataReturn>;
+export {};

package/dist/cjs/thorchain-utils/evm/getThorTxData.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThorTxData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const viem_1 = require("viem");
+const helpers_1 = require("../../swappers/utils/helpers/helpers");
+const getInboundAddressDataForChain_1 = require("../getInboundAddressDataForChain");
+const index_1 = require("../index");
+const routerCalldata_1 = require("../routerCallData/routerCalldata");
+const getThorTxData = async ({ sellAsset, sellAmountCryptoBaseUnit, memo, expiry, config, swapperName, }) => {
+    const { assetReference } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+    const daemonUrl = (0, index_1.getDaemonUrl)(config, swapperName);
+    const res = await (0, getInboundAddressDataForChain_1.getInboundAddressDataForChain)(daemonUrl, sellAsset.assetId, true, swapperName);
+    if (res.isErr())
+        throw res.unwrapErr();
+    const inboundAddress = res.unwrap();
+    const router = (0, viem_1.getAddress)(inboundAddress.router ?? '');
+    const vault = (0, viem_1.getAddress)(inboundAddress.address);
+    if (!router) {
+        throw Error(`No router found for ${sellAsset.assetId} at inbound address ${inboundAddress}`);
+    }
+    const data = (0, routerCalldata_1.depositWithExpiry)({
+        vault,
+        asset: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+            ? '0x0000000000000000000000000000000000000000'
+            : (0, viem_1.getAddress)(assetReference),
+        amount: BigInt(sellAmountCryptoBaseUnit),
+        memo,
+        expiry: BigInt(expiry),
+    });
+    return { data, router, vault };
+};
+exports.getThorTxData = getThorTxData;

package/dist/cjs/thorchain-utils/evm/getUnsignedEvmTransaction.d.ts

@@ -0,0 +1,4 @@
+import type { SignTx } from '@shapeshiftoss/chain-adapters';
+import type { EvmChainId } from '@shapeshiftoss/types';
+import type { GetUnsignedEvmTransactionArgs, SwapperName } from '../../types';
+export declare const getUnsignedEvmTransaction: (args: GetUnsignedEvmTransactionArgs, swapperName: SwapperName) => Promise<SignTx<EvmChainId>>;

package/dist/cjs/thorchain-utils/evm/getUnsignedEvmTransaction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnsignedEvmTransaction = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const helpers_1 = require("../../swappers/utils/helpers/helpers");
+const utils_1 = require("../../utils");
+const getEvmData_1 = require("./getEvmData");
+const getUnsignedEvmTransaction = async (args, swapperName) => {
+    const { from, stepIndex, supportsEIP1559, assertGetEvmChainAdapter, config } = args;
+    const tradeQuote = args.tradeQuote;
+    if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+    const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
+    const value = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+        ? sellAmountIncludingProtocolFeesCryptoBaseUnit
+        : '0';
+    const { data, to } = await (0, getEvmData_1.getEvmData)({ config, step, tradeQuote, swapperName });
+    const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+    const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+    return adapter.buildCustomApiTx({ accountNumber, data, from, to, value, ...feeData });
+};
+exports.getUnsignedEvmTransaction = getUnsignedEvmTransaction;

package/dist/cjs/thorchain-utils/evm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './getThorTxData';
+export * from './getUnsignedEvmTransaction';
+export * from './getEvmTransactionFees';

package/dist/cjs/thorchain-utils/evm/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./getThorTxData"), exports);
+__exportStar(require("./getUnsignedEvmTransaction"), exports);
+__exportStar(require("./getEvmTransactionFees"), exports);

package/dist/cjs/thorchain-utils/getCallDataFromQuote.d.ts

@@ -0,0 +1,9 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { SwapperConfig, SwapperName } from '../types';
+import type { ThorEvmTradeQuote } from './types';
+export declare const getCallDataFromQuote: ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }: Pick<ThorEvmTradeQuote, "data" | "slippageTolerancePercentageDecimal" | "memo" | "aggregator" | "vault" | "expiry" | "tradeType" | "longtailData"> & {
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    config: SwapperConfig;
+    sellAsset: Asset;
+    swapperName: SwapperName;
+}) => Promise<string>;

package/dist/cjs/thorchain-utils/getCallDataFromQuote.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallDataFromQuote = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const contracts_1 = require("@shapeshiftoss/contracts");
+const utils_1 = require("@shapeshiftoss/utils");
+const viem_1 = require("viem");
+const evm_1 = require("./evm");
+const types_1 = require("./types");
+const getCallDataFromQuote = async ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }) => {
+    switch (tradeType) {
+        case types_1.TradeType.L1ToL1: {
+            return data;
+        }
+        case types_1.TradeType.LongTailToL1: {
+            const expectedAmountOut = longtailData?.longtailToL1ExpectedAmountOut ?? '0';
+            const amountOutMin = BigInt((0, utils_1.bnOrZero)(expectedAmountOut)
+                .times((0, utils_1.bn)(1).minus(slippageTolerancePercentageDecimal ?? 0))
+                .toFixed(0, utils_1.BigNumber.ROUND_UP));
+            const swapInAbiItem = (0, viem_1.parseAbiItem)('function swapIn(address tcRouter, address tcVault, string tcMemo, address token, uint256 amount, uint256 amountOutMin, uint256 deadline)');
+            // Long-tails are only supported on mainnet
+            const tcRouter = contracts_1.THOR_ROUTER_CONTRACT_MAINNET;
+            const tcVault = vault;
+            const token = (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+            const amount = BigInt(sellAmountIncludingProtocolFeesCryptoBaseUnit);
+            const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+            const tenMinutes = BigInt(600);
+            const deadline = currentTimestamp + tenMinutes;
+            const params = [tcRouter, tcVault, tcMemo, token, amount, amountOutMin, deadline];
+            const swapInData = (0, viem_1.encodeFunctionData)({
+                abi: [swapInAbiItem],
+                functionName: 'swapIn',
+                args: params,
+            });
+            return swapInData;
+        }
+        case types_1.TradeType.L1ToLongTail: {
+            const { data: dataWithAmountOut } = await (0, evm_1.getThorTxData)({
+                sellAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                swapperName,
+            });
+            return dataWithAmountOut;
+        }
+        case types_1.TradeType.LongTailToLongTail:
+            throw Error(`Unsupported trade type: ${types_1.TradeType}`);
+        default:
+            return (0, utils_1.assertUnreachable)(tradeType);
+    }
+};
+exports.getCallDataFromQuote = getCallDataFromQuote;

package/dist/cjs/thorchain-utils/getInboundAddressDataForChain.d.ts

@@ -0,0 +1,5 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperName } from '../types';
+import type { InboundAddressResponse } from './types';
+export declare const getInboundAddressDataForChain: (daemonUrl: string, assetId: AssetId | undefined, excludeHalted: boolean, swapperName: SwapperName) => Promise<Result<InboundAddressResponse, SwapErrorRight>>;

package/dist/cjs/thorchain-utils/getInboundAddressDataForChain.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInboundAddressDataForChain = void 0;
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const index_1 = require("./index");
+const service_1 = require("./service");
+const getInboundAddressDataForChain = async (daemonUrl, assetId, excludeHalted, swapperName) => {
+    if (!assetId) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: '[getInboundAddressDataForChain]: AssetId is required',
+            code: types_1.TradeQuoteError.InternalError,
+        }));
+    }
+    const poolAssetId = (0, index_1.getPoolAssetId)({ assetId, swapperName });
+    const assetChainSymbol = poolAssetId?.slice(0, poolAssetId.indexOf('.'));
+    return (await service_1.thorService.get(`${daemonUrl}/inbound_addresses`))
+        .andThen(({ data: inboundAddresses }) => {
+        const activeInboundAddresses = inboundAddresses.filter(a => !a.halted);
+        return (0, monads_1.Ok)((excludeHalted ? activeInboundAddresses : inboundAddresses).find(inbound => inbound.chain === assetChainSymbol));
+    })
+        .andThen(maybeInboundAddressResponse => {
+        if (!maybeInboundAddressResponse ||
+            // We should not need this. Added to conform to the previous inboundAddress?.address by consumers
+            // but the address itself will never be undefined, only the inboundAddress
+            (maybeInboundAddressResponse && !maybeInboundAddressResponse.address))
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[getInboundAddressDataForChain]: No inbound address found for asset ${assetId}`,
+                code: types_1.TradeQuoteError.QueryFailed,
+            }));
+        return (0, monads_1.Ok)(maybeInboundAddressResponse);
+    });
+};
+exports.getInboundAddressDataForChain = getInboundAddressDataForChain;

package/dist/cjs/thorchain-utils/getL1RateOrQuote.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, GetTradeRateInput, SwapErrorRight, SwapperDeps, SwapperName } from '../types';
+import type { ThorTradeQuote, ThorTradeRate, TradeType } from './types';
+type ThorTradeRateOrQuote = ThorTradeRate | ThorTradeQuote;
+export declare const getL1RateOrQuote: <T extends ThorTradeRateOrQuote>(input: T extends ThorTradeRate ? GetTradeRateInput : CommonTradeQuoteInput, deps: SwapperDeps, streamingInterval: number, tradeType: TradeType, swapperName: SwapperName) => Promise<Result<T[], SwapErrorRight>>;
+export {};