@shapeshiftoss/swapper 17.6.6 → 17.6.7

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

@@ -0,0 +1,2 @@
+import type { ThorNodeTxSchema } from './types.js';
+export declare const parseThorBuyTxHash: (sellTxId: string, latestOutTx: ThorNodeTxSchema | undefined, nativeChain: 'THOR' | 'MAYA') => string | undefined;

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

@@ -0,0 +1,10 @@
+const EVM_CHAINS = ['ARB', 'AVAX', 'BASE', 'BSC', 'ETH'];
+export const parseThorBuyTxHash = (sellTxId, latestOutTx, nativeChain) => {
+    if (!latestOutTx)
+        return;
+    // outbound rune transactions do not have a txid as they are processed internally, use sell txid
+    if (latestOutTx.chain === nativeChain)
+        return sellTxId;
+    const isEvmCoinAsset = EVM_CHAINS.some(chain => chain === latestOutTx.chain);
+    return isEvmCoinAsset ? `0x${latestOutTx.id}` : latestOutTx.id;
+};

package/dist/esm/thorchain-utils/routerCallData/routerCallData.test.d.ts

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

package/dist/esm/thorchain-utils/routerCallData/routerCallData.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { depositWithExpiry } from '../index.js';
+const VAULT = '0x78E4E10dCAcB0A8261eB3D5e57fFb98AE8D4dFF1';
+describe('routerCalldata', () => {
+    it('should create valid trade data for the deposit() call', () => {
+        const data = depositWithExpiry({
+            vault: VAULT,
+            asset: '0x0000000000000000000000000000000000000000',
+            amount: 70000000000000000n,
+            memo: `s:ETH.USDC-9D4A2E9EB0CE3606EB48:0x8a65ac0E23F31979db06Ec62Af62b132a6dF4741:420`,
+            expiry: 1694809972n,
+        });
+        // expected data same as an actual thorchain trade
+        // https://etherscan.io/tx/0x517306df8ba18c36759de15e7d663f813ae15b3afd1a442c1f70904b246f4d7e
+        const expectedData = '0x44bc937b00000000000000000000000078e4e10dcacb0a8261eb3d5e57ffb98ae8d4dff1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f8b0a10e47000000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000006504bf74000000000000000000000000000000000000000000000000000000000000004e733a4554482e555344432d39443441324539454230434533363036454234383a3078386136356163304532334633313937396462303645633632416636326231333261366446343734313a343230000000000000000000000000000000000000';
+        expect(data).toEqual(expectedData);
+    });
+});

package/dist/esm/thorchain-utils/routerCallData/routerCalldata.d.ts

@@ -0,0 +1,8 @@
+import type { Address } from 'viem';
+export declare const depositWithExpiry: ({ vault, asset, amount, memo, expiry, }: {
+    vault: Address;
+    asset: Address;
+    amount: bigint;
+    memo: string;
+    expiry: bigint;
+}) => `0x${string}`;

package/dist/esm/thorchain-utils/routerCallData/routerCalldata.js

@@ -0,0 +1,10 @@
+import { THORCHAIN_ROUTER_ABI } from '@shapeshiftoss/contracts';
+import { encodeFunctionData } from 'viem';
+export const depositWithExpiry = ({ vault, asset, amount, memo, expiry, }) => {
+    const data = encodeFunctionData({
+        abi: THORCHAIN_ROUTER_ABI,
+        functionName: 'depositWithExpiry',
+        args: [vault, asset, amount, memo, expiry],
+    });
+    return data;
+};

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

@@ -0,0 +1,5 @@
+export declare const thorService: {
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../index.js").SwapErrorRight>>;
+};

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

@@ -0,0 +1,12 @@
+import { createCache, makeSwapperAxiosServiceMonadic } from '../utils.js';
+// Important: maxAge should be small because inbound address info must be recent
+const maxAge = 5 * 1000; // 5 seconds
+const cachedUrls = ['/pools', '/inbound_addresses', '/pool/'];
+const axiosConfig = {
+    timeout: 10000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+};
+export const thorService = makeSwapperAxiosServiceMonadic(createCache(maxAge, cachedUrls, axiosConfig));

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

