@shapeshiftoss/swapper 17.8.0 → 18.1.0

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

@@ -1,2 +1,4 @@
 export * from './constants';
 export * from './types';
+export { portalsApi } from './endpoints';
+export { portalsSwapper } from './PortalsSwapper';

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

@@ -14,5 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.portalsSwapper = exports.portalsApi = void 0;
 __exportStar(require("./constants"), exports);
 __exportStar(require("./types"), exports);
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "portalsApi", { enumerable: true, get: function () { return endpoints_1.portalsApi; } });
+var PortalsSwapper_1 = require("./PortalsSwapper");
+Object.defineProperty(exports, "portalsSwapper", { enumerable: true, get: function () { return PortalsSwapper_1.portalsSwapper; } });

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

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

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

@@ -10,7 +10,8 @@ exports.PortalsSupportedChainIds = [
     types_1.KnownChainIds.PolygonMainnet,
     types_1.KnownChainIds.BnbSmartChainMainnet,
     types_1.KnownChainIds.OptimismMainnet,
-    types_1.KnownChainIds.GnosisMainnet,
     types_1.KnownChainIds.BaseMainnet,
     types_1.KnownChainIds.HyperEvmMainnet,
+    types_1.KnownChainIds.SonicMainnet,
+    types_1.KnownChainIds.PlasmaMainnet,
 ];

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

@@ -17,7 +17,14 @@ type PortalsTradeOrderParams = {
     autoSlippage: true;
 });
 type PortalsTradeOrderEstimateParams = Omit<PortalsTradeOrderParams, 'partner' | 'validate' | 'sender'>;
