@shapeshiftoss/swapper 17.8.0 → 18.1.0

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForQuote = exports.affiliateBpsToNumber = exports.tonAddressToOmnistonAddress = exports.slippageDecimalToBps = exports.calculateRate = exports.validateTonAssets = exports.assetToOmnistonAddress = exports.isTonAsset = void 0;
+exports.waitForFirstTradeStatus = exports.waitForQuote = exports.buildStonfiSpecific = exports.affiliateBpsToNumber = exports.tonAddressToOmnistonAddress = exports.slippageDecimalToBps = exports.calculateRate = exports.assertValidTrade = exports.assetToOmnistonAddress = exports.isTonAsset = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const types_1 = require("@shapeshiftoss/types");
 const utils_1 = require("@shapeshiftoss/utils");
@@ -8,6 +8,7 @@ const monads_1 = require("@sniptt/monads");
 const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
 const types_2 = require("../../../types");
 const utils_2 = require("../../../utils");
+const omnistonManager_1 = require("./omnistonManager");
 const isTonAsset = (asset) => {
     return asset.chainId === types_1.KnownChainIds.TonMainnet;
 };
@@ -28,43 +29,30 @@ const assetToOmnistonAddress = (asset) => {
     return null;
 };
 exports.assetToOmnistonAddress = assetToOmnistonAddress;
