@shapeshiftoss/swapper 17.6.6 → 17.6.7

package/dist/cjs/swappers/PortalsSwapper/types.d.ts

@@ -0,0 +1,3 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const PortalsSupportedChainIds: KnownChainIds[];
+export type PortalsSupportedChainId = (typeof PortalsSupportedChainIds)[number];

package/dist/cjs/swappers/PortalsSwapper/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortalsSupportedChainIds = void 0;
+const types_1 = require("@shapeshiftoss/types");
+// https://api.portals.fi/v1/networks
+exports.PortalsSupportedChainIds = [
+    types_1.KnownChainIds.EthereumMainnet,
+    types_1.KnownChainIds.ArbitrumMainnet,
+    types_1.KnownChainIds.AvalancheMainnet,
+    types_1.KnownChainIds.PolygonMainnet,
+    types_1.KnownChainIds.BnbSmartChainMainnet,
+    types_1.KnownChainIds.OptimismMainnet,
+    types_1.KnownChainIds.GnosisMainnet,
+    types_1.KnownChainIds.BaseMainnet,
+];

package/dist/cjs/swappers/PortalsSwapper/utils/fetchPortalsTradeOrder.d.ts

@@ -0,0 +1,76 @@
+import type { Address } from 'viem';
+import type { SwapperConfig } from '../../../types';
+type PortalsTradeOrderParams = {
+    sender: string;
+    inputToken: string;
+    inputAmount: string;
+    outputToken: string;
+    partner: string;
+    feePercentage?: number;
+    validate: boolean;
+    swapperConfig: SwapperConfig;
+} & ({
+    slippageTolerancePercentage: number;
+    autoSlippage?: never;
+} | {
+    slippageTolerancePercentage?: never;
+    autoSlippage: true;
+});
+type PortalsTradeOrderEstimateParams = Omit<PortalsTradeOrderParams, 'partner' | 'validate' | 'sender'>;
+type PortalsTradeOrderResponse = {
+    context: {
+        orderId: string;
+        inputToken: string;
+        inputAmount: string;
+        inputAmountUsd: number;
+        outputToken: string;
+        outputAmount: string;
+        outputAmountUsd: number;
+        minOutputAmount: string;
+        minOutputAmountUsd: number;
+        slippageTolerancePercentage: number;
+        target: string;
+        partner: string;
+        sender: string;
+        recipient: string;
+        value: string;
+        route: string[];
+        routeHash: string;
+        steps: string[];
+        gasLimit?: string;
+        feeToken?: string;
+        feeAmount?: string;
+        feeAmountUsd?: number;
+    };
+    tx?: {
+        to: Address;
+        from: Address;
+        data: string;
+        value: string;
+        gasLimit: string;
+    };
+};
+type PortalsTradeOrderEstimateResponse = {
+    outputAmount: string;
+    minOutputAmount: string;
+    outputToken: string;
+    outputTokenDecimals: number;
+    context: {
+        slippageTolerancePercentage: number;
+        inputAmount: string;
+        inputAmountUsd: number;
+        inputToken: string;
+        outputToken: string;
+        outputAmount: string;
+        outputAmountUsd: number;
+        minOutputAmountUsd: number;
+        gasLimit: number;
+        sender?: string;
+    };
+};
+export declare class PortalsError extends Error {
+    constructor(message: string);
+}
+export declare const fetchPortalsTradeOrder: ({ sender, inputToken, inputAmount, outputToken, slippageTolerancePercentage, autoSlippage, partner, feePercentage, validate, swapperConfig, }: PortalsTradeOrderParams) => Promise<PortalsTradeOrderResponse>;
+export declare const fetchPortalsTradeEstimate: ({ inputToken, inputAmount, outputToken, slippageTolerancePercentage, swapperConfig, }: PortalsTradeOrderEstimateParams) => Promise<PortalsTradeOrderEstimateResponse>;
+export {};

