@shapeshiftoss/swapper 17.6.9 → 17.6.11

package/dist/esm/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.js';
+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/esm/swappers/StonfiSwapper/types.js

@@ -0,0 +1,2 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const stonfiSupportedChainIds = [KnownChainIds.TonMainnet];

package/dist/esm/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/esm/swappers/StonfiSwapper/utils/constants.js

@@ -0,0 +1,5 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const STONFI_SUPPORTED_CHAIN_IDS = [KnownChainIds.TonMainnet];
+export const STONFI_WEBSOCKET_URL = 'wss://omni-ws.ston.fi';
+export const STONFI_DEFAULT_SLIPPAGE_BPS = 100;
+export const STONFI_QUOTE_TIMEOUT_MS = 30000;

package/dist/esm/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.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 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/esm/swappers/StonfiSwapper/utils/helpers.js

@@ -0,0 +1,124 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { bn, convertPrecision } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
+import { Blockchain } from '@ston-fi/omniston-sdk';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+export const isTonAsset = (asset) => {
+    return asset.chainId === KnownChainIds.TonMainnet;
+};
+export const assetToOmnistonAddress = (asset) => {
+    if (!isTonAsset(asset))
+        return null;
+    const { assetNamespace, assetReference } = fromAssetId(asset.assetId);
+    if (assetNamespace === 'slip44') {
+        return {
+            blockchain: Blockchain.TON,
+            address: 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c',
+        };
+    }
+    if (assetNamespace === 'jetton') {
+        return { blockchain: Blockchain.TON, address: assetReference };
+    }
+    return null;
+};
+export const validateTonAssets = (sellAsset, buyAsset) => {
+    if (sellAsset.chainId !== KnownChainIds.TonMainnet) {
+        return {
+            isValid: false,
+            error: 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,
+            })),
+        };
+    }
+    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 {
+        isValid: true,
+        bidAssetAddress,
+        askAssetAddress,
+    };
+};
+export const calculateRate = (buyAmountCryptoBaseUnit, sellAmountCryptoBaseUnit, buyAssetPrecision, sellAssetPrecision) => {
+    if (bn(buyAmountCryptoBaseUnit).gt(0) && bn(sellAmountCryptoBaseUnit).gt(0)) {
+        return convertPrecision({
+            value: buyAmountCryptoBaseUnit,
+            inputExponent: buyAssetPrecision,
+            outputExponent: sellAssetPrecision,
+        })
+            .dividedBy(bn(sellAmountCryptoBaseUnit))
+            .toFixed();
+    }
+    return '0';
+};
+export 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);
+};
+export const tonAddressToOmnistonAddress = (address) => {
+    return {
+        blockchain: Blockchain.TON,
+        address,
+    };
+};
+export 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;
+};
+export 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 });
+            },
+        });
+    });
+};

package/dist/esm/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/esm/swappers/StonfiSwapper/utils/omnistonManager.js

@@ -0,0 +1,17 @@
+import { Omniston } from '@ston-fi/omniston-sdk';
+import { STONFI_WEBSOCKET_URL } from './constants.js';
+let cachedOmniston = null;
+export const omnistonManager = {
+    getInstance: () => {
+        if (!cachedOmniston) {
+            cachedOmniston = new Omniston({ apiUrl: STONFI_WEBSOCKET_URL });
+        }
+        return cachedOmniston;
+    },
+    disconnect: () => {
+        if (cachedOmniston) {
+            cachedOmniston.close();
+            cachedOmniston = null;
+        }
+    },
+};

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

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

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

@@ -1,9 +1,10 @@
 import { tronChainId } from '@shapeshiftoss/caip';
-import { bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { BigAmount, bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TronWeb } from 'tronweb';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { DEFAULT_SLIPPAGE_PERCENTAGE, SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
 import { fetchSunioQuote } from './fetchFromSunio.js';
 import { isSupportedChainId } from './helpers/helpers.js';
@@ -133,9 +134,10 @@ export async function getQuoteOrRate(input, deps) {
                 }
             }
         }
-        const buyAmountCryptoBaseUnit = bn(bestRoute.amountOut)
-            .times(bn(10).pow(buyAsset.precision))
-            .toFixed(0);
+        const buyAmountCryptoBaseUnit = BigAmount.fromPrecision({
+            value: bestRoute.amountOut,
+            precision: buyAsset.precision,
+        }).toBaseUnit();
         // Calculate protocol fees only for quotes
         const protocolFeeCryptoBaseUnit = isQuote
             ? bn(bestRoute.fee).times(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0)
