@shapeshiftoss/swapper 17.8.0 → 18.1.0

package/dist/esm/swappers/StonfiSwapper/swapperApi/getTradeQuote.js

@@ -1,126 +1,38 @@
-import { tonChainId } from '@shapeshiftoss/caip';
 import { Err, Ok } from '@sniptt/monads';
-import { SettlementMethod } from '@ston-fi/omniston-sdk';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
-import { STONFI_DEFAULT_SLIPPAGE_BPS, STONFI_QUOTE_TIMEOUT_MS } from '../utils/constants.js';
-import { affiliateBpsToNumber, calculateRate, slippageDecimalToBps, tonAddressToOmnistonAddress, validateTonAssets, waitForQuote, } from '../utils/helpers.js';
-import { omnistonManager } from '../utils/omnistonManager.js';
-const buildStonfiSpecific = (quote, bidAssetAddress, askAssetAddress) => ({
-    quoteId: quote.quoteId,
-    resolverId: quote.resolverId,
-    resolverName: quote.resolverName,
-    tradeStartDeadline: quote.tradeStartDeadline,
-    gasBudget: quote.gasBudget,
-    bidAssetAddress: quote.bidAssetAddress ?? bidAssetAddress,
-    askAssetAddress: quote.askAssetAddress ?? askAssetAddress,
-    bidUnits: quote.bidUnits,
-    askUnits: quote.askUnits,
-    referrerAddress: quote.referrerAddress,
-    referrerFeeAsset: quote.referrerFeeAsset,
-    referrerFeeUnits: quote.referrerFeeUnits,
-    protocolFeeAsset: quote.protocolFeeAsset,
-    protocolFeeUnits: quote.protocolFeeUnits,
-    quoteTimestamp: quote.quoteTimestamp,
-    estimatedGasConsumption: quote.estimatedGasConsumption,
-    params: quote.params,
-});
-export const getTradeQuote = async (input) => {
-    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, slippageTolerancePercentageDecimal, affiliateBps, } = input;
-    const validation = validateTonAssets(sellAsset, buyAsset);
-    if (!validation.isValid) {
-        return validation.error;
-    }
-    const { bidAssetAddress, askAssetAddress } = validation;
-    const omniston = omnistonManager.getInstance();
-    try {
-        const slippageBps = slippageDecimalToBps(slippageTolerancePercentageDecimal, STONFI_DEFAULT_SLIPPAGE_BPS);
-        const referrerFeeBps = affiliateBpsToNumber(affiliateBps);
-        const tonTreasuryAddress = getTreasuryAddressFromChainId(tonChainId);
-        const referrerAddress = tonAddressToOmnistonAddress(tonTreasuryAddress);
-        const quoteResult = await waitForQuote(omniston, {
-            settlementMethods: [SettlementMethod.SETTLEMENT_METHOD_SWAP],
-            bidAssetAddress,
-            askAssetAddress,
-            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
-            referrerAddress,
-            referrerFeeBps,
-            settlementParams: {
-                maxPriceSlippageBps: slippageBps,
-                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
-                flexibleReferrerFee: true,
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getStonfiStepData } from '../utils/getStonfiStepData.js';
+import { getStonfiTradeContext } from '../utils/getStonfiTradeContext.js';
+export const getTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const addresses = assertQuoteAddresses(input);
+    if (addresses.isErr())
+        return Err(addresses.unwrapErr());
+    const { sendAddress, receiveAddress } = addresses.unwrap();
+    const maybeContext = await getStonfiTradeContext({ input, deps });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = getStonfiStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit, stonfiTransactionData } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                stonfiTransactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
             },
-        }, STONFI_QUOTE_TIMEOUT_MS);
-        if (quoteResult.type === 'error') {
-            console.error('[Stonfi] Quote request error:', quoteResult.error);
-            return Err(makeSwapErrorRight({
-                message: `[Stonfi] Connection error while fetching quote`,
-                code: TradeQuoteError.QueryFailed,
-                cause: quoteResult.error,
-            }));
-        }
-        if (quoteResult.type === 'timeout') {
-            return Err(makeSwapErrorRight({
-                message: `[Stonfi] Quote request timed out`,
-                code: TradeQuoteError.QueryFailed,
-            }));
-        }
-        if (quoteResult.type === 'noQuote') {
-            return Err(makeSwapErrorRight({
-                message: `[Stonfi] No quote available for this pair`,
-                code: TradeQuoteError.NoRouteFound,
-            }));
-        }
-        const quote = quoteResult.quote;
-        const buyAmountCryptoBaseUnit = quote.askUnits;
-        const networkFeeCryptoBaseUnit = quote.gasBudget;
-        const rate = calculateRate(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
-        const tradeQuote = {
-            id: quote.quoteId,
-            rate,
-            receiveAddress,
-            affiliateBps,
-            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
-            quoteOrRate: 'quote',
-            swapperName: SwapperName.Stonfi,
-            steps: [
-                {
-                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    feeData: {
-                        networkFeeCryptoBaseUnit,
-                        protocolFees: undefined,
-                    },
-                    rate,
-                    source: SwapperName.Stonfi,
-                    buyAsset,
-                    sellAsset,
-                    accountNumber,
-                    allowanceContract: '0x0',
-                    estimatedExecutionTimeMs: 30000,
-                    stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                        buyAmountCryptoBaseUnit,
-                        isEstimate: true,
-                    }),
-                },
-            ],
-        };
-        return Ok([tradeQuote]);
-    }
-    catch (err) {
-        return Err(makeSwapErrorRight({
-            message: `[Stonfi] Error getting quote: ${err}`,
-            code: TradeQuoteError.QueryFailed,
-            cause: err,
-        }));
-    }
+        ],
+    };
+    return Ok([tradeQuote]);
 };

