@shapeshiftoss/swapper 17.6.6 → 17.6.8

package/dist/cjs/types.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MixPanelEvent = exports.TradeExecutionEvent = exports.SwapStatus = exports.TransactionExecutionState = exports.TradeQuoteError = exports.SwapperName = void 0;
+var SwapperName;
+(function (SwapperName) {
+    SwapperName["Thorchain"] = "THORChain";
+    SwapperName["Mayachain"] = "MAYAChain";
+    SwapperName["CowSwap"] = "CoW Swap";
+    SwapperName["Zrx"] = "0x";
+    SwapperName["Test"] = "Test";
+    SwapperName["ArbitrumBridge"] = "Arbitrum Bridge";
+    SwapperName["Portals"] = "Portals";
+    SwapperName["Chainflip"] = "Chainflip";
+    SwapperName["Jupiter"] = "Jupiter";
+    SwapperName["Relay"] = "Relay";
+    SwapperName["ButterSwap"] = "ButterSwap";
+    SwapperName["Bebop"] = "Bebop";
+    SwapperName["NearIntents"] = "NEAR Intents";
+    SwapperName["Cetus"] = "Cetus";
+    SwapperName["Sunio"] = "Sun.io";
+    SwapperName["Avnu"] = "AVNU";
+})(SwapperName || (exports.SwapperName = SwapperName = {}));
+var TradeQuoteError;
+(function (TradeQuoteError) {
+    // the swapper was unable to find a quote for this pair
+    TradeQuoteError["UnsupportedTradePair"] = "UnsupportedTradePair";
+    // the swapper does support the pair buy couldn't find a route for the amount specified
+    TradeQuoteError["NoRouteFound"] = "NoRouteFound";
+    // the swapper doesn't support the chain
+    TradeQuoteError["UnsupportedChain"] = "UnsupportedChain";
+    // the swapper can't swap across chains
+    TradeQuoteError["CrossChainNotSupported"] = "CrossChainNotSupported";
+    // the swapper wasn't able to get a network fee estimate
+    TradeQuoteError["NetworkFeeEstimationFailed"] = "NetworkFeeEstimationFailed";
+    // trading has been halted upstream
+    TradeQuoteError["TradingHalted"] = "TradingHalted";
+    // the sell amount was lower than the minimum defined upstream
+    TradeQuoteError["SellAmountBelowMinimum"] = "SellAmountBelowMinimum";
+    // the fees exceed the sell amount
+    TradeQuoteError["SellAmountBelowTradeFee"] = "SellAmountBelowTradeFee";
+    // the swapper has exceeded its rate limit
+    TradeQuoteError["RateLimitExceeded"] = "RateLimitExceeded";
+    // catch-all for XHRs that can fail
+    TradeQuoteError["QueryFailed"] = "QueryFailed";
+    // the response from the API was invalid or unexpected
+    TradeQuoteError["InvalidResponse"] = "InvalidResponse";
+    // an assertion triggered, indicating a bug
+    TradeQuoteError["InternalError"] = "InternalError";
+    // The max. slippage allowed for this trade has been exceeded at final quote time, as returned by the active quote swapper's API upstream
+    TradeQuoteError["FinalQuoteMaxSlippageExceeded"] = "FinalQuoteMaxSlippageExceeded";
+    // Execution reverted at final quote time, as returned by the active quote swapper's API upstream
+    TradeQuoteError["FinalQuoteExecutionReverted"] = "FinalQuoteExecutionReverted";
+    // Didn't fetch quote/rate in time and aborted
+    TradeQuoteError["Timeout"] = "Timeout";
+    // catch-all for unknown issues
+    TradeQuoteError["UnknownError"] = "UnknownError";
+})(TradeQuoteError || (exports.TradeQuoteError = TradeQuoteError = {}));
+var TransactionExecutionState;
+(function (TransactionExecutionState) {
+    TransactionExecutionState["AwaitingConfirmation"] = "AwaitingConfirmation";
+    TransactionExecutionState["Pending"] = "Pending";
+    TransactionExecutionState["Complete"] = "Complete";
+    TransactionExecutionState["Failed"] = "Failed";
+})(TransactionExecutionState || (exports.TransactionExecutionState = TransactionExecutionState = {}));
+var SwapStatus;
+(function (SwapStatus) {
+    SwapStatus["Idle"] = "idle";
+    SwapStatus["Pending"] = "pending";
+    SwapStatus["Success"] = "success";
+    SwapStatus["Failed"] = "failed";
+})(SwapStatus || (exports.SwapStatus = SwapStatus = {}));
+var TradeExecutionEvent;
+(function (TradeExecutionEvent) {
+    TradeExecutionEvent["SellTxHash"] = "sellTxHash";
+    TradeExecutionEvent["RelayerTxHash"] = "relayerTxHash";
+    TradeExecutionEvent["Status"] = "status";
+    TradeExecutionEvent["Success"] = "success";
+    TradeExecutionEvent["Fail"] = "fail";
+    TradeExecutionEvent["Error"] = "error";
+})(TradeExecutionEvent || (exports.TradeExecutionEvent = TradeExecutionEvent = {}));
+var MixPanelEvent;
+(function (MixPanelEvent) {
+    MixPanelEvent["RelayMultiHop"] = "Unable to execute Relay multi-hop quote";
+    MixPanelEvent["RelayStepMultipleItems"] = "Unable to execute relay quote because step contains multiple items";
+})(MixPanelEvent || (exports.MixPanelEvent = MixPanelEvent = {}));

