@shapeshiftoss/swapper 17.6.9 → 17.6.11

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = void 0;
+const monads_1 = require("@sniptt/monads");
+const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const affiliateFee_1 = require("../../utils/affiliateFee");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_1 = require("../utils/constants");
+const helpers_2 = require("../utils/helpers");
+const omnistonManager_1 = require("../utils/omnistonManager");
+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,
+});
+const getTradeQuote = async (input) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    const validation = (0, helpers_2.validateTonAssets)(sellAsset, buyAsset);
+    if (!validation.isValid) {
+        return validation.error;
+    }
+    const { bidAssetAddress, askAssetAddress } = validation;
+    const omniston = omnistonManager_1.omnistonManager.getInstance();
+    try {
+        const slippageBps = (0, helpers_2.slippageDecimalToBps)(slippageTolerancePercentageDecimal, constants_1.STONFI_DEFAULT_SLIPPAGE_BPS);
+        const referrerFeeBps = (0, helpers_2.affiliateBpsToNumber)(affiliateBps);
+        const tonTreasuryAddress = (0, helpers_1.getTreasuryAddressFromChainId)(sellAsset.chainId);
+        const referrerAddress = (0, helpers_2.tonAddressToOmnistonAddress)(tonTreasuryAddress);
+        const quoteResult = await (0, helpers_2.waitForQuote)(omniston, {
+            settlementMethods: [omniston_sdk_1.SettlementMethod.SETTLEMENT_METHOD_SWAP],
+            bidAssetAddress,
+            askAssetAddress,
+            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+            referrerAddress,
+            referrerFeeBps,
+            settlementParams: {
+                maxPriceSlippageBps: slippageBps,
+                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
+                flexibleReferrerFee: true,
+            },
+        }, constants_1.STONFI_QUOTE_TIMEOUT_MS);
+        if (quoteResult.type === 'error') {
+            console.error('[Stonfi] Quote request error:', quoteResult.error);
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Stonfi] Connection error while fetching quote`,
+                code: types_1.TradeQuoteError.QueryFailed,
+                cause: quoteResult.error,
+            }));
+        }
+        if (quoteResult.type === 'timeout') {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Stonfi] Quote request timed out`,
+                code: types_1.TradeQuoteError.QueryFailed,
+            }));
+        }
+        if (quoteResult.type === 'noQuote') {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Stonfi] No quote available for this pair`,
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const quote = quoteResult.quote;
+        const buyAmountCryptoBaseUnit = quote.askUnits;
+        const networkFeeCryptoBaseUnit = quote.gasBudget;
+        const rate = (0, helpers_2.calculateRate)(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
+        const tradeQuote = {
+            id: quote.quoteId,
+            rate,
+            receiveAddress,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(constants_1.STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
+            quoteOrRate: 'quote',
+            swapperName: types_1.SwapperName.Stonfi,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: undefined,
+                    },
+                    rate,
+                    source: types_1.SwapperName.Stonfi,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: 30000,
+                    stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+                    affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
+                },
+            ],
+        };
+        return (0, monads_1.Ok)([tradeQuote]);
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `[Stonfi] Error getting quote: ${err}`,
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+exports.getTradeQuote = getTradeQuote;

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

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

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRate = void 0;
+const monads_1 = require("@sniptt/monads");
+const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const affiliateFee_1 = require("../../utils/affiliateFee");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_1 = require("../utils/constants");
+const helpers_2 = require("../utils/helpers");
+const omnistonManager_1 = require("../utils/omnistonManager");
+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,
+});
+const getTradeRate = async (input) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    const validation = (0, helpers_2.validateTonAssets)(sellAsset, buyAsset);
+    if (!validation.isValid) {
+        return validation.error;
+    }
+    const { bidAssetAddress, askAssetAddress } = validation;
+    const omniston = omnistonManager_1.omnistonManager.getInstance();
+    try {
+        const slippageBps = (0, helpers_2.slippageDecimalToBps)(slippageTolerancePercentageDecimal, constants_1.STONFI_DEFAULT_SLIPPAGE_BPS);
+        const referrerFeeBps = (0, helpers_2.affiliateBpsToNumber)(affiliateBps);
+        const tonTreasuryAddress = (0, helpers_1.getTreasuryAddressFromChainId)(sellAsset.chainId);
+        const referrerAddress = (0, helpers_2.tonAddressToOmnistonAddress)(tonTreasuryAddress);
+        const quoteResult = await (0, helpers_2.waitForQuote)(omniston, {
+            settlementMethods: [omniston_sdk_1.SettlementMethod.SETTLEMENT_METHOD_SWAP],
+            bidAssetAddress,
+            askAssetAddress,
+            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+            referrerAddress,
+            referrerFeeBps,
+            settlementParams: {
+                maxPriceSlippageBps: slippageBps,
+                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
+                flexibleReferrerFee: true,
+            },
+        }, constants_1.STONFI_QUOTE_TIMEOUT_MS);
+        if (quoteResult.type !== 'success') {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Stonfi] No quote available for this pair`,
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const quote = quoteResult.quote;
+        const buyAmountCryptoBaseUnit = quote.askUnits;
+        const networkFeeCryptoBaseUnit = quote.gasBudget;
+        const rate = (0, helpers_2.calculateRate)(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
+        const tradeRate = {
+            id: quote.quoteId,
+            rate,
+            receiveAddress,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(constants_1.STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
+            quoteOrRate: 'rate',
+            swapperName: types_1.SwapperName.Stonfi,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: undefined,
+                    },
+                    rate,
+                    source: types_1.SwapperName.Stonfi,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber: undefined,
+                    allowanceContract: '0x0000000000000000000000000000000000000000',
+                    estimatedExecutionTimeMs: 30000,
+                    stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+                    affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
+                },
+            ],
+        };
+        return (0, monads_1.Ok)([tradeRate]);
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `[Stonfi] Error getting rate: ${err}`,
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+exports.getTradeRate = getTradeRate;

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