-const validateTonAssets = (sellAsset, buyAsset) => {
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
     if (sellAsset.chainId !== types_1.KnownChainIds.TonMainnet) {
-        return {
-            isValid: false,
-            error: (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-                message: `[Stonfi] Unsupported sell asset chain: ${sellAsset.chainId}`,
-                code: types_2.TradeQuoteError.UnsupportedChain,
-            })),
-        };
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[Stonfi] Unsupported sell asset chain: ${sellAsset.chainId}`,
+            code: types_2.TradeQuoteError.UnsupportedChain,
+        }));
     }
     if (buyAsset.chainId !== types_1.KnownChainIds.TonMainnet) {
-        return {
-            isValid: false,
-            error: (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-                message: `[Stonfi] Cross-chain swaps not supported`,
-                code: types_2.TradeQuoteError.CrossChainNotSupported,
-            })),
-        };
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[Stonfi] Cross-chain swaps not supported`,
+            code: types_2.TradeQuoteError.CrossChainNotSupported,
+        }));
     }
     const bidAssetAddress = (0, exports.assetToOmnistonAddress)(sellAsset);
     const askAssetAddress = (0, exports.assetToOmnistonAddress)(buyAsset);
     if (!bidAssetAddress || !askAssetAddress) {
-        return {
-            isValid: false,
-            error: (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-                message: `[Stonfi] Unable to convert assets to Omniston addresses`,
-                code: types_2.TradeQuoteError.UnsupportedTradePair,
-            })),
-        };
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[Stonfi] Unable to convert assets to Omniston addresses`,
+            code: types_2.TradeQuoteError.UnsupportedTradePair,
+        }));
     }
-    return {
-        isValid: true,
-        bidAssetAddress,
-        askAssetAddress,
-    };
+    return (0, monads_1.Ok)({ bidAssetAddress, askAssetAddress });
 };
-exports.validateTonAssets = validateTonAssets;
+exports.assertValidTrade = assertValidTrade;
 const calculateRate = (buyAmountCryptoBaseUnit, sellAmountCryptoBaseUnit, buyAssetPrecision, sellAssetPrecision) => {
     if ((0, utils_1.bn)(buyAmountCryptoBaseUnit).gt(0) && (0, utils_1.bn)(sellAmountCryptoBaseUnit).gt(0)) {
         return (0, utils_1.convertPrecision)({
@@ -105,6 +93,26 @@ const affiliateBpsToNumber = (affiliateBps) => {
     return parsed;
 };
 exports.affiliateBpsToNumber = affiliateBpsToNumber;
+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,
+});
+exports.buildStonfiSpecific = buildStonfiSpecific;
 const waitForQuote = (omniston, request, timeoutMs) => {
     return new Promise(resolve => {
         const timer = setTimeout(() => {
@@ -133,3 +141,25 @@ const waitForQuote = (omniston, request, timeoutMs) => {
     });
 };
 exports.waitForQuote = waitForQuote;
+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.waitForFirstTradeStatus = waitForFirstTradeStatus;

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

@@ -14,14 +14,8 @@ const constants_1 = require("./utils/constants");
 const getSunioTransactionFees_1 = require("./utils/getSunioTransactionFees");
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 exports.sunioApi = {
-    getTradeQuote: async (input, deps) => {
-        const maybeTradeQuote = await (0, getSunioTradeQuote_1.getSunioTradeQuote)(input, deps);
-        return maybeTradeQuote.map(quote => [quote]);
-    },
-    getTradeRate: async (input, deps) => {
-        const maybeTradeRate = await (0, getSunioTradeRate_1.getSunioTradeRate)(input, deps);
-        return maybeTradeRate.map(rate => [rate]);
-    },
+    getTradeQuote: (input, deps) => (0, getSunioTradeQuote_1.getSunioTradeQuote)(input, deps),
+    getTradeRate: (input, deps) => (0, getSunioTradeRate_1.getSunioTradeRate)(input, deps),
     getUnsignedTronTransaction: async (args) => {
         const { tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, config, } = args;
         if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote)) {
@@ -29,10 +23,9 @@ exports.sunioApi = {
         }
         const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
         const adapter = assertGetTronChainAdapter(caip_1.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_1.TronWeb({
             fullHost: rpcUrl,
@@ -40,7 +33,7 @@ exports.sunioApi = {
                 ? { 'TRON-PRO-API-KEY': config.VITE_TRON_GRID_API_KEY }
                 : {},
         });
-        const routeParams = (0, buildSwapRouteParameters_1.buildSwapRouteParameters)(sunioMetadata.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, tradeQuote.receiveAddress, slippageTolerancePercentageDecimal);
+        const routeParams = (0, buildSwapRouteParameters_1.buildSwapRouteParameters)(sunioTransactionData.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, tradeQuote.receiveAddress, slippageTolerancePercentageDecimal);
         const parameters = (0, buildSwapContractCall_1.buildSwapExactInputParameters)(routeParams);
         const isSellingNativeTrx = step.sellAsset.assetId === caip_1.tronAssetId;
         const callValue = isSellingNativeTrx

package/dist/cjs/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';
-export declare const getSunioTradeQuote: (input: GetTronTradeQuoteInput | CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types';
+import type { SunioTradeQuoteInput } from '../types';
+export declare const getSunioTradeQuote: (input: SunioTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -1,8 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSunioTradeQuote = void 0;
-const getQuoteOrRate_1 = require("../utils/getQuoteOrRate");
-const getSunioTradeQuote = (input, deps) => {
-    return (0, getQuoteOrRate_1.getQuoteOrRate)(input, deps);
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const getSunioStepData_1 = require("../utils/getSunioStepData");
+const getSunioTradeContext_1 = require("../utils/getSunioTradeContext");
+const getSunioTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const addresses = (0, utils_1.assertQuoteAddresses)(input);
+    if (addresses.isErr())
+        return (0, monads_1.Err)(addresses.unwrapErr());
+    const { sendAddress, receiveAddress } = addresses.unwrap();
+    const maybeContext = await (0, getSunioTradeContext_1.getSunioTradeContext)({ input, deps });
+    if (maybeContext.isErr())
+        return (0, monads_1.Err)(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await (0, getSunioStepData_1.getSunioStepData)({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+    });
+    if (maybeStepData.isErr())
+        return (0, monads_1.Err)(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit, sunioTransactionData } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                sunioTransactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return (0, monads_1.Ok)([tradeQuote]);
 };
 exports.getSunioTradeQuote = getSunioTradeQuote;

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

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

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

@@ -1,8 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSunioTradeRate = void 0;
-const getQuoteOrRate_1 = require("../utils/getQuoteOrRate");
-const getSunioTradeRate = (input, deps) => {
-    return (0, getQuoteOrRate_1.getQuoteOrRate)(input, deps);
+const monads_1 = require("@sniptt/monads");
+const getSunioStepData_1 = require("../utils/getSunioStepData");
+const getSunioTradeContext_1 = require("../utils/getSunioTradeContext");
+const getSunioTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContext = await (0, getSunioTradeContext_1.getSunioTradeContext)({ input, deps });
+    if (maybeContext.isErr())
+        return (0, monads_1.Err)(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await (0, getSunioStepData_1.getSunioStepData)({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return (0, monads_1.Err)(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return (0, monads_1.Ok)([tradeRate]);
 };
 exports.getSunioTradeRate = getSunioTradeRate;

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

@@ -1,5 +1,8 @@
 import type { tronChainId } from '@shapeshiftoss/caip';
+import type { GetTronTradeQuoteInput, GetTronTradeRateInput } from '../../types';
 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/cjs/swappers/SunioSwapper/utils/fetchFromSunio.js

@@ -5,7 +5,7 @@ const monads_1 = require("@sniptt/monads");
 const types_1 = require("../../../types");
 const utils_1 = require("../../../utils");
 const constants_1 = require("./constants");
-const helpers_1 = require("./helpers/helpers");
+const helpers_1 = require("./helpers");
 const fetchSunioQuote = async (params, service) => {
     try {
         const { sellAssetId, buyAssetId, sellAmountCryptoBaseUnit } = params;

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

@@ -0,0 +1,21 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight } from '../../../types';
+import type { SunioRoute, SunioTransactionData } from '../types';
+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/cjs/swappers/SunioSwapper/utils/getSunioStepData.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSunioStepData = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const utils_2 = require("../../../utils");
+const estimateSunioNetworkFee_1 = require("./estimateSunioNetworkFee");
+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: !(0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+        address: from,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    if (type === 'rate') {
+        const networkFeeCryptoBaseUnit = await (async () => {
+            try {
+                return await (0, estimateSunioNetworkFee_1.estimateSunioNetworkFeeCryptoBaseUnit)(estimateArgs);
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const stepData = { networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    try {
+        const networkFeeCryptoBaseUnit = await (0, estimateSunioNetworkFee_1.estimateSunioNetworkFeeCryptoBaseUnit)(estimateArgs);
+        const stepData = {
+            networkFeeCryptoBaseUnit,
+            sunioTransactionData: { route },
+        };
+        return (0, monads_1.Ok)(stepData);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getSunioStepData', error));
+    }
+}
+exports.getSunioStepData = getSunioStepData;

package/dist/cjs/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';
+import type { SunioTradeQuoteInput, SunioTradeRateInput } from '../types';
+import type { GetSunioStepDataArgs } from './getSunioStepData';
+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 {};

package/dist/cjs/swappers/SunioSwapper/utils/getSunioTradeContext.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSunioTradeContext = 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 constants_1 = require("./constants");
+const fetchFromSunio_1 = require("./fetchFromSunio");
+const helpers_1 = require("./helpers");
+const sunioService_1 = require("./sunioService");
+const getSunioTradeContext = async ({ input, deps, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const assertion = (0, helpers_1.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    try {
+        const maybeQuoteResponse = await (0, fetchFromSunio_1.fetchSunioQuote)({
+            sellAssetId: sellAsset.assetId,
+            buyAssetId: buyAsset.assetId,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        }, (0, sunioService_1.sunioServiceFactory)());
+        if (maybeQuoteResponse.isErr())
+            return (0, monads_1.Err)(maybeQuoteResponse.unwrapErr());
+        const bestRoute = maybeQuoteResponse.unwrap().data[0];
+        if (!bestRoute) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: '[Sun.io] No routes available',
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const buyAmountCryptoBaseUnit = utils_1.BigAmount.fromPrecision({
+            value: bestRoute.amountOut,
+            precision: buyAsset.precision,
+        }).toBaseUnit();
+        const rate = (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const protocolFeeCryptoBaseUnit = (0, utils_1.bn)(bestRoute.fee)
+            .times(sellAmountIncludingProtocolFeesCryptoBaseUnit)
+            .toFixed(0);
+        const protocolFees = (() => {
+            if ((0, utils_1.bn)(protocolFeeCryptoBaseUnit).lte(0))
+                return;
+            return {
+                [sellAsset.assetId]: {
+                    amountCryptoBaseUnit: protocolFeeCryptoBaseUnit,
+                    requiresBalance: false,
+                    asset: sellAsset,
+                },
+            };
+        })();
+        return (0, monads_1.Ok)({
+            tradeCommon: {
+                id: crypto.randomUUID(),
+                rate,
+                affiliateBps,
+                slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? constants_1.DEFAULT_SLIPPAGE_PERCENTAGE,
+                swapperName: types_1.SwapperName.Sunio,
+            },
+            stepCommon: {
+                buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                rate,
+                source: types_1.SwapperName.Sunio,
+                buyAsset,
+                sellAsset,
+                allowanceContract: constants_1.SUNIO_SMART_ROUTER_CONTRACT,
+                estimatedExecutionTimeMs: undefined,
+                affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit,
+                    isEstimate: true,
+                }),
+            },
+            protocolFees,
+            stepDataArgs: { deps, sellAsset, route: bestRoute },
+        });
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[Sun.io] Failed to get trade',
+            code: types_1.TradeQuoteError.UnknownError,
+            cause: error,
+        }));
+    }
+};
+exports.getSunioTradeContext = getSunioTradeContext;

package/dist/cjs/swappers/SunioSwapper/utils/getSunioTransactionFees.js

@@ -9,7 +9,7 @@ const getSunioTransactionFees = async ({ tradeQuote, stepIndex, from, slippageTo
         throw new Error('Unable to execute a trade rate quote');
     const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
     const storedNetworkFeeCryptoBaseUnit = step.feeData.networkFeeCryptoBaseUnit;
-    const route = step.sunioTransactionMetadata?.route;
+    const route = step.sunioTransactionData?.route;
     if (!route) {
         if (!storedNetworkFeeCryptoBaseUnit)
             throw new Error('Missing network fee in quote');

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

@@ -0,0 +1,10 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+export declare const isSupportedChainId: (chainId: string) => boolean;
+export declare const assetIdToTronToken: (assetId: AssetId) => string;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<void, SwapErrorRight>;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidTrade = exports.assetIdToTronToken = exports.isSupportedChainId = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_1 = require("./constants");
+const isSupportedChainId = (chainId) => {
+    return constants_1.SUNIO_SUPPORTED_CHAIN_IDS.includes(chainId);
+};
+exports.isSupportedChainId = isSupportedChainId;
+const assetIdToTronToken = (assetId) => {
+    if ((0, utils_1.isToken)(assetId)) {
+        const { assetReference } = (0, caip_1.fromAssetId)(assetId);
+        return assetReference;
+    }
+    return constants_1.SUNIO_TRON_NATIVE_ADDRESS;
+};
+exports.assetIdToTronToken = assetIdToTronToken;
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (!(0, exports.isSupportedChainId)(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[${types_1.SwapperName.Sunio}] Unsupported chainId: ${sellAsset.chainId}`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (sellAsset.chainId !== buyAsset.chainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[${types_1.SwapperName.Sunio}] Cross-chain not supported`,
+            code: types_1.TradeQuoteError.CrossChainNotSupported,
+        }));
+    }
+    if (sellAsset.chainId !== caip_1.tronChainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[${types_1.SwapperName.Sunio}] Only TRON chain supported`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return (0, monads_1.Ok)(undefined);
+};
+exports.assertValidTrade = assertValidTrade;

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