package/dist/cjs/utils/tenderly/index.d.ts

@@ -0,0 +1,3 @@
+export * from './simulate';
+export * from './storageSlots';
+export * from './types';

package/dist/cjs/utils/tenderly/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("./simulate"), exports);
+__exportStar(require("./storageSlots"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/utils/tenderly/simulate.d.ts

@@ -0,0 +1,25 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Address, Hex } from 'viem';
+import type { TenderlyConfig, TenderlyInternalTransaction } from './types';
+export type SimulationResult = {
+    success: boolean;
+    gasUsed: bigint;
+    gasLimit: bigint;
+    errorMessage?: string;
+};
+export type SimulateTransactionParams = {
+    chainId: ChainId;
+    from: Address;
+    to: Address;
+    data: Hex;
+    value?: string | bigint;
+    sellAsset: Asset;
+    spenderAddress?: Address;
+    gas?: number;
+};
+export declare const simulateWithStateOverrides: (params: SimulateTransactionParams, config: TenderlyConfig) => Promise<SimulationResult>;
+export declare const fetchInternalTransactions: (params: {
+    chainId: ChainId;
+    txHash: string;
+}, config: TenderlyConfig) => Promise<TenderlyInternalTransaction[]>;

package/dist/cjs/utils/tenderly/simulate.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchInternalTransactions = exports.simulateWithStateOverrides = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const helpers_1 = require("../../swappers/utils/helpers/helpers");
+const storageSlots_1 = require("./storageSlots");
+const simulateWithStateOverrides = async (params, config) => {
+    const { chainId, from, to, data, value, sellAsset, spenderAddress, gas } = params;
+    try {
+        if (!(0, viem_1.isAddress)(from))
+            throw new Error(`Invalid from address: ${from}`);
+        if (!(0, viem_1.isAddress)(to))
+            throw new Error(`Invalid to address: ${to}`);
+        const evmNetworkId = Number((0, caip_1.fromChainId)(chainId).chainReference);
+        const spender = spenderAddress ?? to;
+        const stateOverrides = buildStateOverrides({
+            from,
+            spender,
+            sellAsset,
+        });
+        const request = {
+            network_id: evmNetworkId.toString(),
+            from: from.toLowerCase(),
+            to: to.toLowerCase(),
+            input: data,
+            gas,
+            value: value ? (0, viem_1.toHex)(BigInt(value)) : '0x0',
+            save: false,
+            state_objects: stateOverrides,
+        };
+        const url = `https://api.tenderly.co/api/v1/account/${config.accountSlug}/project/${config.projectSlug}/simulate`;
+        const response = await axios_1.default.post(url, request, {
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Access-Key': config.apiKey,
+            },
+            timeout: 10000,
+        });
+        if ('error' in response.data) {
+            const error = response.data.error;
+            return {
+                success: false,
+                gasUsed: 0n,
+                gasLimit: 0n,
+                errorMessage: `Tenderly API error: ${error.message}`,
+            };
+        }
+        const { transaction } = response.data;
+        const gasUsed = BigInt(transaction.gas_used);
+        return {
+            success: transaction.status,
+            gasUsed,
+            gasLimit: gasUsed,
+            errorMessage: transaction.error_message,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            gasUsed: 0n,
+            gasLimit: 0n,
+            errorMessage: error instanceof Error ? error.message : 'Unknown simulation error',
+        };
+    }
+};
+exports.simulateWithStateOverrides = simulateWithStateOverrides;
+const fetchInternalTransactions = async (params, config) => {
+    const { chainId, txHash } = params;
+    try {
+        const evmNetworkId = Number((0, caip_1.fromChainId)(chainId).chainReference);
+        const url = `https://api.tenderly.co/api/v1/account/${config.accountSlug}/project/${config.projectSlug}/transactions/by-hash/${evmNetworkId}/${txHash}`;
+        const response = await axios_1.default.get(url, {
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Access-Key': config.apiKey,
+            },
+            timeout: 10000,
+        });
+        return response.data.transaction.internal_transactions ?? [];
+    }
+    catch (error) {
+        return [];
+    }
+};
+exports.fetchInternalTransactions = fetchInternalTransactions;
+const buildStateOverrides = (params) => {
+    const { from, spender, sellAsset } = params;
+    // Large native balance for gas (1B is overkill but guarantees success on all chains)
+    const nativeBalanceOverride = (0, viem_1.toHex)((0, viem_1.parseEther)('1000000000'));
+    const isNative = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId);
+    return isNative
+        ? {
+            [from.toLowerCase()]: {
+                balance: nativeBalanceOverride,
+            },
+        }
+        : (() => {
+            const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+            if (!contractAddress) {
+                return {
+                    [from.toLowerCase()]: {
+                        balance: nativeBalanceOverride,
+                    },
+                };
+            }
+            const balanceSlot = (0, storageSlots_1.getTokenBalanceSlot)(contractAddress);
+            const balanceStorageSlot = (0, storageSlots_1.getBalanceStorageSlot)(from, balanceSlot);
+            const maxBalance = (0, storageSlots_1.getMaxBalanceValue)(contractAddress);
+            const allowanceSlot = (0, storageSlots_1.getTokenAllowanceSlot)(contractAddress);
+            const allowanceStorageSlot = (0, storageSlots_1.getAllowanceStorageSlot)(from, spender, allowanceSlot);
+            return {
+                [from.toLowerCase()]: {
+                    balance: nativeBalanceOverride,
+                },
+                [contractAddress.toLowerCase()]: {
+                    storage: {
+                        [balanceStorageSlot]: maxBalance,
+                        [allowanceStorageSlot]: (0, viem_1.toHex)(viem_1.maxUint256),
+                    },
+                },
+            };
+        })();
+};