-type PortalsTradeOrderResponse = {
+export type PortalsTx = {
+    to: Address;
+    from: Address;
+    data: string;
+    value: string;
+    gasLimit?: string;
+};
+export type PortalsTradeOrderResponse = {
     context: {
         orderId: string;
         inputToken: string;
@@ -43,13 +50,7 @@ type PortalsTradeOrderResponse = {
         feeAmount?: string;
         feeAmountUsd?: number;
     };
-    tx?: {
-        to: Address;
-        from: Address;
-        data: string;
-        value: string;
-        gasLimit: string;
-    };
+    tx?: PortalsTx;
 };
 type PortalsTradeOrderEstimateResponse = {
     outputAmount: string;

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

@@ -0,0 +1,27 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types';
+import type { PortalsTx } from './fetchPortalsTradeOrder';
+type BaseArgs = {
+    tx: PortalsTx;
+    spenderAddress: string;
+};
+export type GetPortalsStepDataArgs = StepDataArgs<BaseArgs, {
+    inputToken: string;
+    outputToken: string;
+    inputAmount: string;
+    slippageTolerancePercentage: number;
+}>;
+type PortalsRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type PortalsQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getPortalsStepData(args: Extract<GetPortalsStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<PortalsRateStepData, SwapErrorRight>>;
+export declare function getPortalsStepData(args: Extract<GetPortalsStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<PortalsQuoteStepData, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortalsStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const fetchPortalsTradeOrder_1 = require("./fetchPortalsTradeOrder");
+async function getPortalsStepData(args) {
+    const { tx, sellAsset, spenderAddress, input, deps } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    if (args.type === 'rate') {
+        try {
+            // No placeholder estimation for provider built routes - overridden estimation (approval
+            // state need not exist yet) with the Portals estimate endpoint as fallback
+            const gasLimit = await (async () => {
+                try {
+                    const gasLimit = await (0, evm_1.estimateGasWithStateOverride)({
+                        sellAsset,
+                        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        from: tx.from,
+                        spenderAddress,
+                        to: tx.to,
+                        data: tx.data,
+                        value: tx.value,
+                    });
+                    return gasLimit;
+                }
+                catch {
+                    const quoteEstimateResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeEstimate)({
+                        inputToken: args.inputToken,
+                        outputToken: args.outputToken,
+                        inputAmount: args.inputAmount,
+                        slippageTolerancePercentage: args.slippageTolerancePercentage,
+                        swapperConfig: deps.config,
+                    });
+                    return quoteEstimateResponse.context.gasLimit.toString();
+                }
+            })();
+            const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                adapter,
+                supportsEIP1559,
+                gasLimit,
+            });
+            const stepData = { networkFeeCryptoBaseUnit };
+            return (0, monads_1.Ok)(stepData);
+        }
+        catch (error) {
+            return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getPortalsStepData', error));
+        }
+    }
+    const transactionData = {
+        type: 'evm',
+        chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        // Portals simulate and pad their gas limit when the order was validated, so no additional
+        // buffer - an unvalidated order carries no gas limit and estimates below instead
+        gasLimit: tx.gasLimit,
+    };
+    try {
+        const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+            adapter,
+            transactionData,
+            from: args.from,
+            supportsEIP1559,
+            stateOverride: {
+                sellAsset,
+                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                spenderAddress,
+            },
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getPortalsStepData', error));
+    }
+}
+exports.getPortalsStepData = getPortalsStepData;

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

@@ -0,0 +1,25 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { PortalsSupportedChainId, PortalsTradeQuoteInput, PortalsTradeRateInput } from '../types';
+import type { PortalsTradeOrderResponse, PortalsTx } from './fetchPortalsTradeOrder';
+type PortalsTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: {
+        deps: SwapperDeps;
+        sellAsset: Asset;
+        spenderAddress: string;
+        tx: PortalsTx;
+    };
+};
+export declare const getPortalsTradeContext: ({ input, deps, sellChainId, inputToken, orderContext, tx, }: {
+    input: PortalsTradeQuoteInput | PortalsTradeRateInput;
+    deps: SwapperDeps;
+    sellChainId: PortalsSupportedChainId;
+    inputToken: string;
+    orderContext: PortalsTradeOrderResponse['context'];
+    tx: PortalsTx;
+}) => Result<PortalsTradeContext, SwapErrorRight>;
+export {};

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortalsTradeContext = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const helpers_1 = require("./helpers");
+const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, orderContext, tx, }) => {
+    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const { orderId, outputAmount, minOutputAmount, target, feeAmount, feeToken } = orderContext;
+    const isCrossChain = sellAsset.chainId !== buyAsset.chainId;
+    const buyAmountAfterFeesCryptoBaseUnit = isCrossChain ? minOutputAmount : outputAmount;
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    // Cross-chain approves the route target; same-chain approves the Portals router
+    const allowanceContract = isCrossChain ? target : (0, helpers_1.getPortalsRouterAddressByChainId)(sellChainId);
+    if (allowanceContract === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `no Portals router for chainId ${sellChainId}`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellChainId },
+        }));
+    }
+    // Portals reports the slippage we requested, not what it applied — recover the actual buffer from the amounts
+    const actualBufferDecimal = (0, utils_1.bnOrZero)(buyAmountAfterFeesCryptoBaseUnit)
+        .minus(minOutputAmount)
+        .div(buyAmountAfterFeesCryptoBaseUnit)
+        .toString();
+    // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
+    const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(minOutputAmount)
+        .div((0, utils_1.bn)(1).minus(actualBufferDecimal))
+        .toFixed(0);
+    const protocolFeeAsset = feeToken === inputToken ? sellAsset : buyAsset;
+    const protocolFees = (() => {
+        if (!feeToken || !feeAmount)
+            return;
+        return {
+            [protocolFeeAsset.assetId]: {
+                amountCryptoBaseUnit: feeAmount,
+                asset: protocolFeeAsset,
+                requiresBalance: false,
+            },
+        };
+    })();
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: orderId,
+            rate,
+            swapperName: types_1.SwapperName.Portals,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: actualBufferDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
+            allowanceContract,
+            rate,
+            buyAsset,
+            sellAsset,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            source: types_1.SwapperName.Portals,
+            affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                isEstimate: true,
+            }),
+        },
+        protocolFees,
+        stepDataArgs: { deps, sellAsset, spenderAddress: allowanceContract, tx },
+    });
+};
+exports.getPortalsTradeContext = getPortalsTradeContext;

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

@@ -1,4 +1,28 @@
 import type { ChainId } from '@shapeshiftoss/caip';