package/dist/esm/swappers/StonfiSwapper/swapperApi/getTradeRate.d.ts

@@ -1,2 +1,3 @@
-import type { GetTradeRateInput, TradeRateResult } from '../../../types.js';
-export declare const getTradeRate: (input: GetTradeRateInput) => Promise<TradeRateResult>;
+import type { SwapperDeps, TradeRateResult } from '../../../types.js';
+import type { StonfiTradeRateInput } from '../types.js';
+export declare const getTradeRate: (input: StonfiTradeRateInput, deps: SwapperDeps) => Promise<TradeRateResult>;

package/dist/esm/swappers/StonfiSwapper/swapperApi/getTradeRate.js

@@ -1,111 +1,27 @@
 import { Err, Ok } from '@sniptt/monads';
-import { SettlementMethod } from '@ston-fi/omniston-sdk';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
-import { STONFI_DEFAULT_SLIPPAGE_BPS, STONFI_QUOTE_TIMEOUT_MS } from '../utils/constants.js';
-import { affiliateBpsToNumber, calculateRate, slippageDecimalToBps, tonAddressToOmnistonAddress, validateTonAssets, waitForQuote, } from '../utils/helpers.js';
-import { omnistonManager } from '../utils/omnistonManager.js';
-const buildStonfiSpecific = (quote, bidAssetAddress, askAssetAddress) => ({
-    quoteId: quote.quoteId,
-    resolverId: quote.resolverId,
-    resolverName: quote.resolverName,
-    tradeStartDeadline: quote.tradeStartDeadline,
-    gasBudget: quote.gasBudget,
-    bidAssetAddress: quote.bidAssetAddress ?? bidAssetAddress,
-    askAssetAddress: quote.askAssetAddress ?? askAssetAddress,
-    bidUnits: quote.bidUnits,
-    askUnits: quote.askUnits,
-    referrerAddress: quote.referrerAddress,
-    referrerFeeAsset: quote.referrerFeeAsset,
-    referrerFeeUnits: quote.referrerFeeUnits,
-    protocolFeeAsset: quote.protocolFeeAsset,
-    protocolFeeUnits: quote.protocolFeeUnits,
-    quoteTimestamp: quote.quoteTimestamp,
-    estimatedGasConsumption: quote.estimatedGasConsumption,
-    params: quote.params,
-});
-export const getTradeRate = async (input) => {
-    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, slippageTolerancePercentageDecimal, affiliateBps, } = input;
-    const validation = validateTonAssets(sellAsset, buyAsset);
-    if (!validation.isValid) {
-        return validation.error;
-    }
-    const { bidAssetAddress, askAssetAddress } = validation;
-    const omniston = omnistonManager.getInstance();
-    try {
-        const slippageBps = slippageDecimalToBps(slippageTolerancePercentageDecimal, STONFI_DEFAULT_SLIPPAGE_BPS);
-        const referrerFeeBps = affiliateBpsToNumber(affiliateBps);
-        const tonTreasuryAddress = getTreasuryAddressFromChainId(sellAsset.chainId);
-        const referrerAddress = tonAddressToOmnistonAddress(tonTreasuryAddress);
-        const quoteResult = await waitForQuote(omniston, {
-            settlementMethods: [SettlementMethod.SETTLEMENT_METHOD_SWAP],
-            bidAssetAddress,
-            askAssetAddress,
-            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
-            referrerAddress,
-            referrerFeeBps,
-            settlementParams: {
-                maxPriceSlippageBps: slippageBps,
-                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
-                flexibleReferrerFee: true,
+import { getStonfiStepData } from '../utils/getStonfiStepData.js';
+import { getStonfiTradeContext } from '../utils/getStonfiTradeContext.js';
+export const getTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContext = await getStonfiTradeContext({ input, deps });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = getStonfiStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
             },
-        }, STONFI_QUOTE_TIMEOUT_MS);
-        if (quoteResult.type !== 'success') {
-            return Err(makeSwapErrorRight({
-                message: `[Stonfi] No quote available for this pair`,
-                code: TradeQuoteError.NoRouteFound,
-            }));
-        }
-        const quote = quoteResult.quote;
-        const buyAmountCryptoBaseUnit = quote.askUnits;
-        const networkFeeCryptoBaseUnit = quote.gasBudget;
-        const rate = calculateRate(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
-        const tradeRate = {
-            id: quote.quoteId,
-            rate,
-            receiveAddress,
-            affiliateBps,
-            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
-            quoteOrRate: 'rate',
-            swapperName: SwapperName.Stonfi,
-            steps: [
-                {
-                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    feeData: {
-                        networkFeeCryptoBaseUnit,
-                        protocolFees: undefined,
-                    },
-                    rate,
-                    source: SwapperName.Stonfi,
-                    buyAsset,
-                    sellAsset,
-                    accountNumber: undefined,
-                    allowanceContract: '0x0000000000000000000000000000000000000000',
-                    estimatedExecutionTimeMs: 30000,
-                    stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                        buyAmountCryptoBaseUnit,
-                        isEstimate: true,
-                    }),
-                },
-            ],
-        };
-        return Ok([tradeRate]);
-    }
-    catch (err) {
-        return Err(makeSwapErrorRight({
-            message: `[Stonfi] Error getting rate: ${err}`,
-            code: TradeQuoteError.QueryFailed,
-            cause: err,
-        }));
-    }
+        ],
+    };
+    return Ok([tradeRate]);
 };