@@ -0,0 +1,60 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { Quote } from '@ston-fi/omniston-sdk';
+import type { SwapErrorRight } from '../../types';
+export type StonfiSupportedChainId = typeof KnownChainIds.TonMainnet;
+export declare const stonfiSupportedChainIds: readonly [KnownChainIds.TonMainnet];
+export type OmnistonAssetAddress = {
+    blockchain: number;
+    address: string;
+};
+export type TonAssetValidationResult = {
+    isValid: true;
+    bidAssetAddress: OmnistonAssetAddress;
+    askAssetAddress: OmnistonAssetAddress;
+} | {
+    isValid: false;
+    error: Result<never, SwapErrorRight>;
+};
+export type QuoteResult = {
+    type: 'success';
+    quote: Quote;
+} | {
+    type: 'noQuote';
+} | {
+    type: 'timeout';
+} | {
+    type: 'error';
+    error: unknown;
+};
+export type StonfiQuote = {
+    quoteId: string;
+    resolverId: string;
+    resolverName: string;
+    bidAssetAddress: string;
+    askAssetAddress: string;
+    bidUnits: string;
+    askUnits: string;
+    gasBudget: string;
+    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/cjs/swappers/StonfiSwapper/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stonfiSupportedChainIds = void 0;
+const types_1 = require("@shapeshiftoss/types");
+exports.stonfiSupportedChainIds = [types_1.KnownChainIds.TonMainnet];

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

@@ -0,0 +1,5 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const STONFI_SUPPORTED_CHAIN_IDS: readonly [KnownChainIds.TonMainnet];
+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;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STONFI_QUOTE_TIMEOUT_MS = exports.STONFI_DEFAULT_SLIPPAGE_BPS = exports.STONFI_WEBSOCKET_URL = exports.STONFI_SUPPORTED_CHAIN_IDS = void 0;
+const types_1 = require("@shapeshiftoss/types");
+exports.STONFI_SUPPORTED_CHAIN_IDS = [types_1.KnownChainIds.TonMainnet];
+exports.STONFI_WEBSOCKET_URL = 'wss://omni-ws.ston.fi';
+exports.STONFI_DEFAULT_SLIPPAGE_BPS = 100;
+exports.STONFI_QUOTE_TIMEOUT_MS = 30000;

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

@@ -0,0 +1,11 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Omniston, QuoteRequest } from '@ston-fi/omniston-sdk';
+import type { OmnistonAssetAddress, QuoteResult, TonAssetValidationResult } from '../types';
+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 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 waitForQuote: (omniston: Omniston, request: QuoteRequest, timeoutMs: number) => Promise<QuoteResult>;

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

