@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,189 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { bn, bnOrZero, convertBasisPointsToDecimalPercentage } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getAddress, zeroAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../index.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { simulateWithStateOverrides } from '../../../utils/tenderly/index.js';
+import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { chainIdToPortalsNetwork } from '../constants.js';
+import { fetchPortalsTradeEstimate, fetchPortalsTradeOrder } 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, supportsEIP1559, } = 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 },
+        }));
+    }
+    const isCrossChain = sellAssetChainId !== buyAssetChainId;
+    try {
+        if (!isSupportedChainId(chainId))
+            throw new Error(`Unsupported chainId ${sellAsset.chainId}`);
+        const sellPortalsNetwork = chainIdToPortalsNetwork[sellAssetChainId];
+        const buyPortalsNetwork = chainIdToPortalsNetwork[buyAssetChainId];
+        if (!sellPortalsNetwork) {
+            return Err(makeSwapErrorRight({
+                message: `unsupported ChainId`,
+                code: TradeQuoteError.UnsupportedChain,
+                details: { chainId: sellAssetChainId },
+            }));
+        }
+        if (!buyPortalsNetwork) {
+            return Err(makeSwapErrorRight({
+                message: `unsupported ChainId`,
+                code: TradeQuoteError.UnsupportedChain,
+                details: { chainId: buyAssetChainId },
+            }));
+        }
+        const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
+            ? zeroAddress
+            : fromAssetId(sellAsset.assetId).assetReference;
+        const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
+            ? zeroAddress
+            : fromAssetId(buyAsset.assetId).assetReference;
+        const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
+        const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
+        const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
+            ? bnOrZero(input.slippageTolerancePercentageDecimal).times(100).toNumber()
+            : bnOrZero(getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Portals))
+                .times(100)
+                .toNumber();
+        // Calculate affiliate fee percentage (e.g., 55 bps = 0.55%)
+        const affiliateBpsPercentage = convertBasisPointsToDecimalPercentage(affiliateBps)
+            .times(100)
+            .toNumber();
+        // Dummy address for rates (no wallet connected yet)
+        // Using Vitalik's address as a realistic test address (same approach as Bebop)
+        const RATE_DUMMY_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+        // Use full quote endpoint (not estimate) to get transaction data for Tenderly simulation
+        // Skip validation since this is just a rate quote
+        const quoteResponse = await fetchPortalsTradeOrder({
+            sender: RATE_DUMMY_ADDRESS,
+            inputToken,
+            outputToken,
+            inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+            partner: getTreasuryAddressFromChainId(chainId),
+            feePercentage: affiliateBpsPercentage,
+            validate: false,
+            swapperConfig,
+        });
+        if (!quoteResponse.tx) {
+            throw new Error('Portals quote response missing transaction data');
+        }
+        const { context, tx } = quoteResponse;
+        const buyAmountAfterFeesCryptoBaseUnit = isCrossChain
+            ? context.minOutputAmount
+            : context.outputAmount;
+        const inputOutputRate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const allowanceContract = isCrossChain
+            ? context.target
+            : 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(context.outputAmount)
+            .minus(context.minOutputAmount)
+            .div(context.outputAmount)
+            .toString();
+        // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
+        const buyAmountBeforeSlippageCryptoBaseUnit = bnOrZero(context.minOutputAmount)
+            .div(bn(1).minus(actualBufferDecimal))
+            .toFixed(0);
+        const slippageTolerancePercentageDecimal = actualBufferDecimal;
+        const gasLimit = await (async () => {
+            const tenderlySimulation = await simulateWithStateOverrides({
+                chainId: sellAsset.chainId,
+                from: tx.from,
+                to: tx.to,
+                data: tx.data,
+                value: tx.value,
+                sellAsset,
+                spenderAddress: getAddress(context.target),
+            }, {
+                apiKey: swapperConfig.VITE_TENDERLY_API_KEY,
+                accountSlug: swapperConfig.VITE_TENDERLY_ACCOUNT_SLUG,
+                projectSlug: swapperConfig.VITE_TENDERLY_PROJECT_SLUG,
+            });
+            if (tenderlySimulation.success) {
+                return tenderlySimulation.gasLimit.toString();
+            }
+            // Fallback to estimate endpoint (i.e simulation with overrides failed, but Portals still able to do their magic here)
+            const quoteEstimateResponse = await fetchPortalsTradeEstimate({
+                inputToken,
+                outputToken,
+                inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+                swapperConfig,
+            });
+            return quoteEstimateResponse.context.gasLimit.toString();
+        })();
+        const { average } = await adapter.getGasFeeData();
+        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
+            ...average,
+            supportsEIP1559: Boolean(supportsEIP1559),
+            gasLimit,
+        });
+        const tradeRate = {
+            id: uuid(),
+            quoteOrRate: 'rate',
+            accountNumber,
+            receiveAddress,
+            affiliateBps,
+            rate: inputOutputRate,
+            slippageTolerancePercentageDecimal,
+            swapperName: SwapperName.Portals,
+            steps: [
+                {
+                    estimatedExecutionTimeMs: isCrossChain ? 300000 : 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,13 @@
+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,
+    KnownChainIds.HyperEvmMainnet,
+];

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

@@ -0,0 +1,9 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+export type AxelarscanBridgeStatus = {
+    status: 'pending' | 'confirmed' | 'failed';
+    destinationTxHash?: string;
+    errorMessage?: string;
+};
+export declare const fetchAxelarscanBridgeStatus: (sourceTxHash: string) => Promise<Result<AxelarscanBridgeStatus | undefined, SwapErrorRight>>;
+export declare const getAxelarscanTrackingLink: (sourceTxHash: string) => string;

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

@@ -0,0 +1,47 @@
+import { Err, Ok } from '@sniptt/monads';
+import { makeSwapErrorRight } from '../../../utils.js';
+export const fetchAxelarscanBridgeStatus = async (sourceTxHash) => {
+    try {
+        const response = await fetch(`https://api.axelarscan.io/gmp/searchGMP?txHash=${sourceTxHash}`);
+        if (!response.ok) {
+            return Err(makeSwapErrorRight({
+                message: `Axelarscan API error: ${response.statusText}`,
+            }));
+        }
+        const data = await response.json();
+        if (!data.data || data.data.length === 0) {
+            return Ok(undefined);
+        }
+        const bridgeData = data.data[0];
+        const destinationTxHash = bridgeData.call?.transaction_hash ||
+            bridgeData.executed?.transaction_hash ||
+            bridgeData.express_executed?.transactionHash;
+        const isCompleted = bridgeData.status === 'executed' ||
+            bridgeData.status === 'destination_executed' ||
+            bridgeData.status === 'express_executed' ||
+            bridgeData.simplified_status === 'received' ||
+            !!destinationTxHash;
+        if (isCompleted) {
+            return Ok({
+                status: 'confirmed',
+                destinationTxHash,
+            });
+        }
+        if (bridgeData.status === 'error') {
+            return Ok({
+                status: 'failed',
+                errorMessage: bridgeData.error?.message || 'Bridge failed',
+            });
+        }
+        return Ok({
+            status: 'pending',
+        });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: 'Failed to fetch Axelarscan bridge status',
+            cause: error,
+        }));
+    }
+};
+export const getAxelarscanTrackingLink = (sourceTxHash) => `https://axelarscan.io/gmp/${sourceTxHash}`;

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

