@shapeshiftoss/swapper 17.8.0 → 19.0.0

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>;

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

@@ -1,10 +1,11 @@
 import { fromAssetId } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
 import { bn, convertPrecision } from '@shapeshiftoss/utils';
-import { Err } from '@sniptt/monads';
+import { Err, Ok } from '@sniptt/monads';
 import { Blockchain } from '@ston-fi/omniston-sdk';
 import { TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { omnistonManager } from './omnistonManager.js';
 export const isTonAsset = (asset) => {
     return asset.chainId === KnownChainIds.TonMainnet;
 };
@@ -23,41 +24,28 @@ export const assetToOmnistonAddress = (asset) => {
     }
     return null;
 };
-export const validateTonAssets = (sellAsset, buyAsset) => {
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
     if (sellAsset.chainId !== KnownChainIds.TonMainnet) {
-        return {
-            isValid: false,
-            error: Err(makeSwapErrorRight({
-                message: `[Stonfi] Unsupported sell asset chain: ${sellAsset.chainId}`,
-                code: TradeQuoteError.UnsupportedChain,
-            })),
-        };
+        return Err(makeSwapErrorRight({
+            message: `[Stonfi] Unsupported sell asset chain: ${sellAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
     }
     if (buyAsset.chainId !== KnownChainIds.TonMainnet) {
-        return {
-            isValid: false,
-            error: Err(makeSwapErrorRight({
-                message: `[Stonfi] Cross-chain swaps not supported`,
-                code: TradeQuoteError.CrossChainNotSupported,
-            })),
-        };
+        return Err(makeSwapErrorRight({
+            message: `[Stonfi] Cross-chain swaps not supported`,
+            code: TradeQuoteError.CrossChainNotSupported,
+        }));
     }
     const bidAssetAddress = assetToOmnistonAddress(sellAsset);
     const askAssetAddress = assetToOmnistonAddress(buyAsset);
     if (!bidAssetAddress || !askAssetAddress) {
-        return {
-            isValid: false,
-            error: Err(makeSwapErrorRight({
-                message: `[Stonfi] Unable to convert assets to Omniston addresses`,
-                code: TradeQuoteError.UnsupportedTradePair,
-            })),
-        };
+        return Err(makeSwapErrorRight({
+            message: `[Stonfi] Unable to convert assets to Omniston addresses`,
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
     }
-    return {
-        isValid: true,
-        bidAssetAddress,
-        askAssetAddress,
-    };
+    return Ok({ bidAssetAddress, askAssetAddress });
 };
 export const calculateRate = (buyAmountCryptoBaseUnit, sellAmountCryptoBaseUnit, buyAssetPrecision, sellAssetPrecision) => {
     if (bn(buyAmountCryptoBaseUnit).gt(0) && bn(sellAmountCryptoBaseUnit).gt(0)) {
@@ -95,6 +83,25 @@ export const affiliateBpsToNumber = (affiliateBps) => {
         return 0;
     return parsed;
 };
+export 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 waitForQuote = (omniston, request, timeoutMs) => {
     return new Promise(resolve => {
         const timer = setTimeout(() => {
@@ -122,3 +129,24 @@ export const waitForQuote = (omniston, request, timeoutMs) => {
         });
     });
 };
+export const waitForFirstTradeStatus = (request, timeoutMs) => {
+    const omniston = 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);
+            },
+        });
+    });
+};

package/dist/esm/swappers/SunioSwapper/SunioSwapper.js

@@ -1,4 +1,4 @@
-import { executeTronTransaction } from '../../utils.js';
+import { executeTronTransaction } from '../../utils/index.js';
 export const sunioSwapper = {
     executeTronTransaction,
 };

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

@@ -2,7 +2,7 @@ import { tronAssetId, tronChainId } from '@shapeshiftoss/caip';
 import { toAddressNList } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { TronWeb } from 'tronweb';
-import { createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils/index.js';
 import { getSunioTradeQuote } from './getSunioTradeQuote/getSunioTradeQuote.js';
 import { getSunioTradeRate } from './getSunioTradeRate/getSunioTradeRate.js';
 import { buildSwapExactInputParameters, SUNIO_SWAP_EXACT_INPUT_SELECTOR, } from './utils/buildSwapContractCall.js';
@@ -11,14 +11,8 @@ import { SUNIO_SMART_ROUTER_CONTRACT } from './utils/constants.js';
 import { getSunioTransactionFees } from './utils/getSunioTransactionFees.js';
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 export const sunioApi = {
-    getTradeQuote: async (input, deps) => {
-        const maybeTradeQuote = await getSunioTradeQuote(input, deps);
-        return maybeTradeQuote.map(quote => [quote]);
-    },
-    getTradeRate: async (input, deps) => {
-        const maybeTradeRate = await getSunioTradeRate(input, deps);
-        return maybeTradeRate.map(rate => [rate]);
-    },
+    getTradeQuote: (input, deps) => getSunioTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getSunioTradeRate(input, deps),
     getUnsignedTronTransaction: async (args) => {
         const { tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, config, } = args;
         if (!isExecutableTradeQuote(tradeQuote)) {
@@ -26,10 +20,9 @@ export const sunioApi = {
         }
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
         const adapter = assertGetTronChainAdapter(tronChainId);
-        const sunioMetadata = step.sunioTransactionMetadata;
-        if (!sunioMetadata) {
-            throw new Error('[Sun.io] Missing transaction metadata in quote');
-        }
+        const sunioTransactionData = step.sunioTransactionData;
+        if (!sunioTransactionData)
+            throw new Error('[Sun.io] Missing transaction data in quote');
         const rpcUrl = adapter.httpProvider.getRpcUrl();
         const tronWeb = new TronWeb({
             fullHost: rpcUrl,
@@ -37,7 +30,7 @@ export const sunioApi = {
                 ? { 'TRON-PRO-API-KEY': config.VITE_TRON_GRID_API_KEY }
                 : {},
         });
-        const routeParams = buildSwapRouteParameters(sunioMetadata.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, tradeQuote.receiveAddress, slippageTolerancePercentageDecimal);
+        const routeParams = buildSwapRouteParameters(sunioTransactionData.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, tradeQuote.receiveAddress, slippageTolerancePercentageDecimal);
         const parameters = buildSwapExactInputParameters(routeParams);
         const isSellingNativeTrx = step.sellAsset.assetId === tronAssetId;
         const callValue = isSellingNativeTrx

package/dist/esm/swappers/SunioSwapper/getSunioTradeQuote/getSunioTradeQuote.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { CommonTradeQuoteInput, GetTronTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
-export declare const getSunioTradeQuote: (input: GetTronTradeQuoteInput | CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { SunioTradeQuoteInput } from '../types.js';
+export declare const getSunioTradeQuote: (input: SunioTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/SunioSwapper/getSunioTradeQuote/getSunioTradeQuote.js

@@ -1,4 +1,40 @@
-import { getQuoteOrRate } from '../utils/getQuoteOrRate.js';
-export const getSunioTradeQuote = (input, deps) => {
-    return getQuoteOrRate(input, deps);
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
+import { getSunioStepData } from '../utils/getSunioStepData.js';
+import { getSunioTradeContext } from '../utils/getSunioTradeContext.js';
+export const getSunioTradeQuote = 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 getSunioTradeContext({ input, deps });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getSunioStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit, sunioTransactionData } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                sunioTransactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
 };

package/dist/esm/swappers/SunioSwapper/getSunioTradeRate/getSunioTradeRate.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
-export declare const getSunioTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { SunioTradeRateInput } from '../types.js';
+export declare const getSunioTradeRate: (input: SunioTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/SunioSwapper/getSunioTradeRate/getSunioTradeRate.js

@@ -1,4 +1,27 @@
-import { getQuoteOrRate } from '../utils/getQuoteOrRate.js';
-export const getSunioTradeRate = (input, deps) => {
-    return getQuoteOrRate(input, deps);
+import { Err, Ok } from '@sniptt/monads';
+import { getSunioStepData } from '../utils/getSunioStepData.js';
+import { getSunioTradeContext } from '../utils/getSunioTradeContext.js';
+export const getSunioTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContext = await getSunioTradeContext({ input, deps });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getSunioStepData({ ...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 },
+            },
+        ],
+    };
+    return Ok([tradeRate]);
 };

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

@@ -1,5 +1,8 @@
 import type { tronChainId } from '@shapeshiftoss/caip';
+import type { GetTronTradeQuoteInput, GetTronTradeRateInput } from '../../types.js';
 export type SunioSupportedChainId = typeof tronChainId;
+export type SunioTradeQuoteInput = GetTronTradeQuoteInput;
+export type SunioTradeRateInput = GetTronTradeRateInput;
 export type SunioRoute = {
     amountIn: string;
     amountOut: string;
@@ -13,6 +16,9 @@ export type SunioRoute = {
     poolVersions: string[];
     stepAmountsOut: string[];
 };
+export type SunioTransactionData = {
+    route: SunioRoute;
+};
 export type SunioQuoteResponse = {
     code: number;
     message: string;

package/dist/esm/swappers/SunioSwapper/utils/fetchFromSunio.js

@@ -1,8 +1,8 @@
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
 import { SUNIO_API_BASE_URL, SUNIO_DEX_TYPES } from './constants.js';
-import { assetIdToTronToken } from './helpers/helpers.js';
+import { assetIdToTronToken } from './helpers.js';
 export const fetchSunioQuote = async (params, service) => {
     try {
         const { sellAssetId, buyAssetId, sellAmountCryptoBaseUnit } = params;

package/dist/esm/swappers/SunioSwapper/utils/getSunioStepData.d.ts

@@ -0,0 +1,21 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight } from '../../../types.js';
+import type { SunioRoute, SunioTransactionData } from '../types.js';
+type BaseArgs = {
+    route: SunioRoute;
+};
+export type GetSunioStepDataArgs = StepDataArgs<BaseArgs>;
+type SunioRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type SunioQuoteStepData = {
+    networkFeeCryptoBaseUnit: string;
+    sunioTransactionData: SunioTransactionData;
+};
+export declare function getSunioStepData(args: Extract<GetSunioStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<SunioRateStepData, SwapErrorRight>>;
+export declare function getSunioStepData(args: Extract<GetSunioStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<SunioQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/SunioSwapper/utils/getSunioStepData.js

@@ -0,0 +1,39 @@
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
+import { estimateSunioNetworkFeeCryptoBaseUnit } from './estimateSunioNetworkFee.js';
+export async function getSunioStepData(args) {
+    const { type, route, sellAsset, from, input, deps } = args;
+    const estimateArgs = {
+        rpcUrl: deps.config.VITE_TRON_NODE_URL,
+        apiKey: deps.config.VITE_TRON_GRID_API_KEY,
+        route,
+        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        isSellingNativeTrx: !contractAddressOrUndefined(sellAsset.assetId),
+        address: from,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    if (type === 'rate') {
+        const networkFeeCryptoBaseUnit = await (async () => {
+            try {
+                return await estimateSunioNetworkFeeCryptoBaseUnit(estimateArgs);
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const stepData = { networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    try {
+        const networkFeeCryptoBaseUnit = await estimateSunioNetworkFeeCryptoBaseUnit(estimateArgs);
+        const stepData = {
+            networkFeeCryptoBaseUnit,
+            sunioTransactionData: { route },
+        };
+        return Ok(stepData);
+    }
+    catch (error) {
+        return Err(makeNetworkFeeEstimationFailedErr('getSunioStepData', error));
+    }
+}

package/dist/esm/swappers/SunioSwapper/utils/getSunioTradeContext.d.ts

@@ -0,0 +1,15 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { SunioTradeQuoteInput, SunioTradeRateInput } from '../types.js';
+import type { GetSunioStepDataArgs } from './getSunioStepData.js';
+type SunioTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetSunioStepDataArgs, 'type' | 'input' | 'from'>;
+};
+export declare const getSunioTradeContext: ({ input, deps, }: {
+    input: SunioTradeQuoteInput | SunioTradeRateInput;
+    deps: SwapperDeps;
+}) => Promise<Result<SunioTradeContext, SwapErrorRight>>;
+export {};