package/dist/cjs/utils/tenderly/storageSlots.d.ts

@@ -0,0 +1,8 @@
+import type { Address, Hex } from 'viem';
+export declare const getBalanceStorageSlot: (userAddress: Address, balanceSlotNumber?: number) => Hex;
+export declare const getAllowanceStorageSlot: (ownerAddress: Address, spenderAddress: Address, allowanceSlotNumber?: number) => Hex;
+export declare const KNOWN_BALANCE_SLOTS: Record<string, number>;
+export declare const KNOWN_ALLOWANCE_SLOTS: Record<string, number>;
+export declare const getTokenBalanceSlot: (tokenAddress: Address) => number;
+export declare const getTokenAllowanceSlot: (tokenAddress: Address) => number;
+export declare const getMaxBalanceValue: (tokenAddress: Address) => Hex;

package/dist/cjs/utils/tenderly/storageSlots.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxBalanceValue = exports.getTokenAllowanceSlot = exports.getTokenBalanceSlot = exports.KNOWN_ALLOWANCE_SLOTS = exports.KNOWN_BALANCE_SLOTS = exports.getAllowanceStorageSlot = exports.getBalanceStorageSlot = void 0;
+const viem_1 = require("viem");
+// keccak256(concat(pad(address), pad(slot)))
+const getBalanceStorageSlot = (userAddress, balanceSlotNumber = 0) => {
+    const paddedAddress = (0, viem_1.pad)(userAddress.toLowerCase(), { size: 32 });
+    const paddedSlot = (0, viem_1.pad)((0, viem_1.toHex)(balanceSlotNumber), { size: 32 });
+    return (0, viem_1.keccak256)((0, viem_1.concat)([paddedAddress, paddedSlot]));
+};
+exports.getBalanceStorageSlot = getBalanceStorageSlot;
+// keccak256(spender, keccak256(owner, slot))
+const getAllowanceStorageSlot = (ownerAddress, spenderAddress, allowanceSlotNumber = 1) => {
+    const paddedOwner = (0, viem_1.pad)(ownerAddress.toLowerCase(), { size: 32 });
+    const paddedAllowanceSlot = (0, viem_1.pad)((0, viem_1.toHex)(allowanceSlotNumber), { size: 32 });
+    const innerSlot = (0, viem_1.keccak256)((0, viem_1.concat)([paddedOwner, paddedAllowanceSlot]));
+    const paddedSpender = (0, viem_1.pad)(spenderAddress.toLowerCase(), { size: 32 });
+    return (0, viem_1.keccak256)((0, viem_1.concat)([paddedSpender, innerSlot]));
+};
+exports.getAllowanceStorageSlot = getAllowanceStorageSlot;
+// Most ERC20s: balance at slot 0, allowance at slot 1
+// Slot 51/52 pattern (StandardArbERC20, some L2 implementations)
+// Slot 5/6 pattern (Wormhole bridge)
+// USDT (native Tether - Ethereum): balance at slot 2, allowance at slot 5
+// USDT (BEP20 - BSC): balance at slot 1, allowance at slot 2
+// USDT (xDai bridge - Gnosis): balance at slot 3, allowance at slot 4
+// USDC (Circle native): balance at slot 9, allowance at slot 10
+// USDC (BEP20 - BSC): balance at slot 1, allowance at slot 2
+exports.KNOWN_BALANCE_SLOTS = {
+    // USDT - Native Tether deployment (custom slot 2)
+    '0xdac17f958d2ee523a2206206994597c13d831ec7': 2,
+    // Slot 51 pattern (L2GatewayToken + ERC20Upgradeable + storage gaps)
+    // Various L2 tokens use this pattern with different implementations
+    '0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9': 51,
+    '0x912ce59144191c1204e64559fe8253a0e49e6548': 51,
+    '0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7': 51,
+    '0x01bff41798a0bcf287b996046ca68b395dbc1071': 51,
+    // Wormhole bridge pattern (slot 5)
+    '0xca7dec8550f43a5e46e3dfb95801f64280e75b27': 5,
+    // USDT - BEP20 pattern (slot 1 - Binance-Peg token)
+    '0x55d398326f99059ff775485246999027b3197955': 1,
+    // USDT - xDai bridge pattern (slot 3)
+    '0x4ecaba5870353805a9f068101a40e0f32ed605c6': 3,
+    // USDT - Standard ERC20 deployments (slot 0)
+    // Polygon confirmed, Optimism bridged USDT (0x94b008aa...) also uses slot 0
+    // USDC (Circle native deployments - all use slot 9)
+    '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48': 9,
+    '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e': 9,
+    '0x0b2c639c533813f4aa9d7837caf62653d097ff85': 9,
+    '0x3c499c542cef5e3811e1192ce70d8cc03d5c3359': 9,
+    '0xaf88d065e77c8cc2239327c5edb3a432268e5831': 9,
+    '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913': 9,
+    // USDC (BEP20 pattern on BSC - slot 1)
+    '0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d': 1, // USDC BSC (BEP20)
+};
+exports.KNOWN_ALLOWANCE_SLOTS = {
+    // USDT allowance slots (explicit mapping for all non-standard implementations)
+    '0xdac17f958d2ee523a2206206994597c13d831ec7': 5,
+    '0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9': 52,
+    '0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7': 52,
+    '0x01bff41798a0bcf287b996046ca68b395dbc1071': 52,
+    '0x55d398326f99059ff775485246999027b3197955': 2,
+    '0x4ecaba5870353805a9f068101a40e0f32ed605c6': 4,
+    // Note: Polygon and Optimism standard bridged USDT (0x94b008aa...) use slot 1 (fallback)
+    // Note: SWEAT (slot 5) allowance auto-inferred to slot 6 via Wormhole pattern
+    // USDC allowance slots (BSC uses BEP20 pattern, not Circle FiatToken)
+    '0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d': 2, // USDC BSC (BEP20)
+    // Note: All other USDC (Circle native) use slot 10 (handled by USDC pattern check)
+};
+const getTokenBalanceSlot = (tokenAddress) => exports.KNOWN_BALANCE_SLOTS[tokenAddress.toLowerCase()] ?? 0;
+exports.getTokenBalanceSlot = getTokenBalanceSlot;
+const getTokenAllowanceSlot = (tokenAddress) => {
+    // Check explicit allowance mapping first
+    const explicitSlot = exports.KNOWN_ALLOWANCE_SLOTS[tokenAddress.toLowerCase()];
+    if (explicitSlot !== undefined)
+        return explicitSlot;
+    // Infer allowance slot from balance slot for known patterns
+    const balanceSlot = (0, exports.getTokenBalanceSlot)(tokenAddress);
+    if (balanceSlot === 9)
+        return 10; // USDC pattern
+    if (balanceSlot === 51)
+        return 52; // StandardArbERC20 pattern
+    if (balanceSlot === 5)
+        return 6; // Wormhole pattern
+    // Standard ERC20: allowance at slot 1
+    return 1;
+};
+exports.getTokenAllowanceSlot = getTokenAllowanceSlot;
+// USDC slot 9: bit 255 is blacklist flag, must keep cleared
+const getMaxBalanceValue = (tokenAddress) => {
+    const slot = (0, exports.getTokenBalanceSlot)(tokenAddress);
+    return slot === 9 ? (0, viem_1.toHex)(viem_1.maxUint256 >> 1n) : (0, viem_1.toHex)(viem_1.maxUint256);
+};
+exports.getMaxBalanceValue = getMaxBalanceValue;