@@ -1,85 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.thorchainApi = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const thorchain_utils_1 = require("../../thorchain-utils");
 const types_1 = require("../../types");
-const utils_1 = require("../../utils");
+const cosmossdk_1 = require("../../utils/cosmossdk");
+const evm_1 = require("../../utils/evm");
+const solana_1 = require("../../utils/solana");
+const thorchain_1 = require("../../utils/thorchain");
+const utxo_1 = require("../../utils/utxo");
 const getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
 const getTradeRate_1 = require("./getTradeRate/getTradeRate");
 const swapperName = types_1.SwapperName.Thorchain;
 exports.thorchainApi = {
-    getTradeRate: getTradeRate_1.getTradeRate,
-    getTradeQuote: getTradeQuote_1.getTradeQuote,
-    getUnsignedEvmTransaction: input => thorchain_utils_1.evm.getUnsignedEvmTransaction(input, swapperName),
-    getEvmTransactionFees: input => thorchain_utils_1.evm.getEvmTransactionFees(input, swapperName),
-    getUnsignedUtxoTransaction: input => thorchain_utils_1.utxo.getUnsignedUtxoTransaction(input, swapperName),
-    getUtxoTransactionFees: input => thorchain_utils_1.utxo.getUtxoTransactionFees(input, swapperName),
-    getUnsignedSolanaTransaction: input => thorchain_utils_1.solana.getUnsignedSolanaTransaction(input, swapperName),
-    getSolanaTransactionFees: input => thorchain_utils_1.solana.getSolanaTransactionFees(input, swapperName),
-    getUnsignedTronTransaction: input => thorchain_utils_1.tron.getUnsignedTronTransaction(input, swapperName),
-    getTronTransactionFees: input => thorchain_utils_1.tron.getTronTransactionFees(input, swapperName),
-    getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {
-        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const { memo } = tradeQuote;
-        if (!memo)
-            throw new Error('Memo is required');
-        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
-        const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, feeData } = step;
-        const gas = feeData.chainSpecific.estimatedGasCryptoBaseUnit;
-        const fee = feeData.networkFeeCryptoBaseUnit ?? '0';
-        switch (sellAsset.assetId) {
-            case caip_1.thorchainAssetId:
-            case caip_1.rujiAssetId:
-            case caip_1.tcyAssetId: {
-                const coin = (() => {
-                    if (sellAsset.assetId === caip_1.tcyAssetId)
-                        return 'THOR.TCY';
-                    if (sellAsset.assetId === caip_1.rujiAssetId)
-                        return 'THOR.RUJI';
-                    return 'THOR.RUNE';
-                })();
-                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
-                const { txToSign } = await adapter.buildDepositTransaction({
-                    accountNumber,
-                    from,
-                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    memo,
-                    chainSpecific: {
-                        gas,
-                        fee,
-                        coin,
-                    },
-                });
-                return txToSign;
-            }
-            case caip_1.cosmosAssetId: {
-                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
-                const url = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
-                const data = await (0, thorchain_utils_1.getInboundAddressDataForChain)(url, caip_1.cosmosAssetId, true, swapperName);
-                if (data.isErr())
-                    throw data.unwrapErr();
-                const { address: vault } = data.unwrap();
-                const { txToSign } = await adapter.buildSendApiTransaction({
-                    accountNumber,
-                    from,
-                    to: vault,
-                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    memo,
-                    chainSpecific: { gas, fee },
-                });
-                return txToSign;
-            }
-            default:
-                throw Error(`Unsupported sellAsset: ${sellAsset.assetId}`);
-        }
-    },
-    getCosmosSdkTransactionFees: input => thorchain_utils_1.cosmossdk.getCosmosSdkTransactionFees(input),
+    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps),
+    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps),
+    getUnsignedEvmTransaction: evm_1.getUnsignedEvmTransaction,
+    getEvmTransactionFees: evm_1.getEvmTransactionFees,
+    getUnsignedUtxoTransaction: utxo_1.getUnsignedUtxoTransaction,
+    getUtxoTransactionFees: utxo_1.getUtxoTransactionFees,
+    getUnsignedCosmosSdkTransaction: cosmossdk_1.getUnsignedCosmosSdkTransaction,
+    getCosmosSdkTransactionFees: cosmossdk_1.getCosmosSdkTransactionFees,
+    getUnsignedSolanaTransaction: solana_1.getUnsignedSolanaTransaction,
+    getSolanaTransactionFees: solana_1.getSolanaTransactionFees,
+    getUnsignedTronTransaction: input => thorchain_1.tron.getUnsignedTronTransaction(input, swapperName),
+    getTronTransactionFees: input => thorchain_1.tron.getTronTransactionFees(input, swapperName),
     checkTradeStatus: input => {
         const { config } = input;
         const nodeUrl = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
         const apiUrl = `${config.VITE_UNCHAINED_THORCHAIN_HTTP_URL}/api/v1`;
-        return (0, thorchain_utils_1.checkTradeStatus)({ ...input, nodeUrl, apiUrl, nativeChain: 'THOR' });
+        return (0, thorchain_1.checkTradeStatus)({ ...input, nodeUrl, apiUrl, nativeChain: 'THOR' });
     },
 };