package/dist/cjs/swappers/PortalsSwapper/utils/fetchPortalsTradeOrder.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPortalsTradeEstimate = exports.fetchPortalsTradeOrder = exports.PortalsError = void 0;
+const axios_1 = __importDefault(require("axios"));
+class PortalsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PortalsError';
+    }
+}
+exports.PortalsError = PortalsError;
+const fetchPortalsTradeOrder = async ({ sender, inputToken, inputAmount, outputToken, slippageTolerancePercentage, autoSlippage, partner, feePercentage, validate, swapperConfig, }) => {
+    const url = `${swapperConfig.VITE_PORTALS_BASE_URL}/v2/portal`;
+    const params = new URLSearchParams({
+        partner,
+        ...(sender ? { sender } : {}),
+        inputToken,
+        inputAmount,
+        outputToken,
+        validate: validate.toString(),
+    });
+    if (!autoSlippage) {
+        params.append('slippageTolerancePercentage', slippageTolerancePercentage.toFixed(2)); // Portals API expects a string with at most 2 decimal places
+    }
+    if (feePercentage) {
+        params.append('feePercentage', feePercentage.toString());
+    }
+    try {
+        const response = await axios_1.default.get(url, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error)) {
+            const message = error.response?.data?.message;
+            if (message) {
+                throw new PortalsError(message);
+            }
+            throw new Error(`Failed to fetch Portals trade order: ${error.message}`);
+        }
+        throw error;
+    }
+};
+exports.fetchPortalsTradeOrder = fetchPortalsTradeOrder;
+const fetchPortalsTradeEstimate = async ({ inputToken, inputAmount, outputToken, slippageTolerancePercentage, swapperConfig, }) => {
+    const url = `${swapperConfig.VITE_PORTALS_BASE_URL}/v2/portal/estimate`;
+    const params = new URLSearchParams({
+        inputToken,
+        inputAmount,
+        outputToken,
+    });
+    if (slippageTolerancePercentage !== undefined) {
+        params.append('slippageTolerancePercentage', slippageTolerancePercentage.toFixed(2)); // Portals API expects a string with at most 2 decimal places
+    }
+    try {
+        const response = await axios_1.default.get(url, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error)) {
+            throw new Error(`Failed to fetch Portals trade estimate: ${error.message}`);
+        }
+        throw error;
+    }
+};
+exports.fetchPortalsTradeEstimate = fetchPortalsTradeEstimate;

package/dist/cjs/swappers/PortalsSwapper/utils/helpers.d.ts

@@ -0,0 +1,4 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { PortalsSupportedChainId } from '../types';
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds;
+export declare const getPortalsRouterAddressByChainId: (chainId: PortalsSupportedChainId) => string;

package/dist/cjs/swappers/PortalsSwapper/utils/helpers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortalsRouterAddressByChainId = exports.isSupportedChainId = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("../types");
+const isSupportedChainId = (chainId) => {
+    return types_1.PortalsSupportedChainIds.includes(chainId);
+};
+exports.isSupportedChainId = isSupportedChainId;
+const getPortalsRouterAddressByChainId = (chainId) => {
+    switch (chainId) {
+        case caip_1.polygonChainId:
+            return '0xC74063fdb47fe6dCE6d029A489BAb37b167Da57f';
+        case caip_1.ethChainId:
+            return '0xbf5a7f3629fb325e2a8453d595ab103465f75e62';
+        case caip_1.avalancheChainId:
+            return '0xbf5A7F3629fB325E2a8453D595AB103465F75E62';
+        case caip_1.binanceChainId:
+            return '0x34b6a821d2f26c6b7cdb01cd91895170c6574a0d';
+        case caip_1.optimismChainId:
+            return '0x43838f0c0d499f5c3101589f0f452b1fc7515178';
+        case caip_1.arbitrumChainId:
+            return '0x34b6a821d2f26c6b7cdb01cd91895170c6574a0d';
+        case caip_1.baseChainId:
+            return '0xb0324286b3ef7dddc93fb2ff7c8b7b8a3524803c';
+        case caip_1.gnosisChainId:
+            return '0x8e74454b2cf2f6cc2a06083ef122187551cf391c';
+        default:
+            throw new Error(`Router address not found for chainId: ${chainId}`);
+    }
+};
+exports.getPortalsRouterAddressByChainId = getPortalsRouterAddressByChainId;

package/dist/cjs/swappers/RelaySwapper/RelaySwapper.d.ts

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

