@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -1,8 +1,75 @@
-import { arbitrumChainId, avalancheChainId, baseChainId, binanceChainId, ethChainId, gnosisChainId, optimismChainId, polygonChainId, } from '@shapeshiftoss/caip';
+import { arbitrumChainId, avalancheChainId, baseChainId, binanceChainId, ethChainId, fromAssetId, hyperEvmChainId, optimismChainId, plasmaChainId, polygonChainId, sonicChainId, } from '@shapeshiftoss/caip';
+import { bnOrZero, convertBasisPointsToDecimalPercentage } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { zeroAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { chainIdToPortalsNetwork } from '../constants.js';
 import { PortalsSupportedChainIds } from '../types.js';
 export const isSupportedChainId = (chainId) => {
     return PortalsSupportedChainIds.includes(chainId);
 };
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (!isSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!isSupportedChainId(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    return Ok({ sellChainId: sellAsset.chainId, buyChainId: buyAsset.chainId });
+};
+// Builds the `network:address` token pair Portals expects, native assets mapped to the zero address
+export const getPortalsTokens = ({ sellAsset, buyAsset, }) => {
+    const sellPortalsNetwork = chainIdToPortalsNetwork[sellAsset.chainId];
+    const buyPortalsNetwork = chainIdToPortalsNetwork[buyAsset.chainId];
+    if (!sellPortalsNetwork) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!buyPortalsNetwork) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
+        ? zeroAddress
+        : fromAssetId(sellAsset.assetId).assetReference;
+    const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
+        ? zeroAddress
+        : fromAssetId(buyAsset.assetId).assetReference;
+    return Ok({
+        inputToken: `${sellPortalsNetwork}:${sellAssetAddress}`,
+        outputToken: `${buyPortalsNetwork}:${buyAssetAddress}`,
+    });
+};
+// Portals expects whole percentages (e.g. 1 for 1%), not bps or decimals
+export const getPortalsPercentages = ({ affiliateBps, slippageTolerancePercentageDecimal, }) => {
+    const affiliateBpsPercentage = convertBasisPointsToDecimalPercentage(affiliateBps)
+        .times(100)
+        .toNumber();
+    const slippageTolerancePercentage = slippageTolerancePercentageDecimal
+        ? bnOrZero(slippageTolerancePercentageDecimal).times(100).toNumber()
+        : bnOrZero(getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Portals))
+            .times(100)
+            .toNumber();
+    return { affiliateBpsPercentage, slippageTolerancePercentage };
+};
+// The same-chain Portals router; undefined for supported chains without a known router (cross-chain uses the route target instead)
 export const getPortalsRouterAddressByChainId = (chainId) => {
     switch (chainId) {
         case polygonChainId:
@@ -18,10 +85,12 @@ export const getPortalsRouterAddressByChainId = (chainId) => {
         case arbitrumChainId:
             return '0x34b6a821d2f26c6b7cdb01cd91895170c6574a0d';
         case baseChainId:
+        case sonicChainId:
+        case plasmaChainId:
             return '0xb0324286b3ef7dddc93fb2ff7c8b7b8a3524803c';
-        case gnosisChainId:
-            return '0x8e74454b2cf2f6cc2a06083ef122187551cf391c';
+        case hyperEvmChainId:
+            return '0x2db3b92918ece265c7d5d9d975c69d89b8b1136c';
         default:
-            throw new Error(`Router address not found for chainId: ${chainId}`);
+            return undefined;
     }
 };

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

@@ -1,4 +1,4 @@
-import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils.js';
+import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils/index.js';
 export * from './utils/relayTokenToAssetId.js';
 export const relaySwapper = {
     executeEvmTransaction,

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

@@ -1,7 +1,7 @@
-import { abstractChainId, arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, blastChainId, bobChainId, bscChainId, btcChainId, celoChainId, cronosChainId, ethChainId, etherealChainId, flowEvmChainId, gnosisChainId, hemiChainId, hyperEvmChainId, inkChainId, katanaChainId, lineaChainId, mantleChainId, megaethChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, plumeChainId, polygonChainId, scrollChainId, seiChainId, solanaChainId, soneiumChainId, sonicChainId, storyChainId, tronChainId, unichainChainId, worldChainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
+import { abstractChainId, arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, blastChainId, bobChainId, bscChainId, btcChainId, celoChainId, cronosChainId, ethChainId, etherealChainId, flowEvmChainId, gnosisChainId, hemiChainId, hyperEvmChainId, inkChainId, katanaChainId, lineaChainId, mantleChainId, megaethChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, plumeChainId, polygonChainId, robinhoodChainId, scrollChainId, seiChainId, solanaChainId, soneiumChainId, sonicChainId, storyChainId, tronChainId, unichainChainId, worldChainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
 import invert from 'lodash/invert';
 import { zeroAddress } from 'viem';
-import { arbitrum, avalanche, base, berachain, blast, bob, bsc, celo, cronos, flowMainnet, gnosis, hemi, hyperEvm, ink, katana, linea, mainnet as ethereum, mantle, mode, monad, optimism, plasma, plumeMainnet, polygon, scroll, sei, soneium, sonic, story, unichain, worldchain, zksync, } from 'viem/chains';
+import { abstract, arbitrum, avalanche, base, berachain, blast, bob, bsc, celo, cronos, flowMainnet, gnosis, hemi, hyperEvm, ink, katana, linea, mainnet as ethereum, mantle, megaeth, mode, monad, optimism, plasma, plumeMainnet, polygon, robinhood, scroll, sei, soneium, sonic, story, tron, unichain, worldchain, zksync, } from 'viem/chains';
 import { TradeQuoteError } from '../../types.js';
 import { RelayErrorCode } from './utils/types.js';
 // https://docs.relay.link/resources/supported-chains
@@ -16,12 +16,12 @@ export const chainIdToRelayChainId = {
     [gnosisChainId]: gnosis.id,
     [avalancheChainId]: avalanche.id,
     [bscChainId]: bsc.id,
-    [tronChainId]: 728126428,
+    [tronChainId]: tron.id,
     [monadChainId]: monad.id,
     [hyperEvmChainId]: hyperEvm.id,
     [mantleChainId]: mantle.id,
     [inkChainId]: ink.id,
-    [megaethChainId]: 4326,
+    [megaethChainId]: megaeth.id,
     [plasmaChainId]: plasma.id,
     [katanaChainId]: katana.id,
     [etherealChainId]: 5064014,
@@ -43,7 +43,8 @@ export const chainIdToRelayChainId = {
     [modeChainId]: mode.id,
     [soneiumChainId]: soneium.id,
     [seiChainId]: sei.id,
-    [abstractChainId]: 2741,
+    [abstractChainId]: abstract.id,
+    [robinhoodChainId]: robinhood.id,
 };
 export var RelayStatusMessage;
 (function (RelayStatusMessage) {

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

@@ -1,124 +1,29 @@
-import { evm } 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 { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
-import { getUnsignedTronTransaction } from '../../tron-utils/getUnsignedTronTransaction.js';
-import { checkSafeTransactionStatus, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { checkSafeTransactionStatus, getSwapMetadata } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getSolanaTransactionFees } from '../../utils/solana/getSolanaTransactionFees.js';
+import { getUnsignedSolanaTransaction } from '../../utils/solana/getUnsignedSolanaTransaction.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
+import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.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';
+import { getRelayRequestConfig, 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;
+    getTradeQuote: (input, deps) => {
+        return getTradeQuote(input, deps, chainIdToRelayChainId);
     },
-    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;
+    getTradeRate: (input, deps) => {
+        return getTradeRate(input, deps, chainIdToRelayChainId);
     },
+    getEvmTransactionFees,
+    getUnsignedEvmTransaction,
+    getUnsignedUtxoTransaction,
+    getUtxoTransactionFees,
     getSolanaTransactionFees,
     getUnsignedSolanaTransaction,
     getTronTransactionFees,
@@ -131,8 +36,9 @@ export const relayApi = {
             address,
             fetchIsSmartContractAddressQuery,
         });
-        if (!swap?.metadata.relayTransactionMetadata)
-            throw new Error('Missing swap metadata');
+        if (!swap)
+            throw new Error('Missing swap');
+        const relayMetadata = getSwapMetadata(swap.metadata.swapperMetadata, 'relay');
         if (maybeSafeTransactionStatus) {
             // return any safe transaction status that has not yet executed on chain (no buyTxHash)
             if (!maybeSafeTransactionStatus.buyTxHash)
@@ -141,26 +47,27 @@ export const relayApi = {
             // Mutate txHash and continue with regular status check flow.
             txHash = maybeSafeTransactionStatus.buyTxHash;
         }
-        if (swap.metadata.relayTransactionMetadata &&
+        if (relayMetadata &&
             !txIndexingMap.has(swap.id) &&
             chainIdToRelayChainId[chainId] !== undefined) {
-            const relayTxParam = {
-                ...swap.metadata.relayTransactionMetadata,
-                txHash,
-            };
-            // We don't need to handle the response here, we just want to notify the relay indexer
+            // relay's /transactions/single indexer `tx` param is the EVM calldata (see spec)
             await notifyTransactionIndexing({
-                requestId: swap.metadata.relayTransactionMetadata.relayId,
+                requestId: relayMetadata.relayId,
                 chainId: chainIdToRelayChainId[chainId].toString(),
-                tx: JSON.stringify(relayTxParam),
+                tx: relayMetadata.data ?? '',
             }, config);
             txIndexingMap.set(swap.id, true);
         }
-        const maybeStatusResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v2?requestId=${swap.metadata.relayTransactionMetadata.relayId}`);
+        // relay.link tracks the swap by its origin chain transaction
+        const swapperTxId = txHash;
+        const swapperTxLink = `https://relay.link/transaction/${txHash}`;
+        const maybeStatusResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v3?requestId=${relayMetadata.relayId}`, getRelayRequestConfig(config));
         if (maybeStatusResponse.isErr()) {
             return {
                 buyTxHash: undefined,
                 status: TxStatus.Unknown,
+                swapperTxId,
+                swapperTxLink,
                 message: undefined,
             };
         }
@@ -169,9 +76,13 @@ export const relayApi = {
             switch (statusResponse.status) {
                 case 'success':
                     return TxStatus.Confirmed;
+                case 'waiting':
+                case 'delayed':
                 case 'pending':
+                case 'depositing':
+                case 'submitted':
                     return TxStatus.Pending;
-                case 'failed':
+                case 'failure':
                 case 'refund':
                     return TxStatus.Failed;
                 default:
@@ -186,6 +97,8 @@ export const relayApi = {
         return {
             status,
             buyTxHash,
+            swapperTxId,
+            swapperTxLink,
             message: getLatestRelayStatusMessage(statusResponse),
         };
     },

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

@@ -1,4 +1,5 @@
 import type { Result } from '@sniptt/monads';
-import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { 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>>;
+import type { RelayTradeQuoteInput } from '../utils/types.js';
+export declare const getTradeQuote: (input: RelayTradeQuoteInput, deps: SwapperDeps, relayChainMap: typeof relayChainMapImplementation) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -1,28 +1,51 @@
-import { Err } from '@sniptt/monads';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { getTrade } from '../utils/getTrade.js';
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
+import { getRelayStepData } from '../utils/getRelayStepData.js';
+import { getRelayTradeContext } from '../utils/getRelayTradeContext.js';
 export const getTradeQuote = async (input, deps, relayChainMap) => {
-    if (!input.sendAddress) {
-        return Err(makeSwapErrorRight({
-            message: 'sendAddress is required',
+    const { accountNumber } = input;
+    const addresses = assertQuoteAddresses(input);
+    if (addresses.isErr())
+        return Err(addresses.unwrapErr());
+    const { receiveAddress } = addresses.unwrap();
+    const maybeContext = await getRelayTradeContext({ input, deps, relayChainMap });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, relayStepInputs, stepDataArgs, relayId } = maybeContext.unwrap();
+    const stepResults = await Promise.all(relayStepInputs.map(async ({ data, allowanceContract }) => {
+        const maybeStepData = await getRelayStepData({
+            ...stepDataArgs,
+            data,
+            spenderAddress: allowanceContract,
+            type: 'quote',
+            input,
+        });
+        return maybeStepData.map(({ transactionData, relayTransactionMetadata, networkFeeCryptoBaseUnit, }) => ({
+            ...stepCommon,
+            accountNumber,
+            allowanceContract,
+            transactionData,
+            relayTransactionMetadata,
+            swapperMetadata: {
+                name: 'relay',
+                relayId,
+                data: transactionData?.type === 'evm' ? transactionData.data : undefined,
+            },
+            feeData: { networkFeeCryptoBaseUnit, protocolFees },
         }));
+    }));
+    for (const stepResult of stepResults) {
+        if (stepResult.isErr())
+            return Err(stepResult.unwrapErr());
     }
-    if (!input.receiveAddress) {
-        return Err(makeSwapErrorRight({
-            message: 'receiveAddress is required',
-        }));
-    }
-    const args = {
-        buyAsset: input.buyAsset,
-        receiveAddress: input.receiveAddress,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        sellAsset: input.sellAsset,
-        sendAddress: input.sendAddress,
+    const steps = stepResults.map(stepResult => stepResult.unwrap());
+    const tradeQuote = {
+        ...tradeCommon,
         quoteOrRate: 'quote',
-        accountNumber: input.accountNumber,
-        affiliateBps: input.affiliateBps,
-        xpub: 'xpub' in input ? input.xpub : undefined,
+        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        receiveAddress,
+        steps,
     };
-    const quotesResult = await getTrade({ input: args, deps, relayChainMap });
-    return quotesResult;
+    return Ok([tradeQuote]);
 };

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

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

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

@@ -1,16 +1,38 @@
-import { getTrade } from '../utils/getTrade.js';
+import { Err, Ok } from '@sniptt/monads';
+import { getRelayStepData } from '../utils/getRelayStepData.js';
+import { getRelayTradeContext } from '../utils/getRelayTradeContext.js';
 export const getTradeRate = async (input, deps, relayChainMap) => {
-    const args = {
+    const maybeContext = await getRelayTradeContext({ input, deps, relayChainMap });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { accountNumber } = input;
+    const { tradeCommon, stepCommon, protocolFees, relayStepInputs, stepDataArgs, relayId } = maybeContext.unwrap();
+    const stepResults = await Promise.all(relayStepInputs.map(async ({ data, allowanceContract }) => {
+        const maybeStepData = await getRelayStepData({
+            ...stepDataArgs,
+            data,
+            spenderAddress: allowanceContract,
+            type: 'rate',
+            input,
+        });
+        return maybeStepData.map(({ networkFeeCryptoBaseUnit }) => ({
+            ...stepCommon,
+            accountNumber,
+            allowanceContract,
+            swapperMetadata: { name: 'relay', relayId, data: undefined },
+            feeData: { networkFeeCryptoBaseUnit, protocolFees },
+        }));
+    }));
+    for (const stepResult of stepResults) {
+        if (stepResult.isErr())
+            return Err(stepResult.unwrapErr());
+    }
+    const steps = stepResults.map(stepResult => stepResult.unwrap());
+    const tradeRate = {
+        ...tradeCommon,
         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,
+        steps,
     };
-    const ratesResult = await getTrade({ input: args, deps, relayChainMap });
-    return ratesResult;
+    return Ok([tradeRate]);
 };

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

@@ -1 +1,2 @@
 export * from './RelaySwapper.js';
+export { relayApi } from './endpoints.js';

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

@@ -1 +1,2 @@
 export * from './RelaySwapper.js';
+export { relayApi } from './endpoints.js';

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

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

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

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

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

@@ -7,10 +7,12 @@ export const getLatestRelayStatusMessage = (status) => {
         case statusValue === 'delayed':
             return RelayStatusMessage.Retrying;
         case statusValue === 'pending':
+        case statusValue === 'depositing':
+        case statusValue === 'submitted':
             return RelayStatusMessage.DepositDetected;
         case statusValue === 'success':
             return RelayStatusMessage.SwapComplete;
-        case statusValue === 'failed':
+        case statusValue === 'failure':
             return RelayStatusMessage.SwapFailed;
         default:
             return 'Unknown status';

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

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

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

@@ -0,0 +1,31 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { SolanaComputeBudgetOptions } from '../../../utils/solana/index.js';
+import type { RelayQuoteItem, RelayTransactionMetadata } from './types.js';
+export declare const RELAY_SOLANA_COMPUTE_BUDGET: SolanaComputeBudgetOptions;
+type BaseArgs = {
+    data: RelayQuoteItem['data'];
+    sellAmountCryptoBaseUnit: string;
+    spenderAddress: string;
+    orderId: string | undefined;
+    xpub: string | undefined;
+    fallbackNetworkFeeCryptoBaseUnit: string;
+};
+type RelayRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type RelayQuoteStepData = {
+    transactionData?: TxBuildData;
+    relayTransactionMetadata?: RelayTransactionMetadata;
+    networkFeeCryptoBaseUnit: string;
+};
+export type GetRelayStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+export declare function getRelayStepData(args: Extract<GetRelayStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<RelayRateStepData, SwapErrorRight>>;
+export declare function getRelayStepData(args: Extract<GetRelayStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<RelayQuoteStepData, SwapErrorRight>>;
+export {};