@shapeshiftoss/swapper 17.6.6-alpha.1 → 17.6.6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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