package/dist/cjs/swappers/RelaySwapper/RelaySwapper.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relaySwapper = void 0;
+const utils_1 = require("../../utils");
+exports.relaySwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+    executeSolanaTransaction: utils_1.executeSolanaTransaction,
+    executeTronTransaction: utils_1.executeTronTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/cjs/swappers/RelaySwapper/constant.d.ts

@@ -0,0 +1,23 @@
+import { TradeQuoteError } from '../../types';
+import { RelayErrorCode } from './utils/types';
+export declare const chainIdToRelayChainId: {
+    [x: string]: number;
+};
+export declare enum RelayStatusMessage {
+    WaitingForDeposit = "Waiting for deposit...",
+    DepositDetected = "Deposit detected, processing swap...",
+    Retrying = "Taking a bit longer than usual to find a route, hang tight...",
+    SwapComplete = "Swap complete",
+    SwapFailed = "Swap failed"
+}
+export declare const relayChainIdToChainId: import("lodash").Dictionary<string>;
+export declare const DEFAULT_RELAY_EVM_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
+export declare const RELAY_BTC_TOKEN_ADDRESS = "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8";
+export declare const RELAY_SOLANA_TOKEN_ADDRESS = "11111111111111111111111111111111";
+export declare const RELAY_TRON_TOKEN_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
+export declare const DEFAULT_RELAY_EVM_USER_ADDRESS = "0x000000000000000000000000000000000000dead";
+export declare const DEFAULT_RELAY_BTC_USER_ADDRESS = "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa";
+export declare const DEFAULT_RELAY_SOLANA_USER_ADDRESS = "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";
+export declare const DEFAULT_RELAY_TRON_USER_ADDRESS = "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";
+export declare const MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
+export declare const relayErrorCodeToTradeQuoteError: Record<RelayErrorCode, TradeQuoteError>;

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

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayErrorCodeToTradeQuoteError = exports.MAXIMUM_SUPPORTED_RELAY_STEPS = exports.DEFAULT_RELAY_TRON_USER_ADDRESS = exports.DEFAULT_RELAY_SOLANA_USER_ADDRESS = exports.DEFAULT_RELAY_BTC_USER_ADDRESS = exports.DEFAULT_RELAY_EVM_USER_ADDRESS = exports.RELAY_TRON_TOKEN_ADDRESS = exports.RELAY_SOLANA_TOKEN_ADDRESS = exports.RELAY_BTC_TOKEN_ADDRESS = exports.DEFAULT_RELAY_EVM_TOKEN_ADDRESS = exports.relayChainIdToChainId = exports.RelayStatusMessage = exports.chainIdToRelayChainId = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const invert_1 = __importDefault(require("lodash/invert"));
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const types_1 = require("../../types");
+const types_2 = require("./utils/types");
+exports.chainIdToRelayChainId = {
+    // https://docs.relay.link/resources/supported-chains
+    [caip_1.btcChainId]: 8253038,
+    [caip_1.ethChainId]: chains_1.mainnet.id,
+    [caip_1.arbitrumChainId]: chains_1.arbitrum.id,
+    [caip_1.baseChainId]: chains_1.base.id,
+    [caip_1.optimismChainId]: chains_1.optimism.id,
+    [caip_1.polygonChainId]: chains_1.polygon.id,
+    // https://docs.relay.link/resources/supported-chains
+    [caip_1.solanaChainId]: 792703809,
+    [caip_1.gnosisChainId]: chains_1.gnosis.id,
+    [caip_1.avalancheChainId]: chains_1.avalanche.id,
+    [caip_1.bscChainId]: chains_1.bsc.id,
+    [caip_1.tronChainId]: 728126428,
+    [caip_1.monadChainId]: chains_1.monad.id,
+};
+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 || (exports.RelayStatusMessage = RelayStatusMessage = {}));
+exports.relayChainIdToChainId = (0, invert_1.default)(exports.chainIdToRelayChainId);
+exports.DEFAULT_RELAY_EVM_TOKEN_ADDRESS = viem_1.zeroAddress;
+exports.RELAY_BTC_TOKEN_ADDRESS = 'bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8';
+exports.RELAY_SOLANA_TOKEN_ADDRESS = '11111111111111111111111111111111';
+exports.RELAY_TRON_TOKEN_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';
+exports.DEFAULT_RELAY_EVM_USER_ADDRESS = '0x000000000000000000000000000000000000dead';
+exports.DEFAULT_RELAY_BTC_USER_ADDRESS = 'bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa';
+exports.DEFAULT_RELAY_SOLANA_USER_ADDRESS = 'CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr';
+exports.DEFAULT_RELAY_TRON_USER_ADDRESS = 'TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy';
+exports.MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
+exports.relayErrorCodeToTradeQuoteError = {
+    [types_2.RelayErrorCode.AmountTooLow]: types_1.TradeQuoteError.SellAmountBelowMinimum,
+    [types_2.RelayErrorCode.ChainDisabled]: types_1.TradeQuoteError.TradingHalted,
+    [types_2.RelayErrorCode.Erc20RouterAddressNotFound]: types_1.TradeQuoteError.UnsupportedTradePair,
+    [types_2.RelayErrorCode.ExtraTransactionsNotSupported]: types_1.TradeQuoteError.UnsupportedTradePair,
+    [types_2.RelayErrorCode.InsufficientFunds]: types_1.TradeQuoteError.SellAmountBelowTradeFee,
+    [types_2.RelayErrorCode.InsufficientLiquidity]: types_1.TradeQuoteError.SellAmountBelowTradeFee,
+    [types_2.RelayErrorCode.InvalidAddress]: types_1.TradeQuoteError.UnsupportedTradePair,
+    [types_2.RelayErrorCode.InvalidExtraTransactions]: types_1.TradeQuoteError.UnsupportedTradePair,
+    [types_2.RelayErrorCode.NoQuotes]: types_1.TradeQuoteError.NoRouteFound,
+    [types_2.RelayErrorCode.NoSwapRoutesFound]: types_1.TradeQuoteError.NoRouteFound,
+    [types_2.RelayErrorCode.UnsupportedRoute]: types_1.TradeQuoteError.UnsupportedTradePair,
+    [types_2.RelayErrorCode.UnsupportedExecutionType]: types_1.TradeQuoteError.UnknownError,
+    [types_2.RelayErrorCode.UserRecipientMismatch]: types_1.TradeQuoteError.UnknownError,
+    [types_2.RelayErrorCode.PermitFailed]: types_1.TradeQuoteError.UnknownError,
+    [types_2.RelayErrorCode.SwapImpactTooHigh]: types_1.TradeQuoteError.UnknownError,
+    [types_2.RelayErrorCode.SwapQuoteFailed]: types_1.TradeQuoteError.UnknownError,
+    [types_2.RelayErrorCode.Unauthorized]: types_1.TradeQuoteError.UnknownError,
+    [types_2.RelayErrorCode.UnknownError]: types_1.TradeQuoteError.UnknownError,
+    [types_2.RelayErrorCode.UnsupportedChain]: types_1.TradeQuoteError.UnknownError,
+    [types_2.RelayErrorCode.UnsupportedCurrency]: types_1.TradeQuoteError.UnknownError,
+};

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

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

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

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayApi = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const getSolanaTransactionFees_1 = require("../../solana-utils/getSolanaTransactionFees");
+const getUnsignedSolanaTransaction_1 = require("../../solana-utils/getUnsignedSolanaTransaction");
+const getTronTransactionFees_1 = require("../../tron-utils/getTronTransactionFees");
+const getUnsignedTronTransaction_1 = require("../../tron-utils/getUnsignedTronTransaction");
+const utils_1 = require("../../utils");
+const constant_1 = require("./constant");
+const getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
+const getTradeRate_1 = require("./getTradeRate/getTradeRate");
+const getLatestRelayStatusMessage_1 = require("./utils/getLatestRelayStatusMessage");
+const notifyTransactionIndexing_1 = require("./utils/notifyTransactionIndexing");
+const relayService_1 = require("./utils/relayService");
+// Keep track of the trades we already notified the relay indexer about
+const txIndexingMap = new Map();
+exports.relayApi = {
+    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps, constant_1.chainIdToRelayChainId),
+    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps, constant_1.chainIdToRelayChainId),
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.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 chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.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 chain_adapters_1.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_js_1.default.max(gasLimitFromApi ?? '0', feeData.gasLimit).toFixed(),
+        });
+        return unsignedTx;
+    },
+    getUnsignedUtxoTransaction: async ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.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 (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.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: getSolanaTransactionFees_1.getSolanaTransactionFees,
+    getUnsignedSolanaTransaction: getUnsignedSolanaTransaction_1.getUnsignedSolanaTransaction,
+    getTronTransactionFees: getTronTransactionFees_1.getTronTransactionFees,
+    getUnsignedTronTransaction: getUnsignedTronTransaction_1.getUnsignedTronTransaction,
+    checkTradeStatus: async ({ swap, txHash, chainId, address, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
+        const maybeSafeTransactionStatus = await (0, utils_1.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) &&
+            (0, chain_adapters_1.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 (0, notifyTransactionIndexing_1.notifyTransactionIndexing)({
+                requestId: swap.metadata.relayTransactionMetadata.relayId,
+                chainId: constant_1.chainIdToRelayChainId[chainId].toString(),
+                tx: JSON.stringify(relayTxParam),
+            }, config);
+            txIndexingMap.set(swap.id, true);
+        }
+        const maybeStatusResponse = await relayService_1.relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v2?requestId=${swap.metadata.relayTransactionMetadata.relayId}`);
+        if (maybeStatusResponse.isErr()) {
+            return {
+                buyTxHash: undefined,
+                status: unchained_client_1.TxStatus.Unknown,
+                message: undefined,
+            };
+        }
+        const { data: statusResponse } = maybeStatusResponse.unwrap();
+        const status = (() => {
+            switch (statusResponse.status) {
+                case 'success':
+                    return unchained_client_1.TxStatus.Confirmed;
+                case 'pending':
+                    return unchained_client_1.TxStatus.Pending;
+                case 'failed':
+                case 'refund':
+                    return unchained_client_1.TxStatus.Failed;
+                default:
+                    return unchained_client_1.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: (0, getLatestRelayStatusMessage_1.getLatestRelayStatusMessage)(statusResponse),
+        };
+    },
+};

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = void 0;
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const getTrade_1 = require("../utils/getTrade");
+const getTradeQuote = async (input, deps, relayChainMap) => {
+    if (!input.sendAddress) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: 'sendAddress is required',
+        }));
+    }
+    if (!input.receiveAddress) {
+        return (0, monads_1.Err)((0, utils_1.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 (0, getTrade_1.getTrade)({ input: args, deps, relayChainMap });
+    return quotesResult;
+};
+exports.getTradeQuote = getTradeQuote;

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRate = void 0;
+const getTrade_1 = require("../utils/getTrade");
+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 (0, getTrade_1.getTrade)({ input: args, deps, relayChainMap });
+    return ratesResult;
+};
+exports.getTradeRate = getTradeRate;

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

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

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

@@ -0,0 +1,17 @@
+"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("./RelaySwapper"), exports);

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRelayTrade = void 0;
+const relayService_1 = require("./relayService");
+const fetchRelayTrade = async (params, config) => {
+    return await relayService_1.relayService.post(`${config.VITE_RELAY_API_URL}/quote`, params);
+};
+exports.fetchRelayTrade = fetchRelayTrade;

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestRelayStatusMessage = void 0;
+const constant_1 = require("../constant");
+const getLatestRelayStatusMessage = (status) => {
+    const { status: statusValue } = status;
+    switch (true) {
+        case statusValue === 'waiting':
+            return constant_1.RelayStatusMessage.WaitingForDeposit;
+        case statusValue === 'delayed':
+            return constant_1.RelayStatusMessage.Retrying;
+        case statusValue === 'pending':
+            return constant_1.RelayStatusMessage.DepositDetected;
+        case statusValue === 'success':
+            return constant_1.RelayStatusMessage.SwapComplete;
+        case statusValue === 'failed':
+            return constant_1.RelayStatusMessage.SwapFailed;
+        default:
+            return 'Unknown status';
+    }
+};
+exports.getLatestRelayStatusMessage = getLatestRelayStatusMessage;