@@ -0,0 +1,135 @@
+"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;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("@shapeshiftoss/types");
+const utils_1 = require("@shapeshiftoss/utils");
+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 isTonAsset = (asset) => {
+    return asset.chainId === types_1.KnownChainIds.TonMainnet;
+};
+exports.isTonAsset = isTonAsset;
+const assetToOmnistonAddress = (asset) => {
+    if (!(0, exports.isTonAsset)(asset))
+        return null;
+    const { assetNamespace, assetReference } = (0, caip_1.fromAssetId)(asset.assetId);
+    if (assetNamespace === 'slip44') {
+        return {
+            blockchain: omniston_sdk_1.Blockchain.TON,
+            address: 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c',
+        };
+    }
+    if (assetNamespace === 'jetton') {
+        return { blockchain: omniston_sdk_1.Blockchain.TON, address: assetReference };
+    }
+    return null;
+};
+exports.assetToOmnistonAddress = assetToOmnistonAddress;
+const validateTonAssets = (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,
+            })),
+        };
+    }
+    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,
+            })),
+        };
+    }
+    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 {
+        isValid: true,
+        bidAssetAddress,
+        askAssetAddress,
+    };
+};
+exports.validateTonAssets = validateTonAssets;
+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)({
+            value: buyAmountCryptoBaseUnit,
+            inputExponent: buyAssetPrecision,
+            outputExponent: sellAssetPrecision,
+        })
+            .dividedBy((0, utils_1.bn)(sellAmountCryptoBaseUnit))
+            .toFixed();
+    }
+    return '0';
+};
+exports.calculateRate = calculateRate;
+const slippageDecimalToBps = (slippageTolerancePercentageDecimal, defaultSlippageBps) => {
+    if (!slippageTolerancePercentageDecimal) {
+        return defaultSlippageBps;
+    }
+    const parsed = parseFloat(slippageTolerancePercentageDecimal);
+    if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed < 0) {
+        return defaultSlippageBps;
+    }
+    return Math.round(parsed * 10000);
+};
+exports.slippageDecimalToBps = slippageDecimalToBps;
+const tonAddressToOmnistonAddress = (address) => {
+    return {
+        blockchain: omniston_sdk_1.Blockchain.TON,
+        address,
+    };
+};
+exports.tonAddressToOmnistonAddress = tonAddressToOmnistonAddress;
+const affiliateBpsToNumber = (affiliateBps) => {
+    if (!affiliateBps)
+        return 0;
+    const parsed = parseInt(affiliateBps, 10);
+    if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed < 0)
+        return 0;
+    return parsed;
+};
+exports.affiliateBpsToNumber = affiliateBpsToNumber;
+const waitForQuote = (omniston, request, timeoutMs) => {
+    return new Promise(resolve => {
+        const timer = setTimeout(() => {
+            subscription.unsubscribe();
+            resolve({ type: 'timeout' });
+        }, timeoutMs);
+        const subscription = omniston.requestForQuote(request).subscribe({
+            next: (event) => {
+                if (event.type === 'quoteUpdated' && event.quote) {
+                    clearTimeout(timer);
+                    subscription.unsubscribe();
+                    resolve({ type: 'success', quote: event.quote });
+                }
+                else if (event.type === 'noQuote') {
+                    clearTimeout(timer);
+                    subscription.unsubscribe();
+                    resolve({ type: 'noQuote' });
+                }
+            },
+            error: err => {
+                clearTimeout(timer);
+                subscription.unsubscribe();
+                resolve({ type: 'error', error: err });
+            },
+        });
+    });
+};
+exports.waitForQuote = waitForQuote;

package/dist/cjs/swappers/StonfiSwapper/utils/omnistonManager.d.ts