@@ -0,0 +1,273 @@
+import type BigNumber from 'bignumber.js';
+import type { SwapSource, TradeQuote, TradeRate } from '../types.js';
+export type ThornodePoolStatuses = 'Available' | 'Staged' | 'Suspended';
+export type MidgardPoolResponse = {
+    annualPercentageRate: string;
+    asset: string;
+    assetDepth: string;
+    assetPrice: string;
+    assetPriceUSD: string;
+    liquidityUnits: string;
+    nativeDecimal: string;
+    poolAPY: string;
+    runeDepth: string;
+    saversAPR: string;
+    saversDepth: string;
+    saversUnits: string;
+    status: 'available' | 'staged' | 'suspended';
+    synthSupply: string;
+    synthUnits: string;
+    totalCollateral: string;
+    totalDebtTor: string;
+    units: string;
+    volume24h: string;
+};
+export type ThornodePoolResponse = {
+    LP_units: string;
+    asset: string;
+    balance_asset: string;
+    balance_rune: string;
+    asset_tor_price: string;
+    pending_inbound_asset: string;
+    pending_inbound_rune: string;
+    pool_units: string;
+    savers_depth: string;
+    savers_units: string;
+    status: ThornodePoolStatuses;
+    synth_mint_paused: boolean;
+    synth_supply: string;
+    synth_supply_remaining: string;
+    synth_units: string;
+    derived_depth_bps: string;
+    loan_collateral: string;
+    loan_collateral_remaining: string;
+    loan_cr: string;
+};
+export type ThornodeQuoteResponseSuccess = {
+    dust_threshold?: string;
+    expected_amount_out: string;
+    expiry: number;
+    fees: {
+        affiliate: string;
+        asset: string;
+        liquidity: string;
+        outbound: string;
+        slippage_bps: number;
+        total: string;
+        total_bps: number;
+    };
+    inbound_address: string;
+    inbound_confirmation_blocks?: number;
+    inbound_confirmation_seconds?: number;
+    max_streaming_quantity?: number;
+    memo?: string;
+    notes: string;
+    outbound_delay_blocks: number;
+    outbound_delay_seconds: number;
+    recommended_min_amount_in?: string;
+    router?: string;
+    streaming_swap_blocks?: number;
+    streaming_swap_seconds?: number;
+    total_swap_seconds?: number;
+    warning: string;
+};
+type ThornodeResponseError = {
+    error: string;
+};
+export type ThornodeQuoteResponse = ThornodeQuoteResponseSuccess | ThornodeResponseError;
+type MidgardCoins = {
+    asset: string;
+}[];
+type MidgardActionIn = {
+    coins: MidgardCoins;
+    txID: string;
+};
+type MidgardActionOut = {
+    coins: MidgardCoins;
+    txID: string;
+};
+type MidgardAction = {
+    date: string;
+    height: string;
+    in: MidgardActionIn[];
+    out: MidgardActionOut[];
+    status: string;
+    type: string;
+};
+export type MidgardActionsResponse = {
+    actions: MidgardAction[];
+};
+export type InboundAddressResponse = {
+    chain: string;
+    pub_key: string;
+    address: string;
+    halted: boolean;
+    gas_rate: string;
+    gas_rate_units: string;
+    router?: string;
+    dust_threshold?: string;
+    global_trading_paused: boolean;
+    chain_trading_paused: boolean;
+    chain_lp_actions_paused: boolean;
+    outbound_tx_size: string;
+    outbound_fee: string;
+};
+type ThorNodeCoinSchema = {
+    asset: string;
+    amount: string;
+    decimals?: number;
+};
+export type ThorNodeTxSchema = {
+    id: string;
+    chain: string;
+    from_address: string;
+    to_address: string;
+    coins: ThorNodeCoinSchema[];
+    gas: ThorNodeCoinSchema[];
+    memo?: string;
+};
+export type ThorNodePlannedTxSchema = {
+    chain: string;
+    to_address: string;
+    coin: ThorNodeCoinSchema;
+    refund: boolean;
+};
+export type ThorNodeStatusResponseSuccess = {
+    tx?: {
+        id: string;
+        memo: string;
+        chain: string;
+        from_address: string;
+        to_address: string;
+    };
+    stages: {
+        inbound_observed: {
+            started?: boolean;
+            final_count?: number;
+            pre_confirmation_count?: number;
+            completed: boolean;
+        };
+        inbound_confirmation_counted?: {
+            completed: boolean;
+            counting_start_height?: number;
+            chain?: string;
+            external_observed_height?: number;
+            external_confirmation_delay_height?: number;
+            remaining_confirmation_seconds?: number;
+        };
+        inbound_finalised?: {
+            completed: boolean;
+        };
+        swap_status?: {
+            pending: boolean;
+            streaming?: {
+                interval: number;
+                quantity: number;
+                count: number;
+            };
+        };
+        swap_finalised?: {
+            completed: boolean;
+        };
+        outbound_delay?: {
+            remaining_delay_blocks?: number;
+            remaining_delay_seconds?: number;
+            completed: boolean;
+        };
+        outbound_signed?: {
+            scheduled_outbound_height?: number;
+            blocks_since_scheduled?: number;
+            completed: boolean;
+        };
+    };
+    out_txs?: ThorNodeTxSchema[];
+    planned_out_txs?: ThorNodePlannedTxSchema[];
+};
+export type ThorNodeTxResponseSuccess = {
+    observed_tx: {
+        tx: ThorNodeTxSchema;
+        observed_pub_key?: string;
+        external_observed_height?: number;
+        external_confirmation_delay_height?: number;
+        aggregator?: string;
+        aggregator_target?: string;
+        aggregator_target_limit?: string;
+        signers?: string[];
+        keysign_ms?: number;
+        out_hashes?: string[];
+        status?: 'done' | 'incomplete';
+    };
+    consensus_height?: number;
+    finalised_height?: number;
+    outbound_height?: number;
+    keysign_metric?: {
+        tx_id?: string;
+        node_tss_times: {
+            address?: string;
+            tss_time?: number;
+        }[];
+    };
+};
+export type ThornodeStatusResponse = ThorNodeStatusResponseSuccess | ThornodeResponseError;
+export type ThornodeTxResponse = ThorNodeTxResponseSuccess | ThornodeResponseError;
+export type ThorEvmTradeQuote = TradeQuote & ThorTradeQuoteSpecificMetadata & {
+    router: string;
+    vault: string;
+    aggregator?: string;
+    data: string;
+} & {
+    receiveAddress: string;
+};
+export type ThorTradeUtxoOrCosmosQuote = TradeQuote & ThorTradeQuoteSpecificMetadata;
+export type ThorTradeQuote = ThorEvmTradeQuote | ThorTradeUtxoOrCosmosQuote;
+export declare enum ThorchainStatusMessage {
+    InboundObserved = "Inbound transaction accepted by THOR",
+    InboundObservingPending = "Inbound transaction pending",
+    InboundConfirmationCounted = "Inbound transaction confirmed",
+    InboundConfirmationPending = "Awaiting inbound transaction confirmation",
+    InboundFinalized = "Inbound transaction finalized",
+    InboundFinalizationPending = "Awaiting inbound transaction finalization",
+    SwapPending = "Swap pending",
+    SwapCompleteAwaitingOutbound = "Swap complete, awaiting outbound transaction",
+    SwapCompleteAwaitingDestination = "Swap complete, awaiting destination chain",
+    OutboundDelayTimeRemaining = "Awaiting outbound delay ({timeRemaining} remaining)",
+    OutboundDelayPending = "Awaiting outbound delay",
+    OutboundSigned = "Outbound transaction transmitted, waiting on destination chain...",
+    OutboundScheduled = "Outbound transaction scheduled, waiting on destination chain..."
+}
+export declare enum TradeType {
+    LongTailToLongTail = "LongTailToLongTail",
+    LongTailToL1 = "LongTailToL1",
+    L1ToLongTail = "L1ToLongTail",
+    L1ToL1 = "L1ToL1"
+}
+type ThorTradeQuoteSpecificMetadata = {
+    isStreaming: boolean;
+    memo: string;
+    recommendedMinimumCryptoBaseUnit: string;
+    tradeType: TradeType;
+    expiry: number;
+    longtailData?: {
+        longtailToL1ExpectedAmountOut?: string;
+        L1ToLongtailExpectedAmountOut?: string;
+    };
+};
+export type ThorEvmTradeRate = TradeRate & ThorTradeQuoteSpecificMetadata & {
+    router: string;
+    vault: string;
+    aggregator?: string;
+    data: string;
+    tradeType: TradeType;
+};
+export type ThorTradeUtxoOrCosmosRate = TradeRate & ThorTradeQuoteSpecificMetadata;
+export type ThorTradeRate = ThorEvmTradeRate | ThorTradeUtxoOrCosmosRate;
+export type ThorTradeRoute = {
+    source: SwapSource;
+    quote: ThornodeQuoteResponseSuccess;
+    expectedAmountOutThorBaseUnit: string;
+    isStreaming: boolean;
+    affiliateBps: string;
+    slippageBps: BigNumber;
+    estimatedExecutionTimeMs: number | undefined;
+};
+export {};

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

