@shapeshiftoss/swapper 17.6.3 → 17.6.4

package/dist/esm/swappers/PortalsSwapper/getPortalsTradeRate/getPortalsTradeRate.js

@@ -0,0 +1,142 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { bn, bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { zeroAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../index.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { chainIdToPortalsNetwork } from '../constants.js';
+import { fetchPortalsTradeEstimate } from '../utils/fetchPortalsTradeOrder.js';
+import { getPortalsRouterAddressByChainId, isSupportedChainId } from '../utils/helpers.js';
+export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfig) {
+    const { sellAsset, buyAsset, accountNumber, affiliateBps, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, } = input;
+    const adapter = assertGetEvmChainAdapter(chainId);
+    const sellAssetChainId = sellAsset.chainId;
+    const buyAssetChainId = buyAsset.chainId;
+    if (!isSupportedChainId(sellAssetChainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!isSupportedChainId(buyAssetChainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (sellAssetChainId !== buyAssetChainId) {
+        return Err(makeSwapErrorRight({
+            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.CrossChainNotSupported,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    try {
+        if (!isSupportedChainId(chainId))
+            throw new Error(`Unsupported chainId ${sellAsset.chainId}`);
+        const portalsNetwork = chainIdToPortalsNetwork[chainId];
+        if (!portalsNetwork) {
+            return Err(makeSwapErrorRight({
+                message: `unsupported ChainId`,
+                code: TradeQuoteError.UnsupportedChain,
+                details: { chainId: input.chainId },
+            }));
+        }
+        const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
+            ? zeroAddress
+            : fromAssetId(sellAsset.assetId).assetReference;
+        const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
+            ? zeroAddress
+            : fromAssetId(buyAsset.assetId).assetReference;
+        const inputToken = `${portalsNetwork}:${sellAssetAddress}`;
+        const outputToken = `${portalsNetwork}:${buyAssetAddress}`;
+        const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
+            ? bnOrZero(input.slippageTolerancePercentageDecimal).times(100).toNumber()
+            : bnOrZero(getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Portals))
+                .times(100)
+                .toNumber();
+        const quoteEstimateResponse = await fetchPortalsTradeEstimate({
+            inputToken,
+            outputToken,
+            inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+            swapperConfig,
+        });
+        // Estimate has no protocol fees, so after-fees = expected output amount
+        const buyAmountAfterFeesCryptoBaseUnit = quoteEstimateResponse.outputAmount;
+        // Use the quote estimate endpoint to get a quote without a wallet
+        const inputOutputRate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const allowanceContract = getPortalsRouterAddressByChainId(chainId);
+        // Don't use Portals' slippageTolerancePercentage field (it's a price indicator, not actual buffer)
+        // Instead, calculate the actual buffer Portals applied from the amounts
+        const actualBufferDecimal = bnOrZero(quoteEstimateResponse.outputAmount)
+            .minus(quoteEstimateResponse.minOutputAmount)
+            .div(quoteEstimateResponse.outputAmount)
+            .toString();
+        // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
+        const buyAmountBeforeSlippageCryptoBaseUnit = bnOrZero(quoteEstimateResponse.minOutputAmount)
+            .div(bn(1).minus(actualBufferDecimal))
+            .toFixed(0);
+        const slippageTolerancePercentageDecimal = actualBufferDecimal;
+        const gasLimit = quoteEstimateResponse.context.gasLimit;
+        const { average } = await adapter.getGasFeeData();
+        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
+            ...average,
+            supportsEIP1559: Boolean(input.supportsEIP1559),
+            gasLimit: gasLimit.toString(),
+        });
+        const tradeRate = {
+            id: uuid(),
+            quoteOrRate: 'rate',
+            accountNumber,
+            receiveAddress,
+            affiliateBps,
+            rate: inputOutputRate,
+            slippageTolerancePercentageDecimal,
+            swapperName: SwapperName.Portals,
+            steps: [
+                {
+                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
+                    estimatedExecutionTimeMs: 0,
+                    allowanceContract,
+                    accountNumber,
+                    rate: inputOutputRate,
+                    buyAsset,
+                    sellAsset,
+                    // Before slippage on the right vs. before fees on the left is not a mistake.
+                    // Portals will yield different `outputAmount` (expected out) on estimate vs. quote and is an upstream bug, so we can't use that
+                    // To circumvent that and not mislead users into very optimistic expected out in rate (not taking slippage into account) but pessimistic in rate in the end,
+                    // we simply add the slippage back to the min out, which yields values very close to the actual quote amounts (with a small upside on the quote, so users actually get a better quote
+                    // than what they've seen as a rate, which is much better than a *huge* downside on the quote)
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountBeforeSlippageCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: undefined, // We don't have protocol fees on Portals during the estimate step
+                    },
+                    source: SwapperName.Portals,
+                },
+            ],
+        };
+        return Ok(tradeRate);
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: 'failed to get Portals quote',
+            cause: err,
+            code: TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './constants.js';
+export * from './types.js';

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

@@ -0,0 +1,2 @@
+export * from './constants.js';
+export * from './types.js';

package/dist/esm/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/esm/swappers/PortalsSwapper/types.js

@@ -0,0 +1,12 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+// https://api.portals.fi/v1/networks
+export const PortalsSupportedChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.ArbitrumMainnet,
+    KnownChainIds.AvalancheMainnet,
+    KnownChainIds.PolygonMainnet,
+    KnownChainIds.BnbSmartChainMainnet,
+    KnownChainIds.OptimismMainnet,
+    KnownChainIds.GnosisMainnet,
+    KnownChainIds.BaseMainnet,
+];

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

@@ -0,0 +1,76 @@
+import type { Address } from 'viem';
+import type { SwapperConfig } from '../../../types.js';
+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/esm/swappers/PortalsSwapper/utils/fetchPortalsTradeOrder.js

@@ -0,0 +1,59 @@
+import axios from 'axios';
+export class PortalsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PortalsError';
+    }
+}
+export 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.get(url, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (axios.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;
+    }
+};
+export 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.get(url, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            throw new Error(`Failed to fetch Portals trade estimate: ${error.message}`);
+        }
+        throw error;
+    }
+};

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

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

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

@@ -0,0 +1,27 @@
+import { arbitrumChainId, avalancheChainId, baseChainId, binanceChainId, ethChainId, gnosisChainId, optimismChainId, polygonChainId, } from '@shapeshiftoss/caip';
+import { PortalsSupportedChainIds } from '../types.js';
+export const isSupportedChainId = (chainId) => {
+    return PortalsSupportedChainIds.includes(chainId);
+};
+export const getPortalsRouterAddressByChainId = (chainId) => {
+    switch (chainId) {
+        case polygonChainId:
+            return '0xC74063fdb47fe6dCE6d029A489BAb37b167Da57f';
+        case ethChainId:
+            return '0xbf5a7f3629fb325e2a8453d595ab103465f75e62';
+        case avalancheChainId:
+            return '0xbf5A7F3629fB325E2a8453D595AB103465F75E62';
+        case binanceChainId:
+            return '0x34b6a821d2f26c6b7cdb01cd91895170c6574a0d';
+        case optimismChainId:
+            return '0x43838f0c0d499f5c3101589f0f452b1fc7515178';
+        case arbitrumChainId:
+            return '0x34b6a821d2f26c6b7cdb01cd91895170c6574a0d';
+        case baseChainId:
+            return '0xb0324286b3ef7dddc93fb2ff7c8b7b8a3524803c';
+        case gnosisChainId:
+            return '0x8e74454b2cf2f6cc2a06083ef122187551cf391c';
+        default:
+            throw new Error(`Router address not found for chainId: ${chainId}`);
+    }
+};

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

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

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

@@ -0,0 +1,8 @@
+import { executeEvmTransaction, executeSolanaTransaction } from '../../utils.js';
+export const relaySwapper = {
+    executeEvmTransaction,
+    executeSolanaTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

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

@@ -0,0 +1,23 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { TradeQuoteError } from '../../types.js';
+import { RelayErrorCode } from './utils/types.js';
+export declare const relaySupportedChainIds: KnownChainIds[];
+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 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 MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
+export declare const relayErrorCodeToTradeQuoteError: Record<RelayErrorCode, TradeQuoteError>;

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

@@ -0,0 +1,70 @@
+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.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

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

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

@@ -0,0 +1,188 @@
+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

@@ -0,0 +1,4 @@
+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>>;