@@ -0,0 +1,5 @@
+import { Omniston } from '@ston-fi/omniston-sdk';
+export declare const omnistonManager: {
+    getInstance: () => Omniston;
+    disconnect: () => void;
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omnistonManager = void 0;
+const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
+const constants_1 = require("./constants");
+let cachedOmniston = null;
+exports.omnistonManager = {
+    getInstance: () => {
+        if (!cachedOmniston) {
+            cachedOmniston = new omniston_sdk_1.Omniston({ apiUrl: constants_1.STONFI_WEBSOCKET_URL });
+        }
+        return cachedOmniston;
+    },
+    disconnect: () => {
+        if (cachedOmniston) {
+            cachedOmniston.close();
+            cachedOmniston = null;
+        }
+    },
+};

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

@@ -46,7 +46,7 @@ exports.sunioApi = {
         const tronWeb = new tronweb_1.TronWeb({
             fullHost: rpcUrl,
         });
-        const routeParams = (0, buildSwapRouteParameters_1.buildSwapRouteParameters)(sunioMetadata.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, from, slippageTolerancePercentageDecimal);
+        const routeParams = (0, buildSwapRouteParameters_1.buildSwapRouteParameters)(sunioMetadata.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, tradeQuote.receiveAddress, slippageTolerancePercentageDecimal);
         const parameters = [
             { type: 'address[]', value: routeParams.path },
             { type: 'string[]', value: routeParams.poolVersion },

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

@@ -7,6 +7,7 @@ const monads_1 = require("@sniptt/monads");
 const tronweb_1 = require("tronweb");
 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/helpers");
@@ -136,9 +137,10 @@ async function getQuoteOrRate(input, deps) {
                 }
             }
         }
-        const buyAmountCryptoBaseUnit = (0, utils_1.bn)(bestRoute.amountOut)
-            .times((0, utils_1.bn)(10).pow(buyAsset.precision))
-            .toFixed(0);
+        const buyAmountCryptoBaseUnit = utils_1.BigAmount.fromPrecision({
+            value: bestRoute.amountOut,
+            precision: buyAsset.precision,
+        }).toBaseUnit();
         // Calculate protocol fees only for quotes
         const protocolFeeCryptoBaseUnit = isQuote
             ? (0, utils_1.bn)(bestRoute.fee).times(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0)
@@ -186,6 +188,15 @@ async function getQuoteOrRate(input, deps) {
                             route: bestRoute,
                         },
                     }),
+                    affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
             swapperName: types_1.SwapperName.Sunio,

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

@@ -10,6 +10,9 @@ exports.thorchainSwapper = {
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },
+    executeSolanaTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
     executeTronTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

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