package/dist/esm/swappers/StonfiSwapper/types.d.ts

@@ -1,20 +1,36 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
-import type { Result } from '@sniptt/monads';
 import type { Quote } from '@ston-fi/omniston-sdk';
-import type { SwapErrorRight } from '../../types.js';
+import type { GetTonTradeQuoteInput, GetTonTradeRateInput } from '../../types.js';
+export type StonfiTradeQuoteInput = GetTonTradeQuoteInput;
+export type StonfiTradeRateInput = GetTonTradeRateInput;
 export type StonfiSupportedChainId = typeof KnownChainIds.TonMainnet;
 export declare const stonfiSupportedChainIds: readonly [KnownChainIds.TonMainnet];
-export type OmnistonAssetAddress = {
-    blockchain: number;
-    address: string;
+export type StonfiMetadata = {
+    name: 'stonfi';
+    quoteId: string;
 };
-export type TonAssetValidationResult = {
-    isValid: true;
+export type StonfiTransactionData = {
+    quoteId: string;
+    resolverId: string;
+    resolverName: string;
+    tradeStartDeadline: number;
+    gasBudget: string;
     bidAssetAddress: OmnistonAssetAddress;
     askAssetAddress: OmnistonAssetAddress;
-} | {
-    isValid: false;
-    error: Result<never, SwapErrorRight>;
+    bidUnits: string;
+    askUnits: string;
+    referrerAddress?: OmnistonAssetAddress;
+    referrerFeeAsset?: OmnistonAssetAddress;
+    referrerFeeUnits: string;
+    protocolFeeAsset?: OmnistonAssetAddress;
+    protocolFeeUnits: string;
+    quoteTimestamp: number;
+    estimatedGasConsumption: string;
+    params?: unknown;
+};
+export type OmnistonAssetAddress = {
+    blockchain: number;
+    address: string;
 };
 export type QuoteResult = {
     type: 'success';
@@ -39,22 +55,3 @@ export type StonfiQuote = {
     estimatedGasConsumption: string;
     tradeStartDeadline: number;
 };
-export type StonfiTradeSpecific = {
-    quoteId: string;
-    resolverId: string;
-    resolverName: string;
-    tradeStartDeadline: number;
-    gasBudget: string;
-    bidAssetAddress: OmnistonAssetAddress;
-    askAssetAddress: OmnistonAssetAddress;
-    bidUnits: string;
-    askUnits: string;
-    referrerAddress?: OmnistonAssetAddress;
-    referrerFeeAsset?: OmnistonAssetAddress;
-    referrerFeeUnits: string;
-    protocolFeeAsset?: OmnistonAssetAddress;
-    protocolFeeUnits: string;
-    quoteTimestamp: number;
-    estimatedGasConsumption: string;
-    params?: unknown;
-};

package/dist/esm/swappers/StonfiSwapper/utils/constants.d.ts

@@ -3,3 +3,4 @@ export declare const STONFI_SUPPORTED_CHAIN_IDS: readonly [KnownChainIds.TonMain
 export declare const STONFI_WEBSOCKET_URL = "wss://omni-ws.ston.fi";
 export declare const STONFI_DEFAULT_SLIPPAGE_BPS = 100;
 export declare const STONFI_QUOTE_TIMEOUT_MS = 30000;
+export declare const STONFI_TRADE_TRACKING_TIMEOUT_MS = 60000;

package/dist/esm/swappers/StonfiSwapper/utils/constants.js

@@ -3,3 +3,4 @@ export const STONFI_SUPPORTED_CHAIN_IDS = [KnownChainIds.TonMainnet];
 export const STONFI_WEBSOCKET_URL = 'wss://omni-ws.ston.fi';
 export const STONFI_DEFAULT_SLIPPAGE_BPS = 100;
 export const STONFI_QUOTE_TIMEOUT_MS = 30000;
+export const STONFI_TRADE_TRACKING_TIMEOUT_MS = 60000;

package/dist/esm/swappers/StonfiSwapper/utils/getStonfiStepData.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from '@sniptt/monads';
+import type { Quote } from '@ston-fi/omniston-sdk';
+import type { StepDataArgs, SwapErrorRight } from '../../../types.js';
+import type { OmnistonAssetAddress, StonfiTransactionData } from '../types.js';
+type BaseArgs = {
+    quote: Quote;
+    bidAssetAddress: OmnistonAssetAddress;
+    askAssetAddress: OmnistonAssetAddress;
+};
+export type GetStonfiStepDataArgs = StepDataArgs<BaseArgs>;
+type StonfiRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type StonfiQuoteStepData = {
+    networkFeeCryptoBaseUnit: string;
+    stonfiTransactionData: StonfiTransactionData;
+};
+export declare function getStonfiStepData(args: Extract<GetStonfiStepDataArgs, {
+    type: 'rate';
+}>): Result<StonfiRateStepData, SwapErrorRight>;
+export declare function getStonfiStepData(args: Extract<GetStonfiStepDataArgs, {
+    type: 'quote';
+}>): Result<StonfiQuoteStepData, SwapErrorRight>;
+export {};

package/dist/esm/swappers/StonfiSwapper/utils/getStonfiStepData.js

@@ -0,0 +1,14 @@
+import { Ok } from '@sniptt/monads';
+import { buildStonfiSpecific } from './helpers.js';
+export function getStonfiStepData(args) {
+    const { type, quote, bidAssetAddress, askAssetAddress } = args;
+    if (type === 'rate') {
+        const stepData = { networkFeeCryptoBaseUnit: quote.gasBudget };
+        return Ok(stepData);
+    }
+    const stepData = {
+        networkFeeCryptoBaseUnit: quote.gasBudget,
+        stonfiTransactionData: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+    };
+    return Ok(stepData);
+}

package/dist/esm/swappers/StonfiSwapper/utils/getStonfiTradeContext.d.ts

@@ -0,0 +1,15 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { StonfiTradeQuoteInput, StonfiTradeRateInput } from '../types.js';
+import type { GetStonfiStepDataArgs } from './getStonfiStepData.js';
+type StonfiTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetStonfiStepDataArgs, 'type' | 'input' | 'from'>;
+};
+export declare const getStonfiTradeContext: ({ input, deps, }: {
+    input: StonfiTradeQuoteInput | StonfiTradeRateInput;
+    deps: SwapperDeps;
+}) => Promise<Result<StonfiTradeContext, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/StonfiSwapper/utils/getStonfiTradeContext.js

@@ -0,0 +1,97 @@
+import { tonChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { SettlementMethod } from '@ston-fi/omniston-sdk';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
+import { STONFI_DEFAULT_SLIPPAGE_BPS, STONFI_QUOTE_TIMEOUT_MS } from './constants.js';
+import { affiliateBpsToNumber, assertValidTrade, calculateRate, slippageDecimalToBps, tonAddressToOmnistonAddress, waitForQuote, } from './helpers.js';
+import { omnistonManager } from './omnistonManager.js';
+export const getStonfiTradeContext = async ({ input, deps, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { bidAssetAddress, askAssetAddress } = assertion.unwrap();
+    try {
+        const slippageBps = slippageDecimalToBps(slippageTolerancePercentageDecimal, STONFI_DEFAULT_SLIPPAGE_BPS);
+        const referrerFeeBps = affiliateBpsToNumber(affiliateBps);
+        const referrerAddress = tonAddressToOmnistonAddress(getTreasuryAddressFromChainId(tonChainId));
+        const quoteResult = await waitForQuote(omnistonManager.getInstance(), {
+            settlementMethods: [SettlementMethod.SETTLEMENT_METHOD_SWAP],
+            bidAssetAddress,
+            askAssetAddress,
+            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+            referrerAddress,
+            referrerFeeBps,
+            settlementParams: {
+                maxPriceSlippageBps: slippageBps,
+                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
+                flexibleReferrerFee: true,
+            },
+        }, STONFI_QUOTE_TIMEOUT_MS);
+        if (quoteResult.type === 'error') {
+            console.error('[Stonfi] Quote request error:', quoteResult.error);
+            return Err(makeSwapErrorRight({
+                message: `[Stonfi] Connection error while fetching quote`,
+                code: TradeQuoteError.QueryFailed,
+                cause: quoteResult.error,
+            }));
+        }
+        if (quoteResult.type === 'timeout') {
+            return Err(makeSwapErrorRight({
+                message: `[Stonfi] Quote request timed out`,
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        if (quoteResult.type === 'noQuote') {
+            return Err(makeSwapErrorRight({
+                message: `[Stonfi] No quote available for this pair`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const { quote } = quoteResult;
+        const buyAmountCryptoBaseUnit = quote.askUnits;
+        const rate = calculateRate(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
+        return Ok({
+            tradeCommon: {
+                id: quote.quoteId,
+                rate,
+                affiliateBps,
+                slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
+                swapperName: SwapperName.Stonfi,
+            },
+            stepCommon: {
+                buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                rate,
+                source: SwapperName.Stonfi,
+                buyAsset,
+                sellAsset,
+                allowanceContract: '',
+                estimatedExecutionTimeMs: 30000,
+                swapperMetadata: { name: 'stonfi', quoteId: quote.quoteId },
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit,
+                    isEstimate: true,
+                }),
+            },
+            protocolFees: undefined,
+            stepDataArgs: { deps, sellAsset, quote, bidAssetAddress, askAssetAddress },
+        });
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: `[Stonfi] Error getting quote: ${err}`,
+            code: TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};

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

@@ -1,11 +1,28 @@
 import type { Asset } from '@shapeshiftoss/types';
-import type { Omniston, QuoteRequest } from '@ston-fi/omniston-sdk';
-import type { OmnistonAssetAddress, QuoteResult, TonAssetValidationResult } from '../types.js';
+import type { Result } from '@sniptt/monads';
+import type { Omniston, Quote, QuoteRequest, TradeStatus as OmnistonTradeStatus } from '@ston-fi/omniston-sdk';
+import type { SwapErrorRight } from '../../../types.js';
+import type { OmnistonAssetAddress, QuoteResult, StonfiTransactionData } from '../types.js';
 export declare const isTonAsset: (asset: Asset) => boolean;
 export declare const assetToOmnistonAddress: (asset: Asset) => OmnistonAssetAddress | null;
-export declare const validateTonAssets: (sellAsset: Asset, buyAsset: Asset) => TonAssetValidationResult;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    bidAssetAddress: OmnistonAssetAddress;
+    askAssetAddress: OmnistonAssetAddress;
+}, SwapErrorRight>;
 export declare const calculateRate: (buyAmountCryptoBaseUnit: string, sellAmountCryptoBaseUnit: string, buyAssetPrecision: number, sellAssetPrecision: number) => string;
 export declare const slippageDecimalToBps: (slippageTolerancePercentageDecimal: string | undefined, defaultSlippageBps: number) => number;
 export declare const tonAddressToOmnistonAddress: (address: string) => OmnistonAssetAddress;
 export declare const affiliateBpsToNumber: (affiliateBps: string | undefined) => number;
+export declare const buildStonfiSpecific: (quote: Quote, bidAssetAddress: OmnistonAssetAddress, askAssetAddress: OmnistonAssetAddress) => StonfiTransactionData;
 export declare const waitForQuote: (omniston: Omniston, request: QuoteRequest, timeoutMs: number) => Promise<QuoteResult>;
+export declare const waitForFirstTradeStatus: (request: {
+    quoteId: string;
+    traderWalletAddress: {
+        blockchain: number;
+        address: string;
+    };
+    outgoingTxHash: string;
+}, timeoutMs: number) => Promise<OmnistonTradeStatus | null>;