package/dist/cjs/utils/tenderly/types.d.ts

@@ -0,0 +1,77 @@
+import type { Address, Hex } from 'viem';
+export type TenderlyStateOverrides = {
+    [address: Address]: {
+        balance?: Hex;
+        storage?: {
+            [slot: Hex]: Hex;
+        };
+    };
+};
+export type TenderlySimulationRequest = {
+    network_id: string;
+    from: Address;
+    to: Address;
+    input: Hex;
+    value?: Hex;
+    gas?: number;
+    gas_price?: string;
+    max_fee_per_gas?: string;
+    max_priority_fee_per_gas?: string;
+    save?: boolean;
+    state_objects?: TenderlyStateOverrides;
+};
+export type TenderlySimulationResponse = {
+    transaction: {
+        hash: string;
+        status: boolean;
+        error_message?: string;
+        gas_used: number;
+        gas: number;
+        gas_price: string;
+        value: string;
+        call_trace?: unknown[];
+        asset_changes?: unknown[];
+    };
+    simulation: {
+        id: string;
+        network_id: string;
+        block_number: number;
+        block_hash: string;
+        timestamp: string;
+        gas_used: number;
+        status: boolean;
+    };
+};
+export type TenderlyErrorResponse = {
+    error: {
+        id: string;
+        slug: string;
+        message: string;
+    };
+};
+export type TenderlyConfig = {
+    apiKey: string;
+    accountSlug: string;
+    projectSlug: string;
+};
+export type TenderlyInternalTransaction = {
+    from: Address;
+    to: Address;
+    value: string;
+};
+export type TenderlyTransactionResponse = {
+    transaction: {
+        hash: string;
+        block_number: number;
+        from: Address;
+        to: Address;
+        input: string;
+        value: string;
+        gas: number;
+        gas_used: number;
+        gas_price: string;
+        status: boolean;
+        error_message?: string;
+        internal_transactions?: TenderlyInternalTransaction[];
+    };
+};

