@shapeshiftoss/swapper 17.6.6 → 17.6.7

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

@@ -0,0 +1,68 @@
+import { mayachainChainId, thorchainChainId } from '@shapeshiftoss/caip';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import axios from 'axios';
+import { checkSafeTransactionStatus } from '../utils.js';
+import { getLatestThorTxStatusMessage } from './getLatestThorTxStatusMessage.js';
+import { parseThorBuyTxHash } from './parseBuyTxHash.js';
+export const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, nodeUrl, apiUrl, nativeChain, }) => {
+    try {
+        const maybeSafeTransactionStatus = await 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 === thorchainChainId && nativeChain === 'THOR') ||
+            (chainId === mayachainChainId && nativeChain === 'MAYA')) {
+            const { data: tx } = await axios.get(`${apiUrl}/tx/${txHash}`);
+            if (tx.events['0']?.error) {
+                return {
+                    status: 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.get(`${nodeUrl}/tx/${txHash.replace(/^0x/, '')}`),
+            axios.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: 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 = 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: 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: TxStatus.Confirmed, message: undefined };
+        }
+        const message = getLatestThorTxStatusMessage(txStatusData, hasOutboundL1Tx);
+        return { buyTxHash, status: TxStatus.Pending, message };
+    }
+    catch (e) {
+        console.error(e);
+        return { buyTxHash: undefined, status: TxStatus.Unknown, message: undefined };
+    }
+};

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

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

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

@@ -0,0 +1,11 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+export const getCosmosSdkTransactionFees = async (args) => {
+    const { stepIndex, tradeQuote, assertGetCosmosSdkChainAdapter } = args;
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute trade');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { sellAsset } = step;
+    const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+    const { fast } = await adapter.getFeeData({});
+    return fast.txFee;
+};

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type { SwapperConfig, SwapperName, TradeQuoteStep } from '../../types.js';
+import type { ThorEvmTradeQuote } from '../types.js';
+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/esm/thorchain-utils/evm/getEvmData.js

@@ -0,0 +1,87 @@
+import { assertUnreachable, BigNumber, bn, bnOrZero } from '@shapeshiftoss/utils';
+import assert from 'assert';
+import { getCallDataFromQuote } from '../getCallDataFromQuote.js';
+import { TradeType } from '../types.js';
+import { getThorTxData } from './getThorTxData.js';
+export 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 TradeType.L1ToL1: {
+            const data = await getCallDataFromQuote({
+                data: tradeQuote.data,
+                tradeType,
+                sellAsset,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                longtailData,
+                slippageTolerancePercentageDecimal,
+                vault,
+                swapperName,
+            });
+            return { data, to: router };
+        }
+        case TradeType.LongTailToL1: {
+            assert(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.
+            assert(bnOrZero(expectedAmountOut).gt(0), 'expected expectedAmountOut to be a positive amount');
+            const amountOutMin = BigInt(bnOrZero(expectedAmountOut)
+                .times(bn(1).minus(slippageTolerancePercentageDecimal ?? 0))
+                .toFixed(0, BigNumber.ROUND_UP));
+            // Paranoia: ensure we have this to prevent sandwich attacks on the first step of a LongtailToL1 trade.
+            assert(amountOutMin > 0n, 'expected expectedAmountOut to be a positive amount');
+            const tcVault = vault;
+            const data = await getCallDataFromQuote({
+                data: tradeQuote.data,
+                tradeType,
+                sellAsset,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                longtailData,
+                slippageTolerancePercentageDecimal,
+                vault: tcVault,
+                swapperName,
+            });
+            return { data, to: aggregator };
+        }
+        case TradeType.L1ToLongTail: {
+            const expectedAmountOut = longtailData?.L1ToLongtailExpectedAmountOut ?? '0';
+            // Paranoia assertion - expectedAmountOut should never be 0 as it would likely lead to a loss of funds.
+            assert(bnOrZero(expectedAmountOut).gt(0), 'expected expectedAmountOut to be a positive amount');
+            const { router: updatedRouter } = await getThorTxData({
+                sellAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                swapperName,
+            });
+            assert(router, 'router required for l1 to thorchain longtail swaps');
+            const data = await getCallDataFromQuote({
+                data: tradeQuote.data,
+                tradeType,
+                sellAsset,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                longtailData,
+                slippageTolerancePercentageDecimal,
+                vault,
+                swapperName,
+            });
+            return { data, to: updatedRouter };
+        }
+        case TradeType.LongTailToLongTail:
+            throw Error(`Unsupported trade type: ${TradeType}`);
+        default:
+            return assertUnreachable(tradeType);
+    }
+};

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

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

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

@@ -0,0 +1,19 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { isNativeEvmAsset } from '../../swappers/utils/helpers/helpers.js';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getEvmData } from './getEvmData.js';
+export const getEvmTransactionFees = async (args, swapperName) => {
+    const { from, stepIndex, supportsEIP1559, assertGetEvmChainAdapter, config } = args;
+    const tradeQuote = args.tradeQuote;
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
+    const { data, to } = await getEvmData({ config, step, tradeQuote, swapperName });
+    const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+    const value = isNativeEvmAsset(sellAsset.assetId)
+        ? sellAmountIncludingProtocolFeesCryptoBaseUnit
+        : '0';
+    const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+    return feeData.networkFeeCryptoBaseUnit;
+};

package/dist/esm/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.js';
+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/esm/thorchain-utils/evm/getThorTxData.js