@@ -0,0 +1,23 @@
+export var ThorchainStatusMessage;
+(function (ThorchainStatusMessage) {
+    ThorchainStatusMessage["InboundObserved"] = "Inbound transaction accepted by THOR";
+    ThorchainStatusMessage["InboundObservingPending"] = "Inbound transaction pending";
+    ThorchainStatusMessage["InboundConfirmationCounted"] = "Inbound transaction confirmed";
+    ThorchainStatusMessage["InboundConfirmationPending"] = "Awaiting inbound transaction confirmation";
+    ThorchainStatusMessage["InboundFinalized"] = "Inbound transaction finalized";
+    ThorchainStatusMessage["InboundFinalizationPending"] = "Awaiting inbound transaction finalization";
+    ThorchainStatusMessage["SwapPending"] = "Swap pending";
+    ThorchainStatusMessage["SwapCompleteAwaitingOutbound"] = "Swap complete, awaiting outbound transaction";
+    ThorchainStatusMessage["SwapCompleteAwaitingDestination"] = "Swap complete, awaiting destination chain";
+    ThorchainStatusMessage["OutboundDelayTimeRemaining"] = "Awaiting outbound delay ({timeRemaining} remaining)";
+    ThorchainStatusMessage["OutboundDelayPending"] = "Awaiting outbound delay";
+    ThorchainStatusMessage["OutboundSigned"] = "Outbound transaction transmitted, waiting on destination chain...";
+    ThorchainStatusMessage["OutboundScheduled"] = "Outbound transaction scheduled, waiting on destination chain...";
+})(ThorchainStatusMessage || (ThorchainStatusMessage = {}));
+export var TradeType;
+(function (TradeType) {
+    TradeType["LongTailToLongTail"] = "LongTailToLongTail";
+    TradeType["LongTailToL1"] = "LongTailToL1";
+    TradeType["L1ToLongTail"] = "L1ToLongTail";
+    TradeType["L1ToL1"] = "L1ToL1";
+})(TradeType || (TradeType = {}));