@@ -183,6 +185,15 @@ export async function getQuoteOrRate(input, deps) {
                             route: bestRoute,
                         },
                     }),
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
             swapperName: SwapperName.Sunio,

package/dist/esm/swappers/ThorchainSwapper/ThorchainSwapper.js

@@ -7,6 +7,9 @@ export const thorchainSwapper = {
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },
+    executeSolanaTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
     executeTronTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

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

@@ -1,5 +1,5 @@
 import { cosmosAssetId, rujiAssetId, tcyAssetId, thorchainAssetId } from '@shapeshiftoss/caip';
-import { checkTradeStatus, cosmossdk, evm, getInboundAddressDataForChain, tron, utxo, } from '../../thorchain-utils/index.js';
+import { checkTradeStatus, cosmossdk, evm, getInboundAddressDataForChain, solana, tron, utxo, } from '../../thorchain-utils/index.js';
 import { SwapperName } from '../../types.js';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
@@ -12,6 +12,8 @@ export const thorchainApi = {
     getEvmTransactionFees: input => evm.getEvmTransactionFees(input, swapperName),
     getUnsignedUtxoTransaction: input => utxo.getUnsignedUtxoTransaction(input, swapperName),
     getUtxoTransactionFees: input => utxo.getUtxoTransactionFees(input, swapperName),
+    getUnsignedSolanaTransaction: input => solana.getUnsignedSolanaTransaction(input, swapperName),
+    getSolanaTransactionFees: input => solana.getSolanaTransactionFees(input, swapperName),
     getUnsignedTronTransaction: input => tron.getUnsignedTronTransaction(input, swapperName),
     getTronTransactionFees: input => tron.getTronTransactionFees(input, swapperName),
     getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {

package/dist/esm/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/esm/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/esm/swappers/ThorchainSwapper/utils/poolAssetHelpers/poolAssetHelpers.js

@@ -2,5 +2,6 @@ import invert from 'lodash/invert';
 import generatedTradableAssetMap from '../../generated/generatedTradableAssetMap.json';
 const thorPoolIdAssetIdSymbolMap = generatedTradableAssetMap;
 export const assetIdToThorPoolAssetIdMap = invert(thorPoolIdAssetIdSymbolMap);
+const assetIdToThorPoolAssetIdMapLower = Object.fromEntries(Object.entries(assetIdToThorPoolAssetIdMap).map(([k, v]) => [k.toLowerCase(), v]));
 export const thorPoolAssetIdToAssetId = (id) => thorPoolIdAssetIdSymbolMap[id.toUpperCase()];
-export const assetIdToThorPoolAssetId = ({ assetId }) => assetIdToThorPoolAssetIdMap[assetId.toLowerCase()];
+export const assetIdToThorPoolAssetId = ({ assetId }) => assetIdToThorPoolAssetIdMapLower[assetId.toLowerCase()];

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

@@ -1,4 +1,4 @@
-import { btcAssetId, ethAssetId } from '@shapeshiftoss/caip';
+import { btcAssetId, ethAssetId, solAssetId } from '@shapeshiftoss/caip';
 import { describe, expect, it } from 'vitest';
 import { assetIdToThorPoolAssetId, thorPoolAssetIdToAssetId } from './poolAssetHelpers.js';
 describe('poolAssetHelpers', () => {
@@ -16,6 +16,10 @@ describe('poolAssetHelpers', () => {
             const result = thorPoolAssetIdToAssetId('ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48');
             expect(result).toEqual(usdcAssetId);
         });
+        it('returns Solana assetId when poolAssetId is SOL.SOL', () => {
+            const result = thorPoolAssetIdToAssetId('SOL.SOL');
+            expect(result).toEqual(solAssetId);
+        });
         it('returns undefined for an asset we dont support', () => {
             const result = thorPoolAssetIdToAssetId('BNB.AVA-645');
             expect(result).toEqual(undefined);
@@ -44,6 +48,12 @@ describe('poolAssetHelpers', () => {
             const poolAssetId = 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48';
             expect(result).toEqual(poolAssetId);
         });
+        it('returns SOL pool when assetId is solAssetId (base58 case-sensitive)', () => {
+            const assetId = solAssetId;
+            const result = assetIdToThorPoolAssetId({ assetId });
+            const poolAssetId = 'SOL.SOL';
+            expect(result).toEqual(poolAssetId);
+        });
         it('returns undefined for an unsupported asset', () => {
             const assetId = 'foobar';
             const result = assetIdToThorPoolAssetId({ assetId });

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

@@ -6,6 +6,7 @@ import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { fetchZrxQuote } from '../utils/fetchFromZrx.js';
 import { assertValidTrade, calculateBuyAmountBeforeFeesCryptoBaseUnit, calculateRate, getProtocolFees, } from '../utils/helpers/helpers.js';
@@ -96,6 +97,14 @@ export async function getZrxTradeQuote(input, assertGetEvmChainAdapter, assetsBy
                     buyAmountAfterFeesCryptoBaseUnit: buyAmount,
                     sellAmountIncludingProtocolFeesCryptoBaseUnit,
                     source: SwapperName.Zrx,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmount,
+                    }),
                     permit2Eip712: permit2Eip712,
                     zrxTransactionMetadata: transactionMetadata,
                 },

package/dist/esm/swappers/ZrxSwapper/getZrxTradeRate/getZrxTradeRate.js

@@ -3,6 +3,7 @@ import { Err, Ok } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName } from '../../../types.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { fetchZrxPrice } from '../utils/fetchFromZrx.js';
 import { assertValidTrade, calculateBuyAmountBeforeFeesCryptoBaseUnit, calculateRate, getProtocolFees, } from '../utils/helpers/helpers.js';
@@ -62,6 +63,14 @@ export async function getZrxTradeRate(input, assetsById, zrxBaseUrl) {
                 buyAmountAfterFeesCryptoBaseUnit: buyAmount,
                 sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 source: SwapperName.Zrx,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmount,
+                }),
             },
         ],
     });

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