@@ -0,0 +1,29 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { getAddress } from 'viem';
+import { isNativeEvmAsset } from '../../swappers/utils/helpers/helpers.js';
+import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
+import { getDaemonUrl } from '../index.js';
+import { depositWithExpiry } from '../routerCallData/routerCalldata.js';
+export const getThorTxData = async ({ sellAsset, sellAmountCryptoBaseUnit, memo, expiry, config, swapperName, }) => {
+    const { assetReference } = fromAssetId(sellAsset.assetId);
+    const daemonUrl = getDaemonUrl(config, swapperName);
+    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, true, swapperName);
+    if (res.isErr())
+        throw res.unwrapErr();
+    const inboundAddress = res.unwrap();
+    const router = getAddress(inboundAddress.router ?? '');
+    const vault = getAddress(inboundAddress.address);
+    if (!router) {
+        throw Error(`No router found for ${sellAsset.assetId} at inbound address ${inboundAddress}`);
+    }
+    const data = depositWithExpiry({
+        vault,
+        asset: isNativeEvmAsset(sellAsset.assetId)
+            ? '0x0000000000000000000000000000000000000000'
+            : getAddress(assetReference),
+        amount: BigInt(sellAmountCryptoBaseUnit),
+        memo,
+        expiry: BigInt(expiry),
+    });
+    return { data, router, vault };
+};

package/dist/esm/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.js';
+export declare const getUnsignedEvmTransaction: (args: GetUnsignedEvmTransactionArgs, swapperName: SwapperName) => Promise<SignTx<EvmChainId>>;

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

@@ -0,0 +1,19 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { isNativeEvmAsset } from '../../swappers/utils/helpers/helpers.js';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getEvmData } from './getEvmData.js';
+export const getUnsignedEvmTransaction = async (args, swapperName) => {
+    const { from, stepIndex, supportsEIP1559, assertGetEvmChainAdapter, config } = args;
+    const tradeQuote = args.tradeQuote;
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
+    const value = isNativeEvmAsset(sellAsset.assetId)
+        ? sellAmountIncludingProtocolFeesCryptoBaseUnit
+        : '0';
+    const { data, to } = await getEvmData({ config, step, tradeQuote, swapperName });
+    const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+    const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+    return adapter.buildCustomApiTx({ accountNumber, data, from, to, value, ...feeData });
+};

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

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

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

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

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

@@ -0,0 +1,9 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { SwapperConfig, SwapperName } from '../types.js';
+import type { ThorEvmTradeQuote } from './types.js';
+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/esm/thorchain-utils/getCallDataFromQuote.js

@@ -0,0 +1,50 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { THOR_ROUTER_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
+import { assertUnreachable, BigNumber, bn, bnOrZero } from '@shapeshiftoss/utils';
+import { encodeFunctionData, parseAbiItem } from 'viem';
+import { getThorTxData } from './evm/index.js';
+import { TradeType } from './types.js';
+export const getCallDataFromQuote = async ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }) => {
+    switch (tradeType) {
+        case TradeType.L1ToL1: {
+            return data;
+        }
+        case TradeType.LongTailToL1: {
+            const expectedAmountOut = longtailData?.longtailToL1ExpectedAmountOut ?? '0';
+            const amountOutMin = BigInt(bnOrZero(expectedAmountOut)
+                .times(bn(1).minus(slippageTolerancePercentageDecimal ?? 0))
+                .toFixed(0, BigNumber.ROUND_UP));
+            const swapInAbiItem = 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 = THOR_ROUTER_CONTRACT_MAINNET;
+            const tcVault = vault;
+            const token = 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 = encodeFunctionData({
+                abi: [swapInAbiItem],
+                functionName: 'swapIn',
+                args: params,
+            });
+            return swapInData;
+        }
+        case TradeType.L1ToLongTail: {
+            const { data: dataWithAmountOut } = await getThorTxData({
+                sellAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                memo: tcMemo,
+                expiry,
+                config,
+                swapperName,
+            });
+            return dataWithAmountOut;
+        }
+        case TradeType.LongTailToLongTail:
+            throw Error(`Unsupported trade type: ${TradeType}`);
+        default:
+            return assertUnreachable(tradeType);
+    }
+};

package/dist/esm/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.js';
+import type { InboundAddressResponse } from './types.js';
+export declare const getInboundAddressDataForChain: (daemonUrl: string, assetId: AssetId | undefined, excludeHalted: boolean, swapperName: SwapperName) => Promise<Result<InboundAddressResponse, SwapErrorRight>>;

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

@@ -0,0 +1,31 @@
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../types.js';
+import { makeSwapErrorRight } from '../utils.js';
+import { getPoolAssetId } from './index.js';
+import { thorService } from './service.js';
+export const getInboundAddressDataForChain = async (daemonUrl, assetId, excludeHalted, swapperName) => {
+    if (!assetId) {
+        return Err(makeSwapErrorRight({
+            message: '[getInboundAddressDataForChain]: AssetId is required',
+            code: TradeQuoteError.InternalError,
+        }));
+    }
+    const poolAssetId = getPoolAssetId({ assetId, swapperName });
+    const assetChainSymbol = poolAssetId?.slice(0, poolAssetId.indexOf('.'));
+    return (await thorService.get(`${daemonUrl}/inbound_addresses`))
+        .andThen(({ data: inboundAddresses }) => {
+        const activeInboundAddresses = inboundAddresses.filter(a => !a.halted);
+        return 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 Err(makeSwapErrorRight({
+                message: `[getInboundAddressDataForChain]: No inbound address found for asset ${assetId}`,
+                code: TradeQuoteError.QueryFailed,
+            }));
+        return Ok(maybeInboundAddressResponse);
+    });
+};

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

@@ -0,0 +1,6 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, GetTradeRateInput, SwapErrorRight, SwapperDeps, SwapperName } from '../types.js';
+import type { ThorTradeQuote, ThorTradeRate, TradeType } from './types.js';
+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 {};