+import type { Asset, KnownChainIds } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
 import type { PortalsSupportedChainId } from '../types';
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds;
-export declare const getPortalsRouterAddressByChainId: (chainId: PortalsSupportedChainId) => string;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    sellChainId: PortalsSupportedChainId;
+    buyChainId: PortalsSupportedChainId;
+}, SwapErrorRight>;
+export declare const getPortalsTokens: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    inputToken: string;
+    outputToken: string;
+}, SwapErrorRight>;
+export declare const getPortalsPercentages: ({ affiliateBps, slippageTolerancePercentageDecimal, }: {
+    affiliateBps: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+}) => {
+    affiliateBpsPercentage: number;
+    slippageTolerancePercentage: number;
+};
+export declare const getPortalsRouterAddressByChainId: (chainId: PortalsSupportedChainId) => string | undefined;

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

@@ -1,12 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPortalsRouterAddressByChainId = exports.isSupportedChainId = void 0;
+exports.getPortalsRouterAddressByChainId = exports.getPortalsPercentages = exports.getPortalsTokens = exports.assertValidTrade = exports.isSupportedChainId = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
-const types_1 = require("../types");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const viem_1 = require("viem");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../../../utils/helpers");
+const constants_2 = require("../constants");
+const types_2 = require("../types");
 const isSupportedChainId = (chainId) => {
-    return types_1.PortalsSupportedChainIds.includes(chainId);
+    return types_2.PortalsSupportedChainIds.includes(chainId);
 };
 exports.isSupportedChainId = isSupportedChainId;
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (!(0, exports.isSupportedChainId)(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, exports.isSupportedChainId)(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    return (0, monads_1.Ok)({ sellChainId: sellAsset.chainId, buyChainId: buyAsset.chainId });
+};
+exports.assertValidTrade = assertValidTrade;
+// Builds the `network:address` token pair Portals expects, native assets mapped to the zero address
+const getPortalsTokens = ({ sellAsset, buyAsset, }) => {
+    const sellPortalsNetwork = constants_2.chainIdToPortalsNetwork[sellAsset.chainId];
+    const buyPortalsNetwork = constants_2.chainIdToPortalsNetwork[buyAsset.chainId];
+    if (!sellPortalsNetwork) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!buyPortalsNetwork) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    const sellAssetAddress = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+        ? viem_1.zeroAddress
+        : (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+    const buyAssetAddress = (0, helpers_1.isNativeEvmAsset)(buyAsset.assetId)
+        ? viem_1.zeroAddress
+        : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
+    return (0, monads_1.Ok)({
+        inputToken: `${sellPortalsNetwork}:${sellAssetAddress}`,
+        outputToken: `${buyPortalsNetwork}:${buyAssetAddress}`,
+    });
+};
+exports.getPortalsTokens = getPortalsTokens;
+// Portals expects whole percentages (e.g. 1 for 1%), not bps or decimals
+const getPortalsPercentages = ({ affiliateBps, slippageTolerancePercentageDecimal, }) => {
+    const affiliateBpsPercentage = (0, utils_1.convertBasisPointsToDecimalPercentage)(affiliateBps)
+        .times(100)
+        .toNumber();
+    const slippageTolerancePercentage = slippageTolerancePercentageDecimal
+        ? (0, utils_1.bnOrZero)(slippageTolerancePercentageDecimal).times(100).toNumber()
+        : (0, utils_1.bnOrZero)((0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Portals))
+            .times(100)
+            .toNumber();
+    return { affiliateBpsPercentage, slippageTolerancePercentage };
+};
+exports.getPortalsPercentages = getPortalsPercentages;
+// The same-chain Portals router; undefined for supported chains without a known router (cross-chain uses the route target instead)
 const getPortalsRouterAddressByChainId = (chainId) => {
     switch (chainId) {
         case caip_1.polygonChainId:
@@ -22,11 +92,13 @@ const getPortalsRouterAddressByChainId = (chainId) => {
         case caip_1.arbitrumChainId:
             return '0x34b6a821d2f26c6b7cdb01cd91895170c6574a0d';
         case caip_1.baseChainId:
+        case caip_1.sonicChainId:
+        case caip_1.plasmaChainId:
             return '0xb0324286b3ef7dddc93fb2ff7c8b7b8a3524803c';
-        case caip_1.gnosisChainId:
-            return '0x8e74454b2cf2f6cc2a06083ef122187551cf391c';
+        case caip_1.hyperEvmChainId:
+            return '0x2db3b92918ece265c7d5d9d975c69d89b8b1136c';
         default:
-            throw new Error(`Router address not found for chainId: ${chainId}`);
+            return undefined;
     }
 };
 exports.getPortalsRouterAddressByChainId = getPortalsRouterAddressByChainId;

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

@@ -1,17 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.relayApi = void 0;
-const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const unchained_client_1 = require("@shapeshiftoss/unchained-client");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const getSolanaTransactionFees_1 = require("../../solana-utils/getSolanaTransactionFees");
-const getUnsignedSolanaTransaction_1 = require("../../solana-utils/getUnsignedSolanaTransaction");
-const getTronTransactionFees_1 = require("../../tron-utils/getTronTransactionFees");
-const getUnsignedTronTransaction_1 = require("../../tron-utils/getUnsignedTronTransaction");
 const utils_1 = require("../../utils");
+const evm_1 = require("../../utils/evm");
+const getSolanaTransactionFees_1 = require("../../utils/solana/getSolanaTransactionFees");
+const getUnsignedSolanaTransaction_1 = require("../../utils/solana/getUnsignedSolanaTransaction");
+const tron_1 = require("../../utils/tron");
+const utxo_1 = require("../../utils/utxo");
 const constant_1 = require("./constant");
 const getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
 const getTradeRate_1 = require("./getTradeRate/getTradeRate");
@@ -21,114 +17,20 @@ const relayService_1 = require("./utils/relayService");
 // Keep track of the trades we already notified the relay indexer about
 const txIndexingMap = new Map();
 exports.relayApi = {
-    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps, constant_1.chainIdToRelayChainId),
-    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps, constant_1.chainIdToRelayChainId),
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
-        const { relayTransactionMetadata, sellAsset } = step;
-        if (!relayTransactionMetadata)
-            throw Error('Missing relay transaction metadata');
-        const { to, value, data } = relayTransactionMetadata;
-        if (to === undefined || value === undefined || data === undefined) {
-            const undefinedRequiredValues = [to, value, data].filter(value => value === undefined);
-            throw Error('undefined required values in transactionRequest', {
-                cause: {
-                    undefinedRequiredValues,
-                },
-            });
-        }
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        return feeData.networkFeeCryptoBaseUnit;
-    },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
-        const { accountNumber, relayTransactionMetadata, sellAsset } = step;
-        if (!relayTransactionMetadata)
-            throw Error('Transaction metadata is required');
-        const { to, value, data, gasLimit: gasLimitFromApi } = relayTransactionMetadata;
-        if (to === undefined || value === undefined || data === undefined) {
-            const undefinedRequiredValues = [to, value, data].filter(value => value === undefined);
-            throw Error('undefined required values in swap step', {
-                cause: {
-                    undefinedRequiredValues,
-                },
-            });
-        }
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        const unsignedTx = await adapter.buildCustomApiTx({
-            accountNumber,
-            data,
-            from,
-            to,
-            value,
-            ...feeData,
-            // Use the higher amount of the node or the API, as the node doesn't always provide enough gas padding for total gas used.
-            gasLimit: bignumber_js_1.default.max(gasLimitFromApi ?? '0', feeData.gasLimit).toFixed(),
-        });
-        return unsignedTx;
+    getTradeQuote: (input, deps) => {
+        return (0, getTradeQuote_1.getTradeQuote)(input, deps, constant_1.chainIdToRelayChainId);
     },
