@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/esm/types.d.ts

@@ -0,0 +1,516 @@
+import type { QuoteResponse } from '@jup-ag/api';
+import type { AccountId, AssetId, ChainId, Nominal } from '@shapeshiftoss/caip';
+import type { ChainAdapter, CosmosSdkChainAdapter, EvmChainAdapter, SignTx, solana, UtxoChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { HDWallet, SolanaSignTx } from '@shapeshiftoss/hdwallet-core';
+import type { AccountMetadata, Asset, AssetsByIdPartial, CosmosSdkChainId, EvmChainId, KnownChainIds, OrderQuoteResponse, PartialRecord, 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 { InterpolationOptions } from 'node-polyglot';
+import type Polyglot 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_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;
+};
+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"
+}
+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 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;
+};
+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 GetCosmosSdkTradeRateInput = CommonTradeRateInput & {
+    chainId: CosmosSdkChainId;
+};
+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;
+export type GetTradeRateInput = GetEvmTradeRateInput | GetCosmosSdkTradeRateInput | GetUtxoTradeRateInput;
+export type GetTradeQuoteInputWithWallet = GetUtxoTradeQuoteWithWallet | GetEvmTradeQuoteInputBase | GetCosmosSdkTradeQuoteInputBase;
+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 SwapperDeps = {
+    assetsById: AssetsByIdPartial;
+    config: SwapperConfig;
+    mixPanel: Mixpanel | undefined;
+    assertGetChainAdapter: (chainId: ChainId) => ChainAdapter<KnownChainIds>;
+} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps;
+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;
+    };
+    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;
+    };
+    thorchainSpecific?: {
+        maxStreamingQuantity?: number;
+    };
+    relayTransactionMetadata?: RelayTransactionMetadata;
+    butterSwapTransactionMetadata?: {
+        to: string;
+        data: string;
+        value: Hex;
+        gasLimit: string;
+    };
+};
+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];
+};
+export type SwapperSpecificMetadata = {
+    chainflipSwapId: number | undefined;
+    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;
+    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>;
+};
+type EvmAccountMetadata = {
+    from: string;
+};
+type SolanaAccountMetadata = {
+    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 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;
+export type TradeStatus = {
+    status: TxStatus;
+    buyTxHash: string | undefined;
+    relayerTxHash?: string | undefined;
+    relayerExplorerTxLink?: string | undefined;
+    message: string | [string, InterpolationOptions] | undefined;
+};
+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>;
+};
+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>;
+    getEvmTransactionFees?: (input: GetUnsignedEvmTransactionArgs) => Promise<string>;
+    getSolanaTransactionFees?: (input: GetUnsignedSolanaTransactionArgs) => Promise<string>;
+    getUtxoTransactionFees?: (input: GetUnsignedUtxoTransactionArgs) => Promise<string>;
+    getCosmosSdkTransactionFees?: (input: GetUnsignedCosmosSdkTransactionArgs) => 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 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 {};

package/dist/esm/types.js

@@ -0,0 +1,78 @@
+export 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 || (SwapperName = {}));
+export 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 || (TradeQuoteError = {}));
+export var TransactionExecutionState;
+(function (TransactionExecutionState) {
+    TransactionExecutionState["AwaitingConfirmation"] = "AwaitingConfirmation";
+    TransactionExecutionState["Pending"] = "Pending";
+    TransactionExecutionState["Complete"] = "Complete";
+    TransactionExecutionState["Failed"] = "Failed";
+})(TransactionExecutionState || (TransactionExecutionState = {}));
+export var SwapStatus;
+(function (SwapStatus) {
+    SwapStatus["Idle"] = "idle";
+    SwapStatus["Pending"] = "pending";
+    SwapStatus["Success"] = "success";
+    SwapStatus["Failed"] = "failed";
+})(SwapStatus || (SwapStatus = {}));
+export var TradeExecutionEvent;
+(function (TradeExecutionEvent) {
+    TradeExecutionEvent["SellTxHash"] = "sellTxHash";
+    TradeExecutionEvent["RelayerTxHash"] = "relayerTxHash";
+    TradeExecutionEvent["Status"] = "status";
+    TradeExecutionEvent["Success"] = "success";
+    TradeExecutionEvent["Fail"] = "fail";
+    TradeExecutionEvent["Error"] = "error";
+})(TradeExecutionEvent || (TradeExecutionEvent = {}));
+export 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 || (MixPanelEvent = {}));

package/dist/esm/utils.d.ts

@@ -0,0 +1,62 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter, SignTx, solana } from '@shapeshiftoss/chain-adapters';
+import type { SolanaSignTx } 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 { EvmTransactionExecutionProps, ExecutableTradeStep, SolanaTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, TradeQuote, TradeQuoteStep, TradeRate, TradeStatus } from './types.js';
+import { TradeQuoteError } from './types.js';
+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 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>;