package/dist/esm/thorchain-utils/utxo/getThorTxData.d.ts

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { SwapperConfig, SwapperName } from '../../types.js';
+type GetThorTxDataArgs = {
+    sellAsset: Asset;
+    config: SwapperConfig;
+    swapperName: SwapperName;
+};
+type GetThorTxDataReturn = {
+    vault: string;
+};
+export declare const getThorTxData: ({ sellAsset, config, swapperName, }: GetThorTxDataArgs) => Promise<GetThorTxDataReturn>;
+export {};

package/dist/esm/thorchain-utils/utxo/getThorTxData.js

@@ -0,0 +1,10 @@
+import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
+import { getDaemonUrl } from '../index.js';
+export const getThorTxData = async ({ sellAsset, config, swapperName, }) => {
+    const daemonUrl = getDaemonUrl(config, swapperName);
+    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, false, swapperName);
+    if (res.isErr())
+        throw res.unwrapErr();
+    const { address: vault } = res.unwrap();
+    return { vault };
+};

package/dist/esm/thorchain-utils/utxo/getUnsignedUtxoTransaction.d.ts

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

package/dist/esm/thorchain-utils/utxo/getUnsignedUtxoTransaction.js

@@ -0,0 +1,30 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getThorTxData } from './getThorTxData.js';
+export const getUnsignedUtxoTransaction = async (args, swapperName) => {
+    const { tradeQuote, stepIndex, xpub, accountType, assertGetUtxoChainAdapter, config } = args;
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const { memo } = tradeQuote;
+    if (!memo)
+        throw new Error('Memo is required');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, feeData } = step;
+    const { vault } = await getThorTxData({
+        sellAsset,
+        config,
+        swapperName,
+    });
+    return assertGetUtxoChainAdapter(sellAsset.chainId).buildSendApiTransaction({
+        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        xpub,
+        to: vault,
+        accountNumber,
+        // skip address validation for vault addresses as they may exceed the risk score threshold, but are still valid for use
+        skipToAddressValidation: true,
+        chainSpecific: {
+            accountType,
+            opReturnData: memo,
+            satoshiPerByte: feeData.chainSpecific.satsPerByte,
+        },
+    });
+};

