@shapeshiftoss/swapper 17.8.0 → 18.1.0

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

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelayTradeContext = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const helpers_1 = require("../../../utils/helpers");
+const constant_1 = require("../constant");
+const getRelayAssetAddress_1 = require("../utils/getRelayAssetAddress");
+const relayTokenToAsset_1 = require("../utils/relayTokenToAsset");
+const relayTokenToAssetId_1 = require("../utils/relayTokenToAssetId");
+const fetchRelayTrade_1 = require("./fetchRelayTrade");
+const helpers_2 = require("./helpers");
+const types_2 = require("./types");
+const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const xpub = 'xpub' in input ? input.xpub : undefined;
+    const slippageToleranceBps = input.slippageTolerancePercentageDecimal
+        ? (0, utils_1.convertDecimalPercentageToBasisPoints)(input.slippageTolerancePercentageDecimal).toFixed()
+        : undefined;
+    const assertion = (0, helpers_2.assertValidTrade)({ sellAsset, buyAsset, relayChainMap });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const { sellRelayChainId, buyRelayChainId } = assertion.unwrap();
+    const { sendAddress, recipient, refundTo } = (0, helpers_2.resolveRelayAddresses)({
+        input,
+        sellChainId: sellAsset.chainId,
+        buyChainId: buyAsset.chainId,
+    });
+    const maybeQuote = await (0, fetchRelayTrade_1.fetchRelayTrade)({
+        originChainId: sellRelayChainId,
+        originCurrency: (0, getRelayAssetAddress_1.getRelayAssetAddress)(sellAsset),
+        destinationChainId: buyRelayChainId,
+        destinationCurrency: (0, getRelayAssetAddress_1.getRelayAssetAddress)(buyAsset),
+        tradeType: 'EXACT_INPUT',
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        recipient,
+        user: sendAddress,
+        refundTo,
+        slippageTolerance: slippageToleranceBps,
+        refundOnOrigin: true,
+        referrer: 'shapeshift',
+        appFees: [
+            {
+                // Relay expects a BASE EVM address for affiliate fees
+                recipient: utils_1.DAO_TREASURY_BASE,
+                fee: affiliateBps,
+            },
+        ],
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        const error = maybeQuote.unwrapErr();
+        if (!axios_1.default.isAxiosError(error.cause)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Unknown error', code: types_1.TradeQuoteError.UnknownError }));
+        }
+        const relayError = error.cause?.response?.data;
+        if (!(0, types_2.isRelayError)(relayError)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Unknown error', code: types_1.TradeQuoteError.UnknownError }));
+        }
+        const tradeQuoteErrorCode = constant_1.relayErrorCodeToTradeQuoteError[relayError.errorCode];
+        if (tradeQuoteErrorCode) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: relayError.message, code: tradeQuoteErrorCode }));
+        }
+        // Fallback for unmapped error codes (shouldn't happen, but prevents crashes)
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: relayError.message || 'Unknown Relay error',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const orderId = quote.protocol?.v2?.orderId;
+    if (!orderId && sellAsset.chainId === caip_1.btcChainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Relay quote missing protocol.v2.orderId',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const { slippageTolerance, currencyOut, timeEstimate } = quote.details;
+    const buyAmountAfterFeesCryptoBaseUnit = currencyOut.amount;
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const { currency: relayToken } = currencyOut;
+    const swapSteps = quote.steps.filter(step => step.id !== 'approve');
+    if (swapSteps.length >= constant_1.MAXIMUM_SUPPORTED_RELAY_STEPS) {
+        deps.mixPanel?.track(types_1.MixPanelEvent.RelayMultiHop);
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Relay quote with ${swapSteps.length} swap steps not supported (maximum ${constant_1.MAXIMUM_SUPPORTED_RELAY_STEPS})`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const swapStepsContainsMultipleItems = swapSteps.some(step => step.items?.length && step.items.length > 1);
+    // It's uncommon but can happen, log it to mixpanel to ensure we will investigate if it happens too much in the future
+    if (swapStepsContainsMultipleItems) {
+        deps.mixPanel?.track(types_1.MixPanelEvent.RelayStepMultipleItems);
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Relay quote with step containing multiple items not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (swapSteps.some(step => !step.items?.[0])) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Relay quote step contains no items' }));
+    }
+    const slippageTolerancePercentageDecimal = (() => {
+        if (input.slippageTolerancePercentageDecimal)
+            return input.slippageTolerancePercentageDecimal;
+        const destinationSlippageTolerancePercentageDecimal = (0, utils_1.bnOrZero)(slippageTolerance.destination.percent);
+        if (destinationSlippageTolerancePercentageDecimal.gt(0)) {
+            return (0, utils_1.convertBasisPointsToPercentage)(destinationSlippageTolerancePercentageDecimal).toFixed();
+        }
+        const originSlippageTolerancePercentageDecimal = (0, utils_1.bnOrZero)(slippageTolerance.origin.percent);
+        return (0, utils_1.convertBasisPointsToPercentage)(originSlippageTolerancePercentageDecimal).toFixed();
+    })();
+    const protocolAssetId = (0, relayTokenToAssetId_1.relayTokenToAssetId)(relayToken);
+    const maybeProtocolAsset = (0, relayTokenToAsset_1.relayTokenToAsset)(relayToken, deps.assetsById);
+    if (maybeProtocolAsset.isErr())
+        return (0, monads_1.Err)(maybeProtocolAsset.unwrapErr());
+    const protocolAsset = maybeProtocolAsset.unwrap();
+    const isCrossChain = sellAsset.chainId !== buyAsset.chainId;
+    const maybeAppFeesAsset = (() => {
+        // @TODO: when implementing fees, find if solana to solana assets are always showing empty app fees even if
+        // affiliate bps are set, if we remove this the quote fetching will fail because relayTokenToAsset will throw
+        if (sellAsset.chainId === caip_1.solanaChainId &&
+            buyAsset.chainId === caip_1.solanaChainId &&
+            quote.fees.app.currency.address === viem_1.zeroAddress) {
+            return (0, monads_1.Ok)(undefined);
+        }
+        return (0, relayTokenToAsset_1.relayTokenToAsset)(quote.fees.app.currency, deps.assetsById);
+    })();
+    const isNativeCurrencyInput = (() => {
+        if (maybeAppFeesAsset.isErr())
+            return false;
+        const appFeesAsset = maybeAppFeesAsset.unwrap();
+        if (!appFeesAsset)
+            return false;
+        if ((0, chain_adapters_1.isEvmChainId)(sellAsset.chainId)) {
+            return (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) && sellAsset.chainId === appFeesAsset.chainId;
+        }
+        if (sellAsset.chainId === caip_1.btcChainId)
+            return sellAsset.assetId === appFeesAsset.assetId;
+        if (sellAsset.chainId === caip_1.solanaChainId)
+            return sellAsset.assetId === appFeesAsset.assetId;
+        if (sellAsset.chainId === caip_1.tronChainId)
+            return sellAsset.assetId === appFeesAsset.assetId;
+        return false;
+    })();
+    const appFeesBaseUnit = (() => {
+        if (maybeAppFeesAsset.isErr())
+            return '0';
+        const appFeesAsset = maybeAppFeesAsset.unwrap();
+        if (!appFeesAsset)
+            return '0';
+        // For cross-chain: always add back app fees
+        // For same-chain: only add back if input is native currency
+        if (isCrossChain || isNativeCurrencyInput) {
+            if (buyAsset.assetId === appFeesAsset.assetId) {
+                return quote.fees.app.amount;
+            }
+            // if fee is in sell asset, convert to buy asset
+            if (appFeesAsset.assetId === sellAsset.assetId) {
+                return (0, utils_1.convertPrecision)({
+                    value: quote.fees.app.amount,
+                    inputExponent: appFeesAsset.precision,
+                    outputExponent: buyAsset.precision,
+                })
+                    .times(rate)
+                    .toFixed(0);
+            }
+            // If fee is in a different asset, convert to buy asset
+            const feeAmountUsd = quote.fees.app.amountUsd;
+            const buyAssetUsd = currencyOut.amountUsd;
+            if (feeAmountUsd && buyAssetUsd && buyAmountAfterFeesCryptoBaseUnit) {
+                // Calculate the rate: (buyAssetAmount / buyAssetUsd) gives us "buy asset per USD"
+                // Then multiply by feeAmountUsd to get the equivalent buy asset amount
+                const buyAssetCryptoBaseUnitPerUsd = (0, utils_1.bnOrZero)(buyAmountAfterFeesCryptoBaseUnit).div(buyAssetUsd);
+                const appFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(feeAmountUsd).times(buyAssetCryptoBaseUnitPerUsd);
+                return appFeesCryptoBaseUnit.toFixed(0);
+            }
+            return '0';
+        }
+        // cross-chain or same-chain with native currency as input are not applicable
+        return '0';
+    })();
+    // If same chain and not sellAsset as native currency, convert to protocol fee as native value is sent as well as erc20 tokens
+    // This is a edge case we never encountered before and it's more convenient to consider it as protocol fee as quickwin
+    const appFeesAsProtocolFee = (() => {
+        if (sellAsset.chainId !== buyAsset.chainId)
+            return {};
+        if (maybeAppFeesAsset.isErr())
+            return {};
+        const appFeesAsset = maybeAppFeesAsset.unwrap();
+        if (!appFeesAsset || isNativeCurrencyInput)
+            return {};
+        return {
+            [appFeesAsset.assetId]: {
+                amountCryptoBaseUnit: quote.fees.app.amount,
+                asset: appFeesAsset,
+                requiresBalance: false,
+            },
+        };
+    })();
+    const relayerFeeRelayToken = quote.fees.relayer.currency;
+    const maybeRelayerFeesAsset = (0, relayTokenToAsset_1.relayTokenToAsset)(relayerFeeRelayToken, deps.assetsById);
+    if (maybeRelayerFeesAsset.isErr()) {
+        return (0, monads_1.Err)(maybeRelayerFeesAsset.unwrapErr());
+    }
+    const relayerFeesAsset = maybeRelayerFeesAsset.unwrap();
+    const relayerFeesBuyAssetCryptoBaseUnit = (() => {
+        const relayerFeeAmount = quote.fees.relayer.amount;
+        // If fee is already in buy asset, return as is
+        if (relayerFeesAsset.assetId === buyAsset.assetId) {
+            return relayerFeeAmount;
+        }
+        // if fee is in sell asset, convert to buy asset
+        if (relayerFeesAsset.assetId === sellAsset.assetId) {
+            return (0, utils_1.convertPrecision)({
+                value: relayerFeeAmount,
+                inputExponent: relayerFeesAsset.precision,
+                outputExponent: buyAsset.precision,
+            })
+                .times(rate)
+                .toFixed(0);
+        }
+        // If fee is in a different asset, convert to buy asset
+        const feeAmountUsd = quote.fees.relayer.amountUsd;
+        const buyAssetUsd = currencyOut.amountUsd;
+        const buyAssetAmountBaseUnit = currencyOut.amount;
+        if (feeAmountUsd && buyAssetUsd && buyAssetAmountBaseUnit) {
+            // Calculate the rate: (buyAssetAmount / buyAssetUsd) gives us "buy asset per USD"
+            // Then multiply by feeAmountUsd to get the equivalent buy asset amount
+            const buyAssetCryptoBaseUnitPerUsd = (0, utils_1.bnOrZero)(buyAssetAmountBaseUnit).div(buyAssetUsd);
+            const buyAssetFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(feeAmountUsd).times(buyAssetCryptoBaseUnitPerUsd);
+            return buyAssetFeesCryptoBaseUnit.toFixed(0);
+        }
+        return '0';
+    })();
+    // Add back relayer service and gas fees (relayer is including both) since they are downsides,
+    // and add appFees — these are quote-level and identical across every step
+    const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(currencyOut.amount)
+        .plus(relayerFeesBuyAssetCryptoBaseUnit)
+        .plus(appFeesBaseUnit)
+        .toFixed();
+    const relayId = quote.steps[0].requestId;
+    const relayStepInputs = swapSteps.map(step => {
+        const data = step.items?.[0]?.data;
+        return { data, allowanceContract: (0, helpers_2.getRelayAllowanceContract)(data) };
+    });
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: relayId,
+            rate,
+            swapperName: types_1.SwapperName.Relay,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: types_1.SwapperName.Relay,
+            estimatedExecutionTimeMs: timeEstimate * 1000,
+            affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                strategy: 'fixed_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                fixedAssetId: (0, utils_1.chainIdToFeeAssetId)(caip_1.baseChainId),
+                fixedAsset: deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(caip_1.baseChainId)],
+                isEstimate: true,
+            }),
+        },
+        protocolFees: {
+            [protocolAssetId]: {
+                amountCryptoBaseUnit: quote.fees.relayer.amount,
+                asset: protocolAsset,
+                requiresBalance: false,
+            },
+            ...appFeesAsProtocolFee,
+        },
+        relayStepInputs,
+        stepDataArgs: {
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            orderId,
+            from: sendAddress,
+            xpub,
+            fallbackNetworkFeeCryptoBaseUnit: quote.fees.gas.amount,
+            deps,
+        },
+        relayId,
+    });
+};
+exports.getRelayTradeContext = getRelayTradeContext;

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

@@ -0,0 +1,26 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { TransactionInstruction } from '@solana/web3.js';
+import type { SwapErrorRight } from '../../../types';
+import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
+import type { RelayQuoteItem, RelaySolanaInstruction, RelayTradeQuoteInput, RelayTradeRateInput } from './types';
+export declare const assertValidTrade: ({ sellAsset, buyAsset, relayChainMap, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+    relayChainMap: typeof relayChainMapImplementation;
+}) => Result<{
+    sellRelayChainId: number;
+    buyRelayChainId: number;
+}, SwapErrorRight>;
+export declare const resolveRelayAddresses: ({ input, sellChainId, buyChainId, }: {
+    input: RelayTradeQuoteInput | RelayTradeRateInput;
+    sellChainId: ChainId;
+    buyChainId: ChainId;
+}) => {
+    sendAddress: string;
+    recipient: string;
+    refundTo: string;
+};
+export declare const getRelayAllowanceContract: (data: RelayQuoteItem['data']) => string;
+export declare const convertRelaySolanaInstruction: (instruction: RelaySolanaInstruction) => TransactionInstruction;

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRelaySolanaInstruction = exports.getRelayAllowanceContract = exports.resolveRelayAddresses = exports.assertValidTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const monads_1 = require("@sniptt/monads");
+const web3_js_1 = require("@solana/web3.js");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const getRelayDefaultUserAddress_1 = require("./getRelayDefaultUserAddress");
+const types_2 = require("./types");
+const isSupportedRelayChainId = (chainId) => (0, chain_adapters_1.isEvmChainId)(chainId) ||
+    chainId === caip_1.btcChainId ||
+    chainId === caip_1.solanaChainId ||
+    chainId === caip_1.tronChainId;
+const assertValidTrade = ({ sellAsset, buyAsset, relayChainMap, }) => {
+    if (!isSupportedRelayChainId(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (!isSupportedRelayChainId(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const sellRelayChainId = relayChainMap[sellAsset.chainId];
+    const buyRelayChainId = relayChainMap[buyAsset.chainId];
+    if (sellRelayChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (buyRelayChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return (0, monads_1.Ok)({ sellRelayChainId, buyRelayChainId });
+};
+exports.assertValidTrade = assertValidTrade;
+// BTC swaps must use the default user address for the fetch — a real address may not hold enough in a
+// single UTXO (the swap is funded from multiple UTXOs), so relay's estimation would fail. Rates default
+// every unset address; quotes carry the real ones (guarded upstream) so the `?? default` is inert there,
+// except refundTo which keeps the real send address even for BTC quotes.
+const resolveRelayAddresses = ({ input, sellChainId, buyChainId, }) => {
+    const sendAddress = sellChainId === caip_1.btcChainId
+        ? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellChainId)
+        : input.sendAddress ?? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellChainId);
+    const recipient = input.receiveAddress ?? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(buyChainId);
+    const refundTo = input.sendAddress ?? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellChainId);
+    return { sendAddress, recipient, refundTo };
+};
+exports.resolveRelayAddresses = resolveRelayAddresses;
+// The spender to approve: EVM routes approve the router (data.to); Tron approves the token contract;
+// UTXO/Solana need no allowance. Derived from the provider route, not the built transactionData.
+const getRelayAllowanceContract = (data) => {
+    if (!data)
+        return '';
+    if ((0, types_2.isRelayQuoteEvmItemData)(data))
+        return data.to ?? '';
+    if ((0, types_2.isRelayQuoteTronItemData)(data))
+        return data.parameter?.contract_address ?? '';
+    return '';
+};
+exports.getRelayAllowanceContract = getRelayAllowanceContract;
+const convertRelaySolanaInstruction = (instruction) => ({
+    ...instruction,
+    keys: instruction.keys.map(account => ({
+        ...account,
+        pubkey: new web3_js_1.PublicKey(account.pubkey),
+    })),
+    data: Buffer.from(instruction.data, 'hex'),
+    programId: new web3_js_1.PublicKey(instruction.programId),
+});
+exports.convertRelaySolanaInstruction = convertRelaySolanaInstruction;

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

@@ -1,28 +1,14 @@
-import type { Asset } from '@shapeshiftoss/types';
-export type RelayTradeBaseParams = {
-    buyAsset: Asset;
-    sellAsset: Asset;
-    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
-    affiliateBps: string;
-};
-export type RelayTradeInputParams<T extends 'rate' | 'quote'> = RelayTradeBaseParams & {
-    quoteOrRate: T;
-    receiveAddress: T extends 'rate' ? string | undefined : string;
-    sendAddress: T extends 'rate' ? undefined : string;
-    accountNumber: T extends 'rate' ? undefined : number;
-    slippageTolerancePercentageDecimal?: string;
-    xpub: string | undefined;
-};
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput } from '../../../types';
+export type RelayTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput;
+export type RelayTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput;
 export type RelayTransactionMetadata = {
     to?: string;
-    from?: string;
-    value?: string;
     data?: string;
-    gasLimit?: string;
-    psbt?: string;
-    opReturnData?: string;
+};
+export type RelayMetadata = {
+    name: 'relay';
     relayId: string;
-    orderId: string | undefined;
+    data?: string;
 };
 export type RelayStatus = {
     status: 'success' | 'failed' | 'pending' | 'refund' | 'delayed' | 'waiting';

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

@@ -7,61 +7,21 @@ const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
 const utils_1 = require("../../utils");
 const getTradeQuote_1 = require("./swapperApi/getTradeQuote");
 const getTradeRate_1 = require("./swapperApi/getTradeRate");
+const constants_1 = require("./utils/constants");
+const helpers_1 = require("./utils/helpers");
 const omnistonManager_1 = require("./utils/omnistonManager");
-const TRADE_TRACKING_TIMEOUT_MS = 60000;
-const waitForFirstTradeStatus = (request, timeoutMs) => {
-    const omniston = omnistonManager_1.omnistonManager.getInstance();
-    return new Promise(resolve => {
-        const timer = setTimeout(() => {
-            subscription.unsubscribe();
-            resolve(null);
-        }, timeoutMs);
-        const subscription = omniston.trackTrade(request).subscribe({
-            next: (status) => {
-                clearTimeout(timer);
-                subscription.unsubscribe();
-                resolve(status);
-            },
-            error: err => {
-                console.error('[Stonfi] trackTrade error:', err);
-                clearTimeout(timer);
-                resolve(null);
-            },
-        });
-    });
-};
 exports.stonfiApi = {
-    getTradeQuote: (input, _deps) => (0, getTradeQuote_1.getTradeQuote)(input),
-    getTradeRate: input => (0, getTradeRate_1.getTradeRate)(input),
+    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps),
+    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps),
     getUnsignedTonTransaction: async ({ stepIndex, tradeQuote, from, assertGetTonChainAdapter }) => {
         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, stonfiSpecific } = step;
-        if (!stonfiSpecific) {
-            throw new Error('stonfiSpecific is required');
-        }
+        const { accountNumber, sellAsset, stonfiTransactionData } = step;
+        if (!stonfiTransactionData)
+            throw new Error('[Stonfi] invalid ton transaction');
         const adapter = assertGetTonChainAdapter(sellAsset.chainId);
-        const storedQuote = {
-            quoteId: stonfiSpecific.quoteId,
-            resolverId: stonfiSpecific.resolverId,
-            resolverName: stonfiSpecific.resolverName,
-            bidAssetAddress: stonfiSpecific.bidAssetAddress,
-            askAssetAddress: stonfiSpecific.askAssetAddress,
-            bidUnits: stonfiSpecific.bidUnits,
-            askUnits: stonfiSpecific.askUnits,
-            referrerAddress: stonfiSpecific.referrerAddress,
-            referrerFeeAsset: stonfiSpecific.referrerFeeAsset,
-            referrerFeeUnits: stonfiSpecific.referrerFeeUnits,
-            protocolFeeAsset: stonfiSpecific.protocolFeeAsset,
-            protocolFeeUnits: stonfiSpecific.protocolFeeUnits,
-            quoteTimestamp: stonfiSpecific.quoteTimestamp,
-            tradeStartDeadline: stonfiSpecific.tradeStartDeadline,
-            gasBudget: stonfiSpecific.gasBudget,
-            estimatedGasConsumption: stonfiSpecific.estimatedGasConsumption,
-            params: stonfiSpecific.params,
-        };
         const omniston = omnistonManager_1.omnistonManager.getInstance();
         const maxRetries = 3;
         let lastError = null;
@@ -73,7 +33,7 @@ exports.stonfiApi = {
                         blockchain: omniston_sdk_1.Blockchain.TON,
                         address: tradeQuote.receiveAddress,
                     },
-                    quote: storedQuote,
+                    quote: stonfiTransactionData,
                     useRecommendedSlippage: true,
                 });
                 if (!txResponse?.ton?.messages || txResponse.ton.messages.length === 0) {
@@ -139,19 +99,16 @@ exports.stonfiApi = {
                 return (0, utils_1.createDefaultStatusResponse)(sellTxHash);
             }
         };
-        const { metadata } = swap;
-        if (!metadata?.quoteId) {
-            return checkTxStatusViaChainAdapter();
-        }
+        const { quoteId } = (0, utils_1.getSwapMetadata)(swap.metadata.swapperMetadata, 'stonfi');
         try {
-            const tradeStatus = await waitForFirstTradeStatus({
-                quoteId: metadata.quoteId,
+            const tradeStatus = await (0, helpers_1.waitForFirstTradeStatus)({
+                quoteId,
                 traderWalletAddress: {
                     blockchain: omniston_sdk_1.Blockchain.TON,
                     address: swap.sellAccountId.split(':')[2] ?? '',
                 },
                 outgoingTxHash: sellTxHash,
-            }, TRADE_TRACKING_TIMEOUT_MS);
+            }, constants_1.STONFI_TRADE_TRACKING_TIMEOUT_MS);
             if (!tradeStatus?.status) {
                 return checkTxStatusViaChainAdapter();
             }

package/dist/cjs/swappers/StonfiSwapper/swapperApi/getTradeQuote.d.ts

@@ -1,2 +1,3 @@
-import type { CommonTradeQuoteInput, TradeQuoteResult } from '../../../types';
-export declare const getTradeQuote: (input: CommonTradeQuoteInput) => Promise<TradeQuoteResult>;
+import type { SwapperDeps, TradeQuoteResult } from '../../../types';
+import type { StonfiTradeQuoteInput } from '../types';
+export declare const getTradeQuote: (input: StonfiTradeQuoteInput, deps: SwapperDeps) => Promise<TradeQuoteResult>;