-    getUnsignedUtxoTransaction: async ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
-        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, relayTransactionMetadata } = step;
-        if (!relayTransactionMetadata)
-            throw new Error('Missing relay transaction metadata');
-        const { to, opReturnData } = relayTransactionMetadata;
-        if (!to)
-            throw new Error('Missing transaction destination');
-        if (!opReturnData)
-            throw new Error('Missing opReturnData');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: { pubkey: xpub, opReturnData },
-            sendMax: false,
-        });
-        return assertGetUtxoChainAdapter(sellAsset.chainId).buildSendApiTransaction({
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            xpub,
-            to,
-            accountNumber,
-            chainSpecific: {
-                accountType,
-                opReturnData,
-                satoshiPerByte: fast.chainSpecific.satoshiPerByte,
-            },
-        });
-    },
-    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
-        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
-        const { sellAsset, relayTransactionMetadata } = step;
-        if (!relayTransactionMetadata?.psbt)
-            throw new Error('Missing psbt');
-        const { to, opReturnData } = relayTransactionMetadata;
-        if (!to)
-            throw new Error('Missing transaction destination');
-        if (!opReturnData)
-            throw new Error('Missing opReturnData');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: { pubkey: xpub, opReturnData },
-            sendMax: false,
-        });
-        return fast.txFee;
+    getTradeRate: (input, deps) => {
+        return (0, getTradeRate_1.getTradeRate)(input, deps, constant_1.chainIdToRelayChainId);
     },
