@shapeshiftoss/swapper 17.6.6 → 17.6.8

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,
+        },
+    });
+};

package/dist/esm/types.d.ts

@@ -0,0 +1,643 @@
+import type { QuoteResponse } from '@jup-ag/api';
+import type { AccountId, AssetId, ChainId, Nominal } from '@shapeshiftoss/caip';
+import type { ChainAdapter, CosmosSdkChainAdapter, EvmChainAdapter, near, SignTx, solana, starknet, sui, tron, UtxoChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { HDWallet, SolanaSignTx, StarknetSignTx, SuiSignTx } from '@shapeshiftoss/hdwallet-core';
+import type { AccountMetadata, Asset, AssetsByIdPartial, CosmosSdkChainId, EvmChainId, KnownChainIds, NearChainId, OrderQuoteResponse, PartialRecord, TronChainId, UtxoAccountType, UtxoChainId } from '@shapeshiftoss/types';
+import type { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { Result } from '@sniptt/monads';
+import type { TransactionInstruction } from '@solana/web3.js';
+import type { TypedData } from 'eip-712';
+import type { Mixpanel } from 'mixpanel-browser';
+import type Polyglot from 'node-polyglot';
+import type { InterpolationOptions } from 'node-polyglot';
+import type { Address, Hex } from 'viem';
+import type { CowMessageToSign } from './swappers/CowSwapper/types.js';
+import type { RelayTransactionMetadata } from './swappers/RelaySwapper/utils/types.js';
+import type { makeSwapperAxiosServiceMonadic } from './utils.js';
+export type SwapperConfig = {
+    VITE_UNCHAINED_THORCHAIN_HTTP_URL: string;
+    VITE_UNCHAINED_MAYACHAIN_HTTP_URL: string;
+    VITE_UNCHAINED_COSMOS_HTTP_URL: string;
+    VITE_THORCHAIN_NODE_URL: string;
+    VITE_MAYACHAIN_NODE_URL: string;
+    VITE_TRON_NODE_URL: string;
+    VITE_FEATURE_THORCHAINSWAP_LONGTAIL: boolean;
+    VITE_FEATURE_THORCHAINSWAP_L1_TO_LONGTAIL: boolean;
+    VITE_THORCHAIN_MIDGARD_URL: string;
+    VITE_MAYACHAIN_MIDGARD_URL: string;
+    VITE_UNCHAINED_BITCOIN_HTTP_URL: string;
+    VITE_UNCHAINED_DOGECOIN_HTTP_URL: string;
+    VITE_UNCHAINED_LITECOIN_HTTP_URL: string;
+    VITE_UNCHAINED_BITCOINCASH_HTTP_URL: string;
+    VITE_UNCHAINED_ETHEREUM_HTTP_URL: string;
+    VITE_UNCHAINED_AVALANCHE_HTTP_URL: string;
+    VITE_UNCHAINED_BNBSMARTCHAIN_HTTP_URL: string;
+    VITE_UNCHAINED_BASE_HTTP_URL: string;
+    VITE_COWSWAP_BASE_URL: string;
+    VITE_PORTALS_BASE_URL: string;
+    VITE_ZRX_BASE_URL: string;
+    VITE_CHAINFLIP_API_KEY: string;
+    VITE_CHAINFLIP_API_URL: string;
+    VITE_FEATURE_CHAINFLIP_SWAP_DCA: boolean;
+    VITE_JUPITER_API_URL: string;
+    VITE_RELAY_API_URL: string;
+    VITE_BEBOP_API_KEY: string;
+    VITE_NEAR_INTENTS_API_KEY: string;
+    VITE_TENDERLY_API_KEY: string;
+    VITE_TENDERLY_ACCOUNT_SLUG: string;
+    VITE_TENDERLY_PROJECT_SLUG: string;
+    VITE_SUI_NODE_URL: string;
+};
+export declare enum SwapperName {
+    Thorchain = "THORChain",
+    Mayachain = "MAYAChain",
+    CowSwap = "CoW Swap",
+    Zrx = "0x",
+    Test = "Test",
+    ArbitrumBridge = "Arbitrum Bridge",
+    Portals = "Portals",
+    Chainflip = "Chainflip",
+    Jupiter = "Jupiter",
+    Relay = "Relay",
+    ButterSwap = "ButterSwap",
+    Bebop = "Bebop",
+    NearIntents = "NEAR Intents",
+    Cetus = "Cetus",
+    Sunio = "Sun.io",
+    Avnu = "AVNU"
+}
+export type SwapSource = SwapperName | `${SwapperName} • ${string}`;
+export type SwapErrorRight = {
+    name: 'SwapError';
+    message: string;
+    cause?: unknown;
+    details?: unknown;
+    code?: TradeQuoteError;
+};
+export declare enum TradeQuoteError {
+    UnsupportedTradePair = "UnsupportedTradePair",
+    NoRouteFound = "NoRouteFound",
+    UnsupportedChain = "UnsupportedChain",
+    CrossChainNotSupported = "CrossChainNotSupported",
+    NetworkFeeEstimationFailed = "NetworkFeeEstimationFailed",
+    TradingHalted = "TradingHalted",
+    SellAmountBelowMinimum = "SellAmountBelowMinimum",
+    SellAmountBelowTradeFee = "SellAmountBelowTradeFee",
+    RateLimitExceeded = "RateLimitExceeded",
+    QueryFailed = "QueryFailed",
+    InvalidResponse = "InvalidResponse",
+    InternalError = "InternalError",
+    FinalQuoteMaxSlippageExceeded = "FinalQuoteMaxSlippageExceeded",
+    FinalQuoteExecutionReverted = "FinalQuoteExecutionReverted",
+    Timeout = "Timeout",
+    UnknownError = "UnknownError"
+}
+export type UtxoFeeData = {
+    satsPerByte: string;
+};
+export type CosmosSdkFeeData = {
+    estimatedGasCryptoBaseUnit: string;
+};
+export type SolanaFeeData = {
+    computeUnits: string;
+    priorityFee: string;
+};
+export type SuiFeeData = {
+    gasBudget: string;
+    gasPrice: string;
+};
+export type AmountDisplayMeta = {
+    amountCryptoBaseUnit: string;
+    asset: Partial<Asset> & Pick<Asset, 'symbol' | 'chainId' | 'precision'>;
+};
+export type ProtocolFee = {
+    requiresBalance: boolean;
+} & AmountDisplayMeta;
+export type QuoteFeeData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+    protocolFees: PartialRecord<AssetId, ProtocolFee> | undefined;
+    chainSpecific?: UtxoFeeData | CosmosSdkFeeData | SolanaFeeData | SuiFeeData;
+};
+export type BuyAssetBySellIdInput = {
+    sellAsset: Asset;
+    assets: Asset[];
+    config: SwapperConfig;
+};
+type CommonTradeInputBase = {
+    sellAsset: Asset;
+    buyAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    affiliateBps: string;
+    allowMultiHop: boolean;
+    slippageTolerancePercentageDecimal?: string;
+};
+export type CommonTradeQuoteInput = CommonTradeInputBase & {
+    sendAddress?: string;
+    receiveAddress: string;
+    accountNumber: number;
+    quoteOrRate: 'quote';
+};
+type CommonTradeRateInput = CommonTradeInputBase & {
+    sendAddress?: undefined;
+    receiveAddress: string | undefined;
+    accountNumber: undefined;
+    quoteOrRate: 'rate';
+};
+type CommonTradeInput = CommonTradeQuoteInput;
+export type GetEvmTradeQuoteInputBase = CommonTradeQuoteInput & {
+    chainId: EvmChainId;
+    supportsEIP1559: boolean;
+};
+export type GetEvmTradeRateInput = CommonTradeRateInput & {
+    chainId: EvmChainId;
+    supportsEIP1559: false;
+};
+export type GetEvmTradeQuoteInput = GetEvmTradeQuoteInputBase;
+export type GetEvmTradeQuoteInputWithWallet = Omit<GetEvmTradeQuoteInputBase, 'supportsEIP1559'> & {
+    wallet: HDWallet;
+};
+export type GetCosmosSdkTradeQuoteInputBase = CommonTradeQuoteInput & {
+    chainId: CosmosSdkChainId;
+};
+export type GetCosmosSdkTradeQuoteInput = CommonTradeInput & {
+    chainId: CosmosSdkChainId;
+};
+export type GetTronTradeQuoteInputBase = CommonTradeInput & {
+    chainId: TronChainId;
+};
+export type GetTronTradeQuoteInput = CommonTradeInput & {
+    chainId: TronChainId;
+};
+export type GetCosmosSdkTradeRateInput = CommonTradeRateInput & {
+    chainId: CosmosSdkChainId;
+};
+export type GetTronTradeRateInput = CommonTradeRateInput & {
+    chainId: TronChainId;
+};
+export type GetNearTradeQuoteInputBase = CommonTradeInput & {
+    chainId: NearChainId;
+};
+export type GetNearTradeQuoteInput = CommonTradeInput & {
+    chainId: NearChainId;
+};
+export type GetNearTradeRateInput = CommonTradeRateInput & {
+    chainId: NearChainId;
+};
+type GetUtxoTradeQuoteWithWallet = CommonTradeQuoteInput & {
+    chainId: UtxoChainId;
+    accountType: UtxoAccountType;
+    accountNumber: number;
+    xpub: string;
+};
+export type GetUtxoTradeRateInput = CommonTradeRateInput & {
+    chainId: UtxoChainId;
+    accountType: UtxoAccountType;
+    accountNumber: number | undefined;
+    xpub: string | undefined;
+};
+export type GetUtxoTradeQuoteInput = GetUtxoTradeQuoteWithWallet;
+export type GetTradeQuoteInput = GetUtxoTradeQuoteInput | GetEvmTradeQuoteInput | GetCosmosSdkTradeQuoteInput | GetTronTradeQuoteInput | GetNearTradeQuoteInput;
+export type GetTradeRateInput = GetEvmTradeRateInput | GetCosmosSdkTradeRateInput | GetUtxoTradeRateInput | GetTronTradeRateInput | GetNearTradeRateInput;
+export type GetTradeQuoteInputWithWallet = GetUtxoTradeQuoteWithWallet | GetEvmTradeQuoteInputBase | GetCosmosSdkTradeQuoteInputBase | GetTronTradeQuoteInputBase | GetNearTradeQuoteInputBase;
+export type EvmSwapperDeps = {
+    assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter;
+    fetchIsSmartContractAddressQuery: (userAddress: string, chainId: ChainId) => Promise<boolean>;
+};
+export type UtxoSwapperDeps = {
+    assertGetUtxoChainAdapter: (chainId: ChainId) => UtxoChainAdapter;
+};
+export type CosmosSdkSwapperDeps = {
+    assertGetCosmosSdkChainAdapter: (chainId: ChainId) => CosmosSdkChainAdapter;
+};
+export type SolanaSwapperDeps = {
+    assertGetSolanaChainAdapter: (chainId: ChainId) => solana.ChainAdapter;
+};
+export type TronSwapperDeps = {
+    assertGetTronChainAdapter: (chainId: ChainId) => tron.ChainAdapter;
+};
+export type SuiSwapperDeps = {
+    assertGetSuiChainAdapter: (chainId: ChainId) => sui.ChainAdapter;
+};
+export type NearSwapperDeps = {
+    assertGetNearChainAdapter: (chainId: ChainId) => near.ChainAdapter;
+};
+export type StarknetSwapperDeps = {
+    assertGetStarknetChainAdapter: (chainId: ChainId) => starknet.ChainAdapter;
+};
+export type SwapperDeps = {
+    assetsById: AssetsByIdPartial;
+    config: SwapperConfig;
+    mixPanel: Mixpanel | undefined;
+    assertGetChainAdapter: (chainId: ChainId) => ChainAdapter<KnownChainIds>;
+} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps;
+export type TradeQuoteStep = {
+    buyAmountBeforeFeesCryptoBaseUnit: string;
+    buyAmountAfterFeesCryptoBaseUnit: string;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    feeData: QuoteFeeData;
+    rate: string;
+    source: SwapSource;
+    buyAsset: Asset;
+    sellAsset: Asset;
+    accountNumber: number | undefined;
+    intermediaryTransactionOutputs?: AmountDisplayMeta[];
+    allowanceContract: string;
+    estimatedExecutionTimeMs: number | undefined;
+    permit2Eip712?: TypedData;
+    zrxTransactionMetadata?: {
+        to: Address;
+        data: Address;
+        gasPrice: string | undefined;
+        gas: string | undefined;
+        value: string;
+    };
+    portalsTransactionMetadata?: {
+        to: Address;
+        from: Address;
+        data: string;
+        value: string;
+        gasLimit: string;
+        isCrossChain?: boolean;
+        buyAssetChainId?: ChainId;
+        expiry?: number;
+        steps?: string[];
+        route?: string[];
+    };
+    bebopTransactionMetadata?: {
+        to: Address;
+        data: Hex;
+        value: Hex;
+        gas?: string;
+    };
+    jupiterQuoteResponse?: QuoteResponse;
+    solanaTransactionMetadata?: {
+        addressLookupTableAddresses: string[];
+        instructions?: TransactionInstruction[];
+    };
+    cowswapQuoteResponse?: OrderQuoteResponse;
+    chainflipSpecific?: {
+        chainflipSwapId?: number;
+        chainflipDepositAddress?: string;
+        chainflipNumberOfChunks?: number;
+        chainflipChunkIntervalBlocks?: number;
+        chainflipMaxBoostFee?: number;
+    };
+    nearIntentsSpecific?: {
+        depositAddress: string;
+        depositMemo?: string;
+        timeEstimate: number;
+        deadline: string;
+    };
+    thorchainSpecific?: {
+        maxStreamingQuantity?: number;
+    };
+    relayTransactionMetadata?: RelayTransactionMetadata;
+    butterSwapTransactionMetadata?: {
+        to: string;
+        data: string;
+        value: Hex;
+        gasLimit: string;
+    };
+    sunioTransactionMetadata?: {
+        route: {
+            amountIn: string;
+            amountOut: string;
+            inUsd: string;
+            outUsd: string;
+            impact: string;
+            fee: string;
+            tokens: string[];
+            symbols: string[];
+            poolFees: string[];
+            poolVersions: string[];
+            stepAmountsOut: string[];
+        };
+    };
+    avnuSpecific?: {
+        quoteId: string;
+        routes: any[];
+    };
+};
+export type TradeRateStep = Omit<TradeQuoteStep, 'accountNumber'> & {
+    accountNumber: undefined;
+};
+export type ExecutableTradeStep = Omit<TradeQuoteStep, 'accountNumber'> & {
+    accountNumber: number;
+};
+type TradeQuoteBase = {
+    id: string;
+    rate: string;
+    receiveAddress: string | undefined;
+    affiliateBps: string;
+    isStreaming?: boolean;
+    priceImpactPercentageDecimal?: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+    isLongtail?: boolean;
+    quoteOrRate: 'quote' | 'rate';
+    swapperName: SwapperName;
+};
+export type StreamingSwapFailedSwap = {
+    reason: string;
+    swapIndex: number;
+};
+export type StreamingSwapMetadata = {
+    attemptedSwapCount: number;
+    maxSwapCount: number;
+    failedSwaps: StreamingSwapFailedSwap[];
+};
+export declare enum TransactionExecutionState {
+    AwaitingConfirmation = "AwaitingConfirmation",
+    Pending = "Pending",
+    Complete = "Complete",
+    Failed = "Failed"
+}
+export type SwapExecutionMetadata = {
+    state: TransactionExecutionState;
+    sellTxHash?: string;
+    relayerTxHash?: string;
+    relayerExplorerTxLink?: string | undefined;
+    buyTxHash?: string;
+    streamingSwap?: StreamingSwapMetadata;
+    message?: string | [string, InterpolationOptions];
+    inboundAddress?: string;
+};
+export type SwapperSpecificMetadata = {
+    chainflipSwapId: number | undefined;
+    nearIntentsSpecific?: {
+        depositAddress: string;
+        depositMemo?: string;
+        timeEstimate: number;
+        deadline: string;
+    };
+    relayTransactionMetadata: RelayTransactionMetadata | undefined;
+    relayerExplorerTxLink: string | undefined;
+    relayerTxHash: string | undefined;
+    stepIndex: SupportedTradeQuoteStepIndex;
+    quoteId: string;
+    streamingSwapMetadata: StreamingSwapMetadata | undefined;
+};
+export declare enum SwapStatus {
+    Idle = "idle",
+    Pending = "pending",
+    Success = "success",
+    Failed = "failed"
+}
+export type Swap = {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    sellAsset: Asset;
+    buyAsset: Asset;
+    status: SwapStatus;
+    source: SwapSource;
+    sellTxHash?: string;
+    buyTxHash?: string;
+    statusMessage?: string | [string, Polyglot.InterpolationOptions] | undefined;
+    sellAccountId: AccountId;
+    buyAccountId: AccountId | undefined;
+    receiveAddress: string | undefined;
+    swapperName: SwapperName;
+    sellAmountCryptoBaseUnit: string;
+    expectedBuyAmountCryptoBaseUnit: string;
+    actualBuyAmountCryptoBaseUnit?: string;
+    sellAmountCryptoPrecision: string;
+    expectedBuyAmountCryptoPrecision: string;
+    txLink?: string;
+    metadata: SwapperSpecificMetadata;
+    isStreaming?: boolean;
+};
+type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+type TupleOf<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
+export type SingleHopTradeQuoteSteps = TupleOf<TradeQuoteStep, 1>;
+export type MultiHopTradeQuoteSteps = TupleOf<TradeQuoteStep, 2>;
+export type SingleHopTradeRateSteps = TupleOf<TradeRateStep, 1>;
+export type MultiHopTradeRateSteps = TupleOf<TradeRateStep, 2>;
+export type SupportedTradeQuoteStepIndex = 0 | 1;
+export type SingleHopTradeQuote = TradeQuoteBase & {
+    steps: SingleHopTradeQuoteSteps;
+};
+export type TradeQuote = TradeQuoteBase & {
+    steps: SingleHopTradeQuoteSteps | MultiHopTradeQuoteSteps;
+} & {
+    quoteOrRate: 'quote';
+    receiveAddress: string;
+};
+export type MultiHopTradeQuote = TradeQuote & {
+    steps: MultiHopTradeQuoteSteps;
+};
+export type MultiHopTradeRate = TradeRate & {
+    steps: MultiHopTradeRateSteps;
+};
+export type TradeRate = TradeQuoteBase & {
+    steps: SingleHopTradeRateSteps | MultiHopTradeRateSteps;
+} & {
+    quoteOrRate: 'rate';
+};
+export type FromOrXpub = {
+    from: string;
+    xpub?: never;
+} | {
+    from?: never;
+    xpub: string;
+};
+export type GetUnsignedTxArgs = {
+    tradeQuote: TradeQuote;
+    chainId: ChainId;
+    accountMetadata?: AccountMetadata;
+    stepIndex: number;
+    supportsEIP1559: boolean;
+    slippageTolerancePercentageDecimal: string;
+} & FromOrXpub;
+export type EvmTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: SignTx<EvmChainId>) => Promise<string>;
+};
+export type EvmMessageExecutionProps = {
+    signMessage: (messageToSign: TypedData) => Promise<string>;
+};
+export type UtxoTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: SignTx<UtxoChainId>) => Promise<string>;
+};
+export type CosmosSdkTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: SignTx<CosmosSdkChainId>) => Promise<string>;
+};
+export type SolanaTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: SolanaSignTx) => Promise<string>;
+};
+export type TronTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: tron.TronSignTx) => Promise<string>;
+};
+export type SuiTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: SuiSignTx) => Promise<string>;
+};
+export type NearTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: near.NearSignTx) => Promise<string>;
+};
+export type StarknetTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: StarknetSignTx) => Promise<string>;
+};
+type EvmAccountMetadata = {
+    from: string;
+};
+type SolanaAccountMetadata = {
+    from: string;
+};
+type TronAccountMetadata = {
+    from: string;
+};
+type SuiAccountMetadata = {
+    from: string;
+};
+type NearAccountMetadata = {
+    from: string;
+};
+type StarknetAccountMetadata = {
+    from: string;
+};
+type UtxoAccountMetadata = {
+    senderAddress: string;
+    xpub: string;
+    accountType: UtxoAccountType;
+};
+type CosmosSdkAccountMetadata = {
+    from: string;
+};
+export type CommonGetUnsignedTransactionArgs = {
+    tradeQuote: TradeQuote;
+    chainId: ChainId;
+    stepIndex: SupportedTradeQuoteStepIndex;
+    slippageTolerancePercentageDecimal: string;
+    config: SwapperConfig;
+};
+export type GetUnsignedEvmTransactionArgs = CommonGetUnsignedTransactionArgs & EvmAccountMetadata & Omit<EvmSwapperDeps, 'fetchIsSmartContractAddressQuery'> & {
+    permit2Signature: string | undefined;
+    supportsEIP1559: boolean;
+};
+export type GetUnsignedSolanaTransactionArgs = CommonGetUnsignedTransactionArgs & SolanaAccountMetadata & SolanaSwapperDeps;
+export type GetUnsignedTronTransactionArgs = CommonGetUnsignedTransactionArgs & TronAccountMetadata & TronSwapperDeps;
+export type GetUnsignedSuiTransactionArgs = CommonGetUnsignedTransactionArgs & SuiAccountMetadata & SuiSwapperDeps;
+export type GetUnsignedNearTransactionArgs = CommonGetUnsignedTransactionArgs & NearAccountMetadata & NearSwapperDeps;
+export type GetUnsignedStarknetTransactionArgs = CommonGetUnsignedTransactionArgs & StarknetAccountMetadata & StarknetSwapperDeps;
+export type GetUnsignedEvmMessageArgs = CommonGetUnsignedTransactionArgs & EvmAccountMetadata & Omit<EvmSwapperDeps, 'fetchIsSmartContractAddressQuery'>;
+export type GetUnsignedUtxoTransactionArgs = CommonGetUnsignedTransactionArgs & UtxoAccountMetadata & UtxoSwapperDeps;
+export type GetUnsignedCosmosSdkTransactionArgs = CommonGetUnsignedTransactionArgs & CosmosSdkAccountMetadata & CosmosSdkSwapperDeps;
+export type UnsignedTx = Nominal<Record<string, any>, 'UnsignedTx'>;
+export type ExecuteTradeArgs = {
+    senderAddress: string;
+    receiverAddress: string;
+    txToSign: UnsignedTx;
+    wallet: HDWallet;
+    chainId: ChainId;
+};
+export type CheckTradeStatusInput = {
+    txHash: string;
+    chainId: ChainId;
+    address: string | undefined;
+    stepIndex: SupportedTradeQuoteStepIndex;
+    config: SwapperConfig;
+    swap: Swap | undefined;
+} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps;
+export type TradeStatus = {
+    status: TxStatus;
+    buyTxHash: string | undefined;
+    relayerTxHash?: string | undefined;
+    relayerExplorerTxLink?: string | undefined;
+    message: string | [string, InterpolationOptions] | undefined;
+    actualBuyAmountCryptoBaseUnit?: string;
+};
+export type TradeQuoteResult = Result<TradeQuote[], SwapErrorRight>;
+export type TradeRateResult = Result<TradeRate[], SwapErrorRight>;
+export type EvmMessageToSign = CowMessageToSign;
+export type Swapper = {
+    executeTrade?: (executeTradeArgs: ExecuteTradeArgs) => Promise<string>;
+    executeEvmTransaction?: (txToSign: SignTx<EvmChainId>, callbacks: EvmTransactionExecutionProps) => Promise<string>;
+    executeEvmMessage?: (txMetaToSign: EvmMessageToSign, callbacks: EvmMessageExecutionProps, config: SwapperConfig) => Promise<string>;
+    executeUtxoTransaction?: (txToSign: SignTx<UtxoChainId>, callbacks: UtxoTransactionExecutionProps) => Promise<string>;
+    executeCosmosSdkTransaction?: (txToSign: SignTx<CosmosSdkChainId>, callbacks: CosmosSdkTransactionExecutionProps) => Promise<string>;
+    executeSolanaTransaction?: (txToSign: SolanaSignTx, callbacks: SolanaTransactionExecutionProps) => Promise<string>;
+    executeTronTransaction?: (txToSign: tron.TronSignTx, callbacks: TronTransactionExecutionProps) => Promise<string>;
+    executeSuiTransaction?: (txToSign: SuiSignTx, callbacks: SuiTransactionExecutionProps) => Promise<string>;
+    executeNearTransaction?: (txToSign: near.NearSignTx, callbacks: NearTransactionExecutionProps) => Promise<string>;
+    executeStarknetTransaction?: (txToSign: StarknetSignTx, callbacks: StarknetTransactionExecutionProps) => Promise<string>;
+};
+export type SwapperApi = {
+    checkTradeStatus: (input: CheckTradeStatusInput) => Promise<TradeStatus>;
+    getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<TradeQuoteResult>;
+    getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<TradeRateResult>;
+    getUnsignedTx?: (input: GetUnsignedTxArgs) => Promise<UnsignedTx>;
+    getUnsignedEvmTransaction?: (input: GetUnsignedEvmTransactionArgs) => Promise<SignTx<EvmChainId>>;
+    getUnsignedEvmMessage?: (input: GetUnsignedEvmMessageArgs) => Promise<EvmMessageToSign>;
+    getUnsignedUtxoTransaction?: (input: GetUnsignedUtxoTransactionArgs) => Promise<SignTx<UtxoChainId>>;
+    getUnsignedCosmosSdkTransaction?: (input: GetUnsignedCosmosSdkTransactionArgs) => Promise<SignTx<CosmosSdkChainId>>;
+    getUnsignedSolanaTransaction?: (input: GetUnsignedSolanaTransactionArgs) => Promise<SolanaSignTx>;
+    getUnsignedTronTransaction?: (input: GetUnsignedTronTransactionArgs) => Promise<tron.TronSignTx>;
+    getUnsignedSuiTransaction?: (input: GetUnsignedSuiTransactionArgs) => Promise<SuiSignTx>;
+    getUnsignedNearTransaction?: (input: GetUnsignedNearTransactionArgs) => Promise<near.NearSignTx>;
+    getUnsignedStarknetTransaction?: (input: GetUnsignedStarknetTransactionArgs) => Promise<StarknetSignTx>;
+    getEvmTransactionFees?: (input: GetUnsignedEvmTransactionArgs) => Promise<string>;
+    getSolanaTransactionFees?: (input: GetUnsignedSolanaTransactionArgs) => Promise<string>;
+    getSuiTransactionFees?: (input: GetUnsignedSuiTransactionArgs) => Promise<string>;
+    getUtxoTransactionFees?: (input: GetUnsignedUtxoTransactionArgs) => Promise<string>;
+    getCosmosSdkTransactionFees?: (input: GetUnsignedCosmosSdkTransactionArgs) => Promise<string>;
+    getTronTransactionFees?: (input: GetUnsignedTronTransactionArgs) => Promise<string>;
+    getNearTransactionFees?: (input: GetUnsignedNearTransactionArgs) => Promise<string>;
+    getStarknetTransactionFees?: (input: GetUnsignedStarknetTransactionArgs) => Promise<string>;
+};
+export type QuoteResult = Result<TradeQuote[], SwapErrorRight> & {
+    swapperName: SwapperName;
+};
+export type RateResult = Result<TradeRate[], SwapErrorRight> & {
+    swapperName: SwapperName;
+    fallback?: Promise<Result<TradeRate[], SwapErrorRight>>;
+};
+export type CommonTradeExecutionInput = {
+    swapperName: SwapperName;
+    tradeQuote: TradeQuote;
+    stepIndex: SupportedTradeQuoteStepIndex;
+    slippageTolerancePercentageDecimal: string;
+};
+export type EvmTransactionExecutionInput = CommonTradeExecutionInput & EvmTransactionExecutionProps & EvmAccountMetadata & {
+    supportsEIP1559: boolean;
+    permit2Signature: string | undefined;
+};
+export type EvmMessageExecutionInput = CommonTradeExecutionInput & EvmMessageExecutionProps & EvmAccountMetadata;
+export type UtxoTransactionExecutionInput = CommonTradeExecutionInput & UtxoTransactionExecutionProps & UtxoAccountMetadata;
+export type CosmosSdkTransactionExecutionInput = CommonTradeExecutionInput & CosmosSdkTransactionExecutionProps & CosmosSdkAccountMetadata;
+export type SolanaTransactionExecutionInput = CommonTradeExecutionInput & SolanaTransactionExecutionProps & SolanaAccountMetadata;
+export type TronTransactionExecutionInput = CommonTradeExecutionInput & TronTransactionExecutionProps & TronAccountMetadata;
+export type SuiTransactionExecutionInput = CommonTradeExecutionInput & SuiTransactionExecutionProps & SuiAccountMetadata;
+export type NearTransactionExecutionInput = CommonTradeExecutionInput & NearTransactionExecutionProps & NearAccountMetadata;
+export type StarknetTransactionExecutionInput = CommonTradeExecutionInput & StarknetTransactionExecutionProps & StarknetAccountMetadata;
+export declare enum TradeExecutionEvent {
+    SellTxHash = "sellTxHash",
+    RelayerTxHash = "relayerTxHash",
+    Status = "status",
+    Success = "success",
+    Fail = "fail",
+    Error = "error"
+}
+export type SellTxHashArgs = {
+    stepIndex: SupportedTradeQuoteStepIndex;
+    sellTxHash: string;
+};
+export type RelayerTxDetailsArgs = {
+    stepIndex: SupportedTradeQuoteStepIndex;
+    relayerTxHash: string;
+    relayerExplorerTxLink: string;
+};
+export type StatusArgs = TradeStatus & {
+    stepIndex: number;
+};
+export type TradeExecutionEventMap = {
+    [TradeExecutionEvent.SellTxHash]: (args: SellTxHashArgs) => void;
+    [TradeExecutionEvent.RelayerTxHash]: (args: RelayerTxDetailsArgs) => void;
+    [TradeExecutionEvent.Status]: (args: StatusArgs) => void;
+    [TradeExecutionEvent.Success]: (args: StatusArgs) => void;
+    [TradeExecutionEvent.Fail]: (args: StatusArgs) => void;
+    [TradeExecutionEvent.Error]: (args: unknown) => void;
+};
+export type MonadicSwapperAxiosService = ReturnType<typeof makeSwapperAxiosServiceMonadic>;
+export declare enum MixPanelEvent {
+    RelayMultiHop = "Unable to execute Relay multi-hop quote",
+    RelayStepMultipleItems = "Unable to execute relay quote because step contains multiple items"
+}
+export {};