@shapeshiftoss/swapper 17.6.6-alpha.0 → 17.6.6

package/dist/esm/swappers/RelaySwapper/constant.js

@@ -1,71 +0,0 @@
-import { arbitrumChainId, avalancheChainId, baseChainId, bscChainId, btcChainId, ethChainId, gnosisChainId, optimismChainId, polygonChainId, solanaChainId, } from '@shapeshiftoss/caip';
-import { KnownChainIds } from '@shapeshiftoss/types';
-import invert from 'lodash/invert';
-import { zeroAddress } from 'viem';
-import { arbitrum, avalanche, base, bsc, gnosis, mainnet as ethereum, optimism, polygon, } from 'viem/chains';
-import { TradeQuoteError } from '../../types.js';
-import { RelayErrorCode } from './utils/types.js';
-export const relaySupportedChainIds = [
-    KnownChainIds.EthereumMainnet,
-    KnownChainIds.ArbitrumMainnet,
-    KnownChainIds.BaseMainnet,
-    KnownChainIds.OptimismMainnet,
-    KnownChainIds.PolygonMainnet,
-    KnownChainIds.GnosisMainnet,
-    KnownChainIds.AvalancheMainnet,
-    KnownChainIds.BitcoinMainnet,
-    KnownChainIds.SolanaMainnet,
-    KnownChainIds.BnbSmartChainMainnet,
-];
-export const chainIdToRelayChainId = {
-    // https://docs.relay.link/resources/supported-chains
-    [btcChainId]: 8253038,
-    [ethChainId]: ethereum.id,
-    [arbitrumChainId]: arbitrum.id,
-    [baseChainId]: base.id,
-    [optimismChainId]: optimism.id,
-    [polygonChainId]: polygon.id,
-    // https://docs.relay.link/resources/supported-chains
-    [solanaChainId]: 792703809,
-    [gnosisChainId]: gnosis.id,
-    [avalancheChainId]: avalanche.id,
-    [bscChainId]: bsc.id,
-};
-export var RelayStatusMessage;
-(function (RelayStatusMessage) {
-    RelayStatusMessage["WaitingForDeposit"] = "Waiting for deposit...";
-    RelayStatusMessage["DepositDetected"] = "Deposit detected, processing swap...";
-    RelayStatusMessage["Retrying"] = "Taking a bit longer than usual to find a route, hang tight...";
-    RelayStatusMessage["SwapComplete"] = "Swap complete";
-    RelayStatusMessage["SwapFailed"] = "Swap failed";
-})(RelayStatusMessage || (RelayStatusMessage = {}));
-export const relayChainIdToChainId = invert(chainIdToRelayChainId);
-export const DEFAULT_RELAY_EVM_TOKEN_ADDRESS = zeroAddress;
-export const RELAY_BTC_TOKEN_ADDRESS = 'bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8';
-export const RELAY_SOLANA_TOKEN_ADDRESS = '11111111111111111111111111111111';
-export const DEFAULT_RELAY_EVM_USER_ADDRESS = '0x000000000000000000000000000000000000dead';
-export const DEFAULT_RELAY_BTC_USER_ADDRESS = 'bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa';
-export const DEFAULT_RELAY_SOLANA_USER_ADDRESS = 'CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr';
-export const MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
-export const relayErrorCodeToTradeQuoteError = {
-    [RelayErrorCode.AmountTooLow]: TradeQuoteError.SellAmountBelowMinimum,
-    [RelayErrorCode.ChainDisabled]: TradeQuoteError.TradingHalted,
-    [RelayErrorCode.Erc20RouterAddressNotFound]: TradeQuoteError.UnsupportedTradePair,
-    [RelayErrorCode.ExtraTransactionsNotSupported]: TradeQuoteError.UnsupportedTradePair,
-    [RelayErrorCode.InsufficientFunds]: TradeQuoteError.SellAmountBelowTradeFee,
-    [RelayErrorCode.InsufficientLiquidity]: TradeQuoteError.SellAmountBelowTradeFee,
-    [RelayErrorCode.InvalidAddress]: TradeQuoteError.UnsupportedTradePair,
-    [RelayErrorCode.InvalidExtraTransactions]: TradeQuoteError.UnsupportedTradePair,
-    [RelayErrorCode.NoQuotes]: TradeQuoteError.NoRouteFound,
-    [RelayErrorCode.NoSwapRoutesFound]: TradeQuoteError.NoRouteFound,
-    [RelayErrorCode.UnsupportedRoute]: TradeQuoteError.UnsupportedTradePair,
-    [RelayErrorCode.UnsupportedExecutionType]: TradeQuoteError.UnknownError,
-    [RelayErrorCode.UserRecipientMismatch]: TradeQuoteError.UnknownError,
-    [RelayErrorCode.PermitFailed]: TradeQuoteError.UnknownError,
-    [RelayErrorCode.SwapImpactTooHigh]: TradeQuoteError.UnknownError,
-    [RelayErrorCode.SwapQuoteFailed]: TradeQuoteError.UnknownError,
-    [RelayErrorCode.Unauthorized]: TradeQuoteError.UnknownError,
-    [RelayErrorCode.UnknownError]: TradeQuoteError.UnknownError,
-    [RelayErrorCode.UnsupportedChain]: TradeQuoteError.UnknownError,
-    [RelayErrorCode.UnsupportedCurrency]: TradeQuoteError.UnknownError,
-};