+    getEvmTransactionFees: evm_1.getEvmTransactionFees,
+    getUnsignedEvmTransaction: evm_1.getUnsignedEvmTransaction,
+    getUnsignedUtxoTransaction: utxo_1.getUnsignedUtxoTransaction,
+    getUtxoTransactionFees: utxo_1.getUtxoTransactionFees,
     getSolanaTransactionFees: getSolanaTransactionFees_1.getSolanaTransactionFees,
     getUnsignedSolanaTransaction: getUnsignedSolanaTransaction_1.getUnsignedSolanaTransaction,
-    getTronTransactionFees: getTronTransactionFees_1.getTronTransactionFees,
-    getUnsignedTronTransaction: getUnsignedTronTransaction_1.getUnsignedTronTransaction,
+    getTronTransactionFees: tron_1.getTronTransactionFees,
+    getUnsignedTronTransaction: tron_1.getUnsignedTronTransaction,
     checkTradeStatus: async ({ swap, txHash, chainId, address, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
         const maybeSafeTransactionStatus = await (0, utils_1.checkSafeTransactionStatus)({
             txHash,
@@ -137,8 +39,9 @@ exports.relayApi = {
             address,
             fetchIsSmartContractAddressQuery,
         });
-        if (!swap?.metadata.relayTransactionMetadata)
-            throw new Error('Missing swap metadata');
+        if (!swap)
+            throw new Error('Missing swap');
+        const relayMetadata = (0, utils_1.getSwapMetadata)(swap.metadata.swapperMetadata, 'relay');
         if (maybeSafeTransactionStatus) {
             // return any safe transaction status that has not yet executed on chain (no buyTxHash)
             if (!maybeSafeTransactionStatus.buyTxHash)
@@ -147,26 +50,27 @@ exports.relayApi = {
             // Mutate txHash and continue with regular status check flow.
             txHash = maybeSafeTransactionStatus.buyTxHash;
         }
-        if (swap.metadata.relayTransactionMetadata &&
+        if (relayMetadata &&
             !txIndexingMap.has(swap.id) &&
             constant_1.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 (0, notifyTransactionIndexing_1.notifyTransactionIndexing)({
-                requestId: swap.metadata.relayTransactionMetadata.relayId,
+                requestId: relayMetadata.relayId,
                 chainId: constant_1.chainIdToRelayChainId[chainId].toString(),
-                tx: JSON.stringify(relayTxParam),
+                tx: relayMetadata.data ?? '',
             }, config);
             txIndexingMap.set(swap.id, true);
         }
-        const maybeStatusResponse = await relayService_1.relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v2?requestId=${swap.metadata.relayTransactionMetadata.relayId}`);
+        // relay.link tracks the swap by its origin chain transaction
+        const swapperTxId = txHash;
+        const swapperTxLink = `https://relay.link/transaction/${txHash}`;
+        const maybeStatusResponse = await relayService_1.relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v2?requestId=${relayMetadata.relayId}`);
         if (maybeStatusResponse.isErr()) {
             return {
                 buyTxHash: undefined,
                 status: unchained_client_1.TxStatus.Unknown,
+                swapperTxId,
+                swapperTxLink,
                 message: undefined,
             };
         }
@@ -192,6 +96,8 @@ exports.relayApi = {
         return {
             status,
             buyTxHash,
+            swapperTxId,
+            swapperTxLink,
             message: (0, getLatestRelayStatusMessage_1.getLatestRelayStatusMessage)(statusResponse),
         };
     },

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

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