package/dist/cjs/utils/tenderly/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils.d.ts

@@ -0,0 +1,76 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter, near, SignTx, solana, starknet, sui } from '@shapeshiftoss/chain-adapters';
+import type { SolanaSignTx, StarknetSignTx, SuiSignTx } from '@shapeshiftoss/hdwallet-core';
+import type { Asset, EvmChainId } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { Result } from '@sniptt/monads';
+import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import type { TronSignTx } from 'packages/chain-adapters/src/tron/types';
+import type { EvmTransactionExecutionProps, ExecutableTradeStep, NearTransactionExecutionProps, SolanaTransactionExecutionProps, StarknetTransactionExecutionProps, SuiTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, TradeQuote, TradeQuoteStep, TradeRate, TradeStatus, TronTransactionExecutionProps } from './types';
+import { TradeQuoteError } from './types';
+export declare const makeSwapErrorRight: ({ details, cause, code, message, }: {
+    message: string;
+    details?: unknown;
+    cause?: unknown;
+    code?: TradeQuoteError | undefined;
+}) => SwapErrorRight;
+export declare const createTradeAmountTooSmallErr: (details?: {
+    minAmountCryptoBaseUnit: string;
+    assetId: AssetId;
+}) => SwapErrorRight;
+export declare const createCache: (maxAge: number, cachedUrls: string[], axiosConfig: AxiosRequestConfig) => AxiosInstance;
+export declare const AsyncResultOf: <T>(promise: Promise<T>) => Promise<Result<T, Error>>;
+export declare const makeSwapperAxiosServiceMonadic: (service: AxiosInstance) => {
+    get: <T = any>(url: string, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T, any, {}>, SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T_1, any, {}>, SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T_2, any, {}>, SwapErrorRight>>;
+};
+export declare const getHopByIndex: (quote: TradeQuote | TradeRate | undefined, index: SupportedTradeQuoteStepIndex) => TradeQuoteStep | undefined;
+export declare const executeEvmTransaction: (txToSign: SignTx<EvmChainId>, callbacks: EvmTransactionExecutionProps) => Promise<string>;
+export declare const executeSolanaTransaction: (txToSign: SolanaSignTx, callbacks: SolanaTransactionExecutionProps) => Promise<string>;
+export declare const executeTronTransaction: (txToSign: TronSignTx, callbacks: TronTransactionExecutionProps) => Promise<string>;
+export declare const executeSuiTransaction: (txToSign: SuiSignTx, callbacks: SuiTransactionExecutionProps) => Promise<string>;
+export declare const executeNearTransaction: (txToSign: near.NearSignTx, callbacks: NearTransactionExecutionProps) => Promise<string>;
+export declare const executeStarknetTransaction: (txToSign: StarknetSignTx, callbacks: StarknetTransactionExecutionProps) => Promise<string>;
+export declare const createDefaultStatusResponse: (buyTxHash?: string) => {
+    status: TxStatus;
+    buyTxHash: string | undefined;
+    message: undefined;
+};
+export declare const checkSafeTransactionStatus: ({ address, txHash, chainId, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }: {
+    address: string | undefined;
+    txHash: string;
+    chainId: ChainId;
+    assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter;
+    fetchIsSmartContractAddressQuery: (userAddress: string, chainId: ChainId) => Promise<boolean>;
+}) => Promise<TradeStatus | undefined>;
+export declare const checkEvmSwapStatus: ({ txHash, chainId, address, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }: {
+    txHash: string;
+    address: string | undefined;
+    chainId: ChainId;
+    assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter;
+    fetchIsSmartContractAddressQuery: (userAddress: string, chainId: ChainId) => Promise<boolean>;
+}) => Promise<TradeStatus>;
+export declare const getInputOutputRate: ({ sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, sellAsset, buyAsset, }: {
+    sellAmountCryptoBaseUnit: string;
+    buyAmountCryptoBaseUnit: string;
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => string;
+export declare const isExecutableTradeQuote: (quote: TradeQuote | TradeRate) => quote is TradeQuote;
+export declare const isExecutableTradeStep: (step: TradeQuoteStep) => step is ExecutableTradeStep;
+export declare const getExecutableTradeStep: (tradeQuote: TradeQuote, stepIndex: SupportedTradeQuoteStepIndex) => ExecutableTradeStep;
+export declare const checkSolanaSwapStatus: ({ txHash, address, assertGetSolanaChainAdapter, }: {
+    txHash: string;
+    address: string | undefined;
+    assertGetSolanaChainAdapter: (chainId: ChainId) => solana.ChainAdapter;
+}) => Promise<TradeStatus>;
+export declare const checkSuiSwapStatus: ({ txHash, address, assertGetSuiChainAdapter, }: {
+    txHash: string;
+    address: string | undefined;
+    assertGetSuiChainAdapter: (chainId: ChainId) => sui.ChainAdapter;
+}) => Promise<TradeStatus>;
+export declare const checkStarknetSwapStatus: ({ txHash, assertGetStarknetChainAdapter, }: {
+    txHash: string;
+    assertGetStarknetChainAdapter: (chainId: ChainId) => starknet.ChainAdapter;
+}) => Promise<TradeStatus>;