@@ -0,0 +1,77 @@
+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[];
+        expiry?: 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/fetchSquidStatus.d.ts

@@ -0,0 +1,9 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+export type SquidBridgeStatus = {
+    status: 'pending' | 'confirmed' | 'failed';
+    destinationTxHash?: string;
+};
+export declare const fetchSquidBridgeStatus: (sourceTxHash: string, sourceChainId: ChainId, destinationChainId: ChainId) => Promise<Result<SquidBridgeStatus, SwapErrorRight>>;
+export declare const getSquidTrackingLink: (sourceTxHash: string, squidStatus: SquidBridgeStatus, sellAssetExplorerTxLink: string, buyAssetExplorerTxLink: string) => string;

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

@@ -0,0 +1,52 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { makeSwapErrorRight } from '../../../utils.js';
+export const fetchSquidBridgeStatus = async (sourceTxHash, sourceChainId, destinationChainId) => {
+    try {
+        const fromChain = fromChainId(sourceChainId).chainReference;
+        const toChain = fromChainId(destinationChainId).chainReference;
+        const url = new URL('https://v2.api.squidrouter.com/v2/status');
+        url.searchParams.set('transactionId', sourceTxHash);
+        url.searchParams.set('fromChainId', fromChain);
+        url.searchParams.set('toChainId', toChain);
+        const response = await fetch(url.toString(), {
+            headers: {
+                'x-integrator-id': 'squid-swap-widget',
+            },
+        });
+        if (!response.ok) {
+            return Err(makeSwapErrorRight({
+                message: `Squid API error: ${response.statusText}`,
+            }));
+        }
+        const data = await response.json();
+        const destinationTxHash = data.toChain?.transactionId;
+        if (data.squidTransactionStatus === 'success') {
+            return Ok({
+                status: 'confirmed',
+                destinationTxHash,
+            });
+        }
+        if (data.squidTransactionStatus === 'partial_success' ||
+            data.squidTransactionStatus === 'needs_gas') {
+            return Ok({
+                status: 'failed',
+            });
+        }
+        return Ok({
+            status: 'pending',
+        });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: 'Failed to fetch Squid bridge status',
+            cause: error,
+        }));
+    }
+};
+export const getSquidTrackingLink = (sourceTxHash, squidStatus, sellAssetExplorerTxLink, buyAssetExplorerTxLink) => {
+    if (squidStatus.status === 'confirmed' && squidStatus.destinationTxHash) {
+        return `${buyAssetExplorerTxLink}${squidStatus.destinationTxHash}`;
+    }
+    return `${sellAssetExplorerTxLink}${sourceTxHash}`;
+};

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,9 @@
+import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils.js';
+export const relaySwapper = {
+    executeEvmTransaction,
+    executeSolanaTransaction,
+    executeTronTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

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

@@ -0,0 +1,23 @@
+import { TradeQuoteError } from '../../types.js';
+import { RelayErrorCode } from './utils/types.js';
+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/esm/swappers/RelaySwapper/constant.js

@@ -0,0 +1,65 @@
+import { arbitrumChainId, avalancheChainId, baseChainId, bscChainId, btcChainId, ethChainId, gnosisChainId, hyperEvmChainId, katanaChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
+import invert from 'lodash/invert';
+import { zeroAddress } from 'viem';
+import { arbitrum, avalanche, base, bsc, gnosis, hyperEvm, katana, mainnet as ethereum, monad, optimism, plasma, polygon, } from 'viem/chains';
+import { TradeQuoteError } from '../../types.js';
+import { RelayErrorCode } from './utils/types.js';
+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,
+    [tronChainId]: 728126428,
+    [monadChainId]: monad.id,
+    [hyperEvmChainId]: hyperEvm.id,
+    [plasmaChainId]: plasma.id,
+    [katanaChainId]: katana.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 RELAY_TRON_TOKEN_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';
+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 DEFAULT_RELAY_TRON_USER_ADDRESS = 'TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy';
+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

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