@@ -8,7 +8,7 @@ export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownC
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;
-}) => import("@sniptt/monads/build/result/result").ResOk<boolean, never> | import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight>;
+}) => import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight> | import("@sniptt/monads/build/result/result").ResOk<boolean, never>;
 export declare const calculateRate: ({ buyAmount, sellAmount, buyAsset, sellAsset, }: {
     buyAmount: string;
     sellAmount: string;

package/dist/esm/swappers/utils/affiliateFee.d.ts

@@ -0,0 +1,17 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { AffiliateFee } from '../../types.js';
+export type AffiliateFeeStrategy = 'buy_asset' | 'sell_asset' | 'fixed_asset';
+type BuildAffiliateFeeParams = {
+    strategy: AffiliateFeeStrategy;
+    affiliateBps: string;
+    sellAsset: Asset;
+    buyAsset: Asset;
+    sellAmountCryptoBaseUnit: string;
+    buyAmountCryptoBaseUnit: string;
+    fixedAsset?: Asset;
+    fixedAssetId?: AssetId;
+    isEstimate?: boolean;
+};
+export declare const buildAffiliateFee: (params: BuildAffiliateFeeParams) => AffiliateFee | undefined;
+export {};

package/dist/esm/swappers/utils/affiliateFee.js

@@ -0,0 +1,39 @@
+import { bn, bnOrZero } from '@shapeshiftoss/utils';
+export const buildAffiliateFee = (params) => {
+    const { strategy, affiliateBps, sellAsset, buyAsset, sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, fixedAsset, fixedAssetId, isEstimate, } = params;
+    if (bnOrZero(affiliateBps).lte(0))
+        return undefined;
+    const bpsDecimal = bn(affiliateBps).div(10000);
+    switch (strategy) {
+        case 'buy_asset': {
+            const feeAmount = bnOrZero(buyAmountCryptoBaseUnit).times(bpsDecimal).toFixed(0);
+            return {
+                assetId: buyAsset.assetId,
+                amountCryptoBaseUnit: feeAmount,
+                asset: buyAsset,
+                isEstimate,
+            };
+        }
+        case 'sell_asset': {
+            const feeAmount = bnOrZero(sellAmountCryptoBaseUnit).times(bpsDecimal).toFixed(0);
+            return {
+                assetId: sellAsset.assetId,
+                amountCryptoBaseUnit: feeAmount,
+                asset: sellAsset,
+                isEstimate,
+            };
+        }
+        case 'fixed_asset': {
+            if (!fixedAsset || !fixedAssetId)
+                return undefined;
+            return {
+                assetId: fixedAssetId,
+                amountCryptoBaseUnit: '0',
+                asset: fixedAsset,
+                isEstimate: true,
+            };
+        }
+        default:
+            return undefined;
+    }
+};

package/dist/esm/swappers/utils/filterBuyAssetsBySellAssetId/filterBuyAssetsBySellAssetId.js

@@ -1,14 +1,11 @@
-import { arbitrumNovaChainId } from '@shapeshiftoss/caip';
 import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 const _filterEvmBuyAssetsBySellAssetId = ({ assets, sellAsset }, chainIdPredicate) => {
     // evm only
     if (!isEvmChainId(sellAsset.chainId))
         return [];
     return assets.filter(buyAsset => {
-        // evm only AND chain id predicate with no arbitrum nova support for any swappers
-        return (isEvmChainId(buyAsset.chainId) &&
-            chainIdPredicate(buyAsset.chainId, sellAsset.chainId) &&
-            buyAsset.chainId !== arbitrumNovaChainId);
+        // evm only AND chain id predicate
+        return isEvmChainId(buyAsset.chainId) && chainIdPredicate(buyAsset.chainId, sellAsset.chainId);
     });
 };
 export const filterSameChainEvmBuyAssetsBySellAssetId = (input) => {

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

@@ -1,6 +1,6 @@
 import { arbitrumAssetId, avalancheAssetId, baseAssetId, bscAssetId, ethAssetId, fromAssetId, gnosisAssetId, katanaAssetId, monadAssetId, optimismAssetId, plasmaAssetId, polygonAssetId, } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
-import { DAO_TREASURY_ARBITRUM, DAO_TREASURY_AVALANCHE, DAO_TREASURY_BASE, DAO_TREASURY_BITCOIN, DAO_TREASURY_BSC, DAO_TREASURY_ETHEREUM_MAINNET, DAO_TREASURY_GNOSIS, DAO_TREASURY_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, DAO_TREASURY_STARKNET, isTreasuryChainId, } from '@shapeshiftoss/utils';
+import { DAO_TREASURY_ARBITRUM, DAO_TREASURY_AVALANCHE, DAO_TREASURY_BASE, DAO_TREASURY_BITCOIN, DAO_TREASURY_BSC, DAO_TREASURY_ETHEREUM_MAINNET, DAO_TREASURY_GNOSIS, DAO_TREASURY_HYPEREVM, DAO_TREASURY_MONAD, DAO_TREASURY_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, DAO_TREASURY_STARKNET, DAO_TREASURY_TON, isTreasuryChainId, } from '@shapeshiftoss/utils';
 export const isNativeEvmAsset = (assetId) => {
     const { chainId } = fromAssetId(assetId);
     switch (chainId) {
@@ -42,6 +42,9 @@ const DAO_TREASURY_BY_CHAIN_ID = {
     [KnownChainIds.SolanaMainnet]: DAO_TREASURY_SOLANA,
     [KnownChainIds.BitcoinMainnet]: DAO_TREASURY_BITCOIN,
     [KnownChainIds.StarknetMainnet]: DAO_TREASURY_STARKNET,
+    [KnownChainIds.TonMainnet]: DAO_TREASURY_TON,
+    [KnownChainIds.MonadMainnet]: DAO_TREASURY_MONAD,
+    [KnownChainIds.HyperEvmMainnet]: DAO_TREASURY_HYPEREVM,
 };
 export const getTreasuryAddressFromChainId = (chainId) => {
     const maybeTreasuryChainId = isTreasuryChainId(chainId) ? chainId : undefined;

package/dist/esm/thorchain-utils/getCallDataFromQuote.d.ts

@@ -1,7 +1,7 @@
 import type { Asset } from '@shapeshiftoss/types';
 import type { SwapperConfig, SwapperName } from '../types.js';
 import type { ThorEvmTradeQuote } from './types.js';
-export declare const getCallDataFromQuote: ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }: Pick<ThorEvmTradeQuote, "data" | "slippageTolerancePercentageDecimal" | "memo" | "aggregator" | "vault" | "expiry" | "tradeType" | "longtailData"> & {
+export declare const getCallDataFromQuote: ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }: Pick<ThorEvmTradeQuote, "data" | "slippageTolerancePercentageDecimal" | "memo" | "expiry" | "tradeType" | "aggregator" | "vault" | "longtailData"> & {
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
     config: SwapperConfig;
     sellAsset: Asset;