@@ -15,6 +15,8 @@ exports.thorchainApi = {
     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, }) => {

package/dist/cjs/swappers/ThorchainSwapper/generated/generatedTradableAssetMap.json

@@ -37,6 +37,7 @@
     "ETH.YFI-0X0BC529C00C6401AEF6D220BE8C6EA1667F6AD93E": "eip155:1/erc20:0x0bc529c00c6401aef6d220be8c6ea1667f6ad93e",
     "GAIA.ATOM": "cosmos:cosmoshub-4/slip44:118",
     "LTC.LTC": "bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2",
+    "SOL.SOL": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/slip44:501",
     "THOR.RUJI": "cosmos:thorchain-1/slip44:ruji",
     "THOR.TCY": "cosmos:thorchain-1/slip44:tcy",
     "TRON.TRX": "tron:0x2b6653dc/slip44:195",

package/dist/cjs/swappers/ThorchainSwapper/utils/poolAssetHelpers/poolAssetHelpers.d.ts

@@ -1,5 +1,5 @@
 import type { AssetId } from '@shapeshiftoss/caip';
-export declare const assetIdToThorPoolAssetIdMap: import("lodash").Dictionary<string>;
+export declare const assetIdToThorPoolAssetIdMap: Record<string, string>;
 export declare const thorPoolAssetIdToAssetId: (id: string) => AssetId | undefined;
 export declare const assetIdToThorPoolAssetId: ({ assetId }: {
     assetId: AssetId;

package/dist/cjs/swappers/ThorchainSwapper/utils/poolAssetHelpers/poolAssetHelpers.js

@@ -8,7 +8,8 @@ const invert_1 = __importDefault(require("lodash/invert"));
 const generatedTradableAssetMap_json_1 = __importDefault(require("../../generated/generatedTradableAssetMap.json"));
 const thorPoolIdAssetIdSymbolMap = generatedTradableAssetMap_json_1.default;
 exports.assetIdToThorPoolAssetIdMap = (0, invert_1.default)(thorPoolIdAssetIdSymbolMap);
+const assetIdToThorPoolAssetIdMapLower = Object.fromEntries(Object.entries(exports.assetIdToThorPoolAssetIdMap).map(([k, v]) => [k.toLowerCase(), v]));
 const thorPoolAssetIdToAssetId = (id) => thorPoolIdAssetIdSymbolMap[id.toUpperCase()];
 exports.thorPoolAssetIdToAssetId = thorPoolAssetIdToAssetId;
-const assetIdToThorPoolAssetId = ({ assetId }) => exports.assetIdToThorPoolAssetIdMap[assetId.toLowerCase()];
+const assetIdToThorPoolAssetId = ({ assetId }) => assetIdToThorPoolAssetIdMapLower[assetId.toLowerCase()];
 exports.assetIdToThorPoolAssetId = assetIdToThorPoolAssetId;

package/dist/cjs/swappers/ThorchainSwapper/utils/poolAssetHelpers/poolAssetHelpers.test.js

@@ -18,6 +18,10 @@ const poolAssetHelpers_1 = require("./poolAssetHelpers");
             const result = (0, poolAssetHelpers_1.thorPoolAssetIdToAssetId)('ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48');
             (0, vitest_1.expect)(result).toEqual(usdcAssetId);
         });
+        (0, vitest_1.it)('returns Solana assetId when poolAssetId is SOL.SOL', () => {
+            const result = (0, poolAssetHelpers_1.thorPoolAssetIdToAssetId)('SOL.SOL');
+            (0, vitest_1.expect)(result).toEqual(caip_1.solAssetId);
+        });
         (0, vitest_1.it)('returns undefined for an asset we dont support', () => {
             const result = (0, poolAssetHelpers_1.thorPoolAssetIdToAssetId)('BNB.AVA-645');
             (0, vitest_1.expect)(result).toEqual(undefined);
@@ -46,6 +50,12 @@ const poolAssetHelpers_1 = require("./poolAssetHelpers");
             const poolAssetId = 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48';
             (0, vitest_1.expect)(result).toEqual(poolAssetId);
         });
+        (0, vitest_1.it)('returns SOL pool when assetId is solAssetId (base58 case-sensitive)', () => {
+            const assetId = caip_1.solAssetId;
+            const result = (0, poolAssetHelpers_1.assetIdToThorPoolAssetId)({ assetId });
+            const poolAssetId = 'SOL.SOL';
+            (0, vitest_1.expect)(result).toEqual(poolAssetId);
+        });
         (0, vitest_1.it)('returns undefined for an unsupported asset', () => {
             const assetId = 'foobar';
             const result = (0, poolAssetHelpers_1.assetIdToThorPoolAssetId)({ assetId });

package/dist/cjs/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.js

@@ -9,6 +9,7 @@ const uuid_1 = require("uuid");
 const constants_1 = require("../../../constants");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../utils/affiliateFee");
 const helpers_1 = require("../../utils/helpers/helpers");
 const fetchFromZrx_1 = require("../utils/fetchFromZrx");
 const helpers_2 = require("../utils/helpers/helpers");
@@ -99,6 +100,14 @@ async function getZrxTradeQuote(input, assertGetEvmChainAdapter, assetsById, zrx
                     buyAmountAfterFeesCryptoBaseUnit: buyAmount,
                     sellAmountIncludingProtocolFeesCryptoBaseUnit,
                     source: types_1.SwapperName.Zrx,
+                    affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmount,
+                    }),
                     permit2Eip712: permit2Eip712,
                     zrxTransactionMetadata: transactionMetadata,
                 },