package/dist/esm/thorchain-utils/utxo/getUtxoTransactionFees.d.ts

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

package/dist/esm/thorchain-utils/utxo/getUtxoTransactionFees.js

@@ -0,0 +1,25 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getThorTxData } from './getThorTxData.js';
+export const getUtxoTransactionFees = async (args, swapperName) => {
+    const { stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter, config } = args;
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const { memo } = tradeQuote;
+    if (!memo)
+        throw new Error('Memo is required');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = step;
+    const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+    const { vault } = await getThorTxData({
+        sellAsset,
+        config,
+        swapperName,
+    });
+    const { fast } = await adapter.getFeeData({
+        to: vault,
+        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        chainSpecific: { pubkey: xpub, opReturnData: memo },
+        sendMax: false,
+    });
+    return fast.txFee;
+};

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

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

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

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

package/dist/esm/tron-utils/getTronTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedTronTransactionArgs } from '../types.js';
+export declare const getTronTransactionFees: ({ tradeQuote, stepIndex, }: Pick<GetUnsignedTronTransactionArgs, 'tradeQuote' | 'stepIndex'>) => Promise<string>;

package/dist/esm/tron-utils/getTronTransactionFees.js

@@ -0,0 +1,10 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
+export const getTronTransactionFees = ({ tradeQuote, stepIndex, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    if (!step.feeData.networkFeeCryptoBaseUnit) {
+        throw new Error('Missing network fee in quote');
+    }
+    return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+};

package/dist/esm/tron-utils/getUnsignedTronTransaction.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedTronTransactionArgs } from '../types.js';
+export declare const getUnsignedTronTransaction: ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }: GetUnsignedTronTransactionArgs) => Promise<import("packages/chain-adapters/src/tron").TronSignTx>;

package/dist/esm/tron-utils/getUnsignedTronTransaction.js

@@ -0,0 +1,24 @@
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
+export const getUnsignedTronTransaction = ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { accountNumber, sellAsset, relayTransactionMetadata, nearIntentsSpecific } = step;
+    const adapter = assertGetTronChainAdapter(sellAsset.chainId);
+    const to = relayTransactionMetadata?.to ?? nearIntentsSpecific?.depositAddress;
+    if (!to)
+        throw new Error('Missing transaction destination address');
+    const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+    // Extract contract address for TRC20 tokens
+    const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+    return adapter.buildSendApiTransaction({
+        to,
+        from,
+        value,
+        accountNumber,
+        chainSpecific: {
+            contractAddress,
+        },
+    });
+};