package/dist/esm/swappers/RelaySwapper/endpoints.d.ts

@@ -1,2 +0,0 @@
-import type { SwapperApi } from '../../types.js';
-export declare const relayApi: SwapperApi;

package/dist/esm/swappers/RelaySwapper/endpoints.js

@@ -1,188 +0,0 @@
-import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { TxStatus } from '@shapeshiftoss/unchained-client';
-import BigNumber from 'bignumber.js';
-import { getSolanaTransactionFees } from '../../solana-utils/getSolanaTransactionFees.js';
-import { getUnsignedSolanaTransaction } from '../../solana-utils/getUnsignedSolanaTransaction.js';
-import { checkSafeTransactionStatus, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
-import { chainIdToRelayChainId } from './constant.js';
-import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
-import { getTradeRate } from './getTradeRate/getTradeRate.js';
-import { getLatestRelayStatusMessage } from './utils/getLatestRelayStatusMessage.js';
-import { notifyTransactionIndexing } from './utils/notifyTransactionIndexing.js';
-import { relayService } from './utils/relayService.js';
-// Keep track of the trades we already notified the relay indexer about
-const txIndexingMap = new Map();
-export const relayApi = {
-    getTradeQuote: (input, deps) => getTradeQuote(input, deps, chainIdToRelayChainId),
-    getTradeRate: (input, deps) => getTradeRate(input, deps, chainIdToRelayChainId),
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { relayTransactionMetadata, sellAsset } = step;
-        if (!relayTransactionMetadata)
-            throw Error('Missing relay transaction metadata');
-        const { to, value, data } = relayTransactionMetadata;
-        if (to === undefined || value === undefined || data === undefined) {
-            const undefinedRequiredValues = [to, value, data].filter(value => value === undefined);
-            throw Error('undefined required values in transactionRequest', {
-                cause: {
-                    undefinedRequiredValues,
-                },
-            });
-        }
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        return feeData.networkFeeCryptoBaseUnit;
-    },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, relayTransactionMetadata, sellAsset } = step;
-        if (!relayTransactionMetadata)
-            throw Error('Transaction metadata is required');
-        const { to, value, data, gasLimit: gasLimitFromApi } = relayTransactionMetadata;
-        if (to === undefined || value === undefined || data === undefined) {
-            const undefinedRequiredValues = [to, value, data].filter(value => value === undefined);
-            throw Error('undefined required values in swap step', {
-                cause: {
-                    undefinedRequiredValues,
-                },
-            });
-        }
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        const unsignedTx = await adapter.buildCustomApiTx({
-            accountNumber,
-            data,
-            from,
-            to,
-            value,
-            ...feeData,
-            // Use the higher amount of the node or the API, as the node doesn't always provide enough gas padding for total gas used.
-            gasLimit: BigNumber.max(gasLimitFromApi ?? '0', feeData.gasLimit).toFixed(),
-        });
-        return unsignedTx;
-    },
-    getUnsignedUtxoTransaction: async ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, relayTransactionMetadata } = step;
-        if (!relayTransactionMetadata)
-            throw new Error('Missing relay transaction metadata');
-        const { to, opReturnData } = relayTransactionMetadata;
-        if (!to)
-            throw new Error('Missing transaction destination');
-        if (!opReturnData)
-            throw new Error('Missing opReturnData');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: { pubkey: xpub, opReturnData },
-            sendMax: false,
-        });
-        return assertGetUtxoChainAdapter(sellAsset.chainId).buildSendApiTransaction({
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            xpub,
-            to,
-            accountNumber,
-            chainSpecific: {
-                accountType,
-                opReturnData,
-                satoshiPerByte: fast.chainSpecific.satoshiPerByte,
-            },
-        });
-    },
-    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { sellAsset, relayTransactionMetadata } = step;
-        if (!relayTransactionMetadata?.psbt)
-            throw new Error('Missing psbt');
-        const { to, opReturnData } = relayTransactionMetadata;
-        if (!to)
-            throw new Error('Missing transaction destination');
-        if (!opReturnData)
-            throw new Error('Missing opReturnData');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: { pubkey: xpub, opReturnData },
-            sendMax: false,
-        });
-        return fast.txFee;
-    },
-    getSolanaTransactionFees,
-    getUnsignedSolanaTransaction,
-    checkTradeStatus: async ({ swap, txHash, chainId, address, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
-        const maybeSafeTransactionStatus = await checkSafeTransactionStatus({
-            txHash,
-            chainId,
-            assertGetEvmChainAdapter,
-            address,
-            fetchIsSmartContractAddressQuery,
-        });
-        if (!swap?.metadata.relayTransactionMetadata)
-            throw new Error('Missing swap metadata');
-        if (maybeSafeTransactionStatus) {
-            // return any safe transaction status that has not yet executed on chain (no buyTxHash)
-            if (!maybeSafeTransactionStatus.buyTxHash)
-                return maybeSafeTransactionStatus;
-            // The safe buyTxHash is the on chain transaction hash (not the safe transaction hash).
-            // Mutate txHash and continue with regular status check flow.
-            txHash = maybeSafeTransactionStatus.buyTxHash;
-        }
-        if (swap.metadata.relayTransactionMetadata &&
-            !txIndexingMap.has(swap.id) &&
-            isEvmChainId(chainId)) {
-            const relayTxParam = {
-                ...swap.metadata.relayTransactionMetadata,
-                txHash,
-            };
-            // We don't need to handle the response here, we just want to notify the relay indexer
-            await notifyTransactionIndexing({
-                requestId: swap.metadata.relayTransactionMetadata.relayId,
-                chainId: chainIdToRelayChainId[chainId].toString(),
-                tx: JSON.stringify(relayTxParam),
-            }, config);
-            txIndexingMap.set(swap.id, true);
-        }
-        const maybeStatusResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v2?requestId=${swap.metadata.relayTransactionMetadata.relayId}`);
-        if (maybeStatusResponse.isErr()) {
-            return {
-                buyTxHash: undefined,
-                status: TxStatus.Unknown,
-                message: undefined,
-            };
-        }
-        const { data: statusResponse } = maybeStatusResponse.unwrap();
-        const status = (() => {
-            switch (statusResponse.status) {
-                case 'success':
-                    return TxStatus.Confirmed;
-                case 'pending':
-                    return TxStatus.Pending;
-                case 'failed':
-                case 'refund':
-                    return TxStatus.Failed;
-                default:
-                    return TxStatus.Unknown;
-            }
-        })();
-        // Relay refers to in Txs as "inTxHashes" but to out Txs as simply "txHashes" when they really mean "outTxHashes"
-        // One thing to note is that for same-chain Txs, there is no "out Tx" per se since the in Tx *is* the out Tx
-        const outTxHashes = statusResponse.txHashes;
-        const isSameChainSwap = statusResponse.destinationChainId === statusResponse.originChainId;
-        const buyTxHash = isSameChainSwap ? txHash : outTxHashes?.[0];
-        return {
-            status,
-            buyTxHash,
-            message: getLatestRelayStatusMessage(statusResponse),
-        };
-    },
-};

package/dist/esm/swappers/RelaySwapper/getTradeQuote/getTradeQuote.d.ts

@@ -1,4 +0,0 @@
-import type { Result } from '@sniptt/monads';
-import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
-import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant.js';
-export declare const getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps, relayChainMap: typeof relayChainMapImplementation) => Promise<Result<TradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/RelaySwapper/getTradeQuote/getTradeQuote.js

@@ -1,28 +0,0 @@
-import { Err } from '@sniptt/monads';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { getTrade } from '../utils/getTrade.js';
-export const getTradeQuote = async (input, deps, relayChainMap) => {
-    if (!input.sendAddress) {
-        return Err(makeSwapErrorRight({
-            message: 'sendAddress is required',
-        }));
-    }
-    if (!input.receiveAddress) {
-        return Err(makeSwapErrorRight({
-            message: 'receiveAddress is required',
-        }));
-    }
-    const args = {
-        buyAsset: input.buyAsset,
-        receiveAddress: input.receiveAddress,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        sellAsset: input.sellAsset,
-        sendAddress: input.sendAddress,
-        quoteOrRate: 'quote',
-        accountNumber: input.accountNumber,
-        affiliateBps: input.affiliateBps,
-        xpub: 'xpub' in input ? input.xpub : undefined,
-    };
-    const quotesResult = await getTrade({ input: args, deps, relayChainMap });
-    return quotesResult;
-};

package/dist/esm/swappers/RelaySwapper/getTradeRate/getTradeRate.d.ts

@@ -1,4 +0,0 @@
-import type { ChainId } from '@shapeshiftoss/caip';
-import type { Result } from '@sniptt/monads';
-import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
-export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps, relayChainMap: Record<ChainId, number>) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/RelaySwapper/getTradeRate/getTradeRate.js

@@ -1,16 +0,0 @@
-import { getTrade } from '../utils/getTrade.js';
-export const getTradeRate = async (input, deps, relayChainMap) => {
-    const args = {
-        quoteOrRate: 'rate',
-        buyAsset: input.buyAsset,
-        receiveAddress: input.receiveAddress,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        sellAsset: input.sellAsset,
-        sendAddress: input.sendAddress,
-        accountNumber: input.accountNumber,
-        affiliateBps: input.affiliateBps,
-        xpub: 'xpub' in input ? input.xpub : undefined,
-    };
-    const ratesResult = await getTrade({ input: args, deps, relayChainMap });
-    return ratesResult;
-};

package/dist/esm/swappers/RelaySwapper/index.d.ts

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

package/dist/esm/swappers/RelaySwapper/index.js

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

package/dist/esm/swappers/RelaySwapper/utils/fetchRelayTrade.d.ts

@@ -1,5 +0,0 @@
-import type { Result } from '@sniptt/monads';
-import type { AxiosResponse } from 'axios';
-import type { SwapErrorRight, SwapperConfig } from '../../../types.js';
-import type { RelayFetchQuoteParams, RelayQuote } from './types.js';
-export declare const fetchRelayTrade: <T extends "rate" | "quote">(params: RelayFetchQuoteParams<T>, config: SwapperConfig) => Promise<Result<AxiosResponse<RelayQuote, any>, SwapErrorRight>>;

package/dist/esm/swappers/RelaySwapper/utils/fetchRelayTrade.js

@@ -1,4 +0,0 @@
-import { relayService } from './relayService.js';
-export const fetchRelayTrade = async (params, config) => {
-    return await relayService.post(`${config.VITE_RELAY_API_URL}/quote`, params);
-};

package/dist/esm/swappers/RelaySwapper/utils/getLatestRelayStatusMessage.d.ts

@@ -1,2 +0,0 @@
-import type { RelayStatus } from './types.js';
-export declare const getLatestRelayStatusMessage: (status: RelayStatus) => string;

package/dist/esm/swappers/RelaySwapper/utils/getLatestRelayStatusMessage.js

@@ -1,18 +0,0 @@
-import { RelayStatusMessage } from '../constant.js';
-export const getLatestRelayStatusMessage = (status) => {
-    const { status: statusValue } = status;
-    switch (true) {
-        case statusValue === 'waiting':
-            return RelayStatusMessage.WaitingForDeposit;
-        case statusValue === 'delayed':
-            return RelayStatusMessage.Retrying;
-        case statusValue === 'pending':
-            return RelayStatusMessage.DepositDetected;
-        case statusValue === 'success':
-            return RelayStatusMessage.SwapComplete;
-        case statusValue === 'failed':
-            return RelayStatusMessage.SwapFailed;
-        default:
-            return 'Unknown status';
-    }
-};

package/dist/esm/swappers/RelaySwapper/utils/getRelayAssetAddress.d.ts

@@ -1,3 +0,0 @@
-import type { Asset } from '@shapeshiftoss/types';
-import type { Address } from 'viem';
-export declare const getRelayAssetAddress: (asset: Asset) => Address;

package/dist/esm/swappers/RelaySwapper/utils/getRelayAssetAddress.js

@@ -1,15 +0,0 @@
-import { btcAssetId, fromAssetId, isAssetReference, solAssetId } from '@shapeshiftoss/caip';
-import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
-import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, } from '../constant.js';
-export const getRelayAssetAddress = (asset) => {
-    if (asset.assetId === btcAssetId)
-        return RELAY_BTC_TOKEN_ADDRESS;
-    if (asset.assetId === solAssetId)
-        return RELAY_SOLANA_TOKEN_ADDRESS;
-    if (isNativeEvmAsset(asset.assetId))
-        return DEFAULT_RELAY_EVM_TOKEN_ADDRESS;
-    const { assetReference } = fromAssetId(asset.assetId);
-    return isAssetReference(assetReference)
-        ? DEFAULT_RELAY_EVM_TOKEN_ADDRESS
-        : assetReference;
-};

package/dist/esm/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.d.ts

@@ -1,2 +0,0 @@
-import type { ChainId } from '@shapeshiftoss/caip';
-export declare const getRelayDefaultUserAddress: (chainId: ChainId) => "0x000000000000000000000000000000000000dead" | "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa" | "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";

package/dist/esm/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.js

@@ -1,12 +0,0 @@
-import { btcChainId, solanaChainId } from '@shapeshiftoss/caip';
-import { DEFAULT_RELAY_BTC_USER_ADDRESS, DEFAULT_RELAY_EVM_USER_ADDRESS, DEFAULT_RELAY_SOLANA_USER_ADDRESS, } from '../constant.js';
-export const getRelayDefaultUserAddress = (chainId) => {
-    switch (chainId) {
-        case btcChainId:
-            return DEFAULT_RELAY_BTC_USER_ADDRESS;
-        case solanaChainId:
-            return DEFAULT_RELAY_SOLANA_USER_ADDRESS;
-        default:
-            return DEFAULT_RELAY_EVM_USER_ADDRESS;
-    }
-};

package/dist/esm/swappers/RelaySwapper/utils/getRelayPsbtRelayer.d.ts

@@ -1 +0,0 @@
-export declare const getRelayPsbtRelayer: (psbtHex: string, sellAmountCryptoBaseUnit: string) => string | undefined;

package/dist/esm/swappers/RelaySwapper/utils/getRelayPsbtRelayer.js

@@ -1,20 +0,0 @@
-import * as bitcoin from '@shapeshiftoss/bitcoinjs-lib';
-export const getRelayPsbtRelayer = (psbtHex, sellAmountCryptoBaseUnit) => {
-    const psbtBuffer = Buffer.from(psbtHex, 'hex');
-    const psbt = bitcoin.Psbt.fromBuffer(psbtBuffer);
-    const outputs = psbt.txOutputs;
-    for (let i = 0; i < outputs.length; i++) {
-        const output = outputs[i];
-        const script = output.script;
-        try {
-            const address = bitcoin.address.fromOutputScript(script);
-            // Assuming the destination address is the one with the exact amount of sellAmountCryptoBaseUnit
-            if (output.value === Number(sellAmountCryptoBaseUnit)) {
-                return address;
-            }
-        }
-        catch (e) {
-            console.error(`Could not extract address from output ${i}:`, e);
-        }
-    }
-};

package/dist/esm/swappers/RelaySwapper/utils/getTrade.d.ts

@@ -1,14 +0,0 @@
-import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types.js';
-import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant.js';
-import type { RelayTradeInputParams } from '../utils/types.js';
-export declare function getTrade(args: {
-    input: RelayTradeInputParams<'quote'>;
-    deps: SwapperDeps;
-    relayChainMap: typeof relayChainMapImplementation;
-}): Promise<Result<TradeQuote[], SwapErrorRight>>;
-export declare function getTrade(args: {
-    input: RelayTradeInputParams<'rate'>;
-    deps: SwapperDeps;
-    relayChainMap: typeof relayChainMapImplementation;
-}): Promise<Result<TradeRate[], SwapErrorRight>>;