@shapeshiftoss/swapper 17.6.10 → 17.7.0

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

@@ -1,4 +1,4 @@
-import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { evm } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import BigNumber from 'bignumber.js';
 import { getSolanaTransactionFees } from '../../solana-utils/getSolanaTransactionFees.js';
@@ -143,7 +143,7 @@ export const relayApi = {
         }
         if (swap.metadata.relayTransactionMetadata &&
             !txIndexingMap.has(swap.id) &&
-            isEvmChainId(chainId)) {
+            chainIdToRelayChainId[chainId] !== undefined) {
             const relayTxParam = {
                 ...swap.metadata.relayTransactionMetadata,
                 txHash,

package/dist/esm/swappers/RelaySwapper/utils/getTrade.js

@@ -1,13 +1,14 @@
-import { btcChainId, fromChainId, monadChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
+import { baseChainId, btcChainId, fromChainId, monadChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
 import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { bnOrZero, convertBasisPointsToPercentage, convertDecimalPercentageToBasisPoints, convertPrecision, DAO_TREASURY_BASE, } from '@shapeshiftoss/utils';
+import { bnOrZero, chainIdToFeeAssetId, convertBasisPointsToPercentage, convertDecimalPercentageToBasisPoints, convertPrecision, DAO_TREASURY_BASE, isToken, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { PublicKey } from '@solana/web3.js';
+import { AddressLookupTableAccount, MessageV0, PublicKey, VersionedTransaction, } from '@solana/web3.js';
 import axios from 'axios';
 import { getAddress, zeroAddress } from 'viem';
 import { MixPanelEvent, SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
 import { simulateWithStateOverrides } from '../../../utils/tenderly/index.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { MAXIMUM_SUPPORTED_RELAY_STEPS, relayErrorCodeToTradeQuoteError } from '../constant.js';
 import { getRelayAssetAddress } from '../utils/getRelayAssetAddress.js';
@@ -390,7 +391,7 @@ export async function getTrade({ input, deps, relayChainMap, }) {
         // Fallback to Relay's gas amount
         return quote.fees.gas.amount;
     })();
-    const steps = swapSteps.map((quoteStep) => {
+    const steps = await Promise.all(swapSteps.map(async (quoteStep) => {
         const selectedItem = quoteStep.items?.[0];
         if (!selectedItem)
             throw new Error('Relay quote step contains no items');
@@ -400,7 +401,7 @@ export async function getTrade({ input, deps, relayChainMap, }) {
             .plus(relayerFeesBuyAssetCryptoBaseUnit)
             .plus(appFeesBaseUnit)
             .toFixed();
-        const { allowanceContract, relayTransactionMetadata, solanaTransactionMetadata } = (() => {
+        const { allowanceContract, relayTransactionMetadata, solanaTransactionMetadata } = await (async () => {
             if (!selectedItem.data)
                 throw new Error('Relay quote step contains no data');
             if (isRelayQuoteUtxoItemData(selectedItem.data)) {
@@ -439,11 +440,38 @@ export async function getTrade({ input, deps, relayChainMap, }) {
                 };
             }
             if (isRelayQuoteSolanaItemData(selectedItem.data)) {
+                const solanaInstructions = selectedItem.data?.instructions?.map(convertSolanaInstruction);
+                const addressLookupTableAddresses = selectedItem.data?.addressLookupTableAddresses;
+                // Build a trial VersionedTransaction to check if it exceeds the 1232-byte Solana tx size limit
+                const isOversized = await (async () => {
+                    if (!solanaInstructions?.length || !sendAddress)
+                        return false;
+                    try {
+                        const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                        const lookupTableInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAddresses);
+                        const lookupTableAccounts = lookupTableInfos.map(info => new AddressLookupTableAccount({
+                            key: new PublicKey(info.key),
+                            state: AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+                        }));
+                        const messageV0 = MessageV0.compile({
+                            payerKey: new PublicKey(sendAddress),
+                            instructions: solanaInstructions,
+                            recentBlockhash: PublicKey.default.toString(),
+                            addressLookupTableAccounts: lookupTableAccounts,
+                        });
+                        const txBytes = new VersionedTransaction(messageV0).serialize();
+                        return txBytes.length > 1232;
+                    }
+                    catch {
+                        return false;
+                    }
+                })();
                 return {
                     allowanceContract: '',
                     solanaTransactionMetadata: {
-                        addressLookupTableAddresses: selectedItem.data?.addressLookupTableAddresses,
-                        instructions: selectedItem.data?.instructions?.map(convertSolanaInstruction),
+                        addressLookupTableAddresses,
+                        instructions: solanaInstructions,
+                        isOversized,
                     },
                     relayTransactionMetadata: {
                         relayId: quote.steps[0].requestId,
@@ -452,13 +480,23 @@ export async function getTrade({ input, deps, relayChainMap, }) {
                 };
             }
             if (isRelayQuoteTronItemData(selectedItem.data)) {
+                const contractAddress = selectedItem.data.parameter?.contract_address;
+                const callData = selectedItem.data.parameter?.data;
+                const isTronToken = isToken(sellAsset.assetId);
+                if (isTronToken && !contractAddress) {
+                    throw new Error('Missing Relay Tron contract address');
+                }
+                if (isTronToken && !callData) {
+                    throw new Error('Missing Relay Tron transaction data');
+                }
                 return {
-                    allowanceContract: '',
+                    allowanceContract: contractAddress ?? '',
                     solanaTransactionMetadata: undefined,
                     relayTransactionMetadata: {
                         relayId: quote.steps[0].requestId,
                         orderId,
-                        to: selectedItem.data?.parameter?.contract_address,
+                        to: contractAddress,
+                        data: callData,
                     },
                 };
             }
@@ -488,8 +526,19 @@ export async function getTrade({ input, deps, relayChainMap, }) {
             estimatedExecutionTimeMs: timeEstimate * 1000,
             solanaTransactionMetadata,
             relayTransactionMetadata,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'fixed_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                fixedAssetId: chainIdToFeeAssetId(baseChainId),
+                fixedAsset: deps.assetsById[chainIdToFeeAssetId(baseChainId)],
+                isEstimate: true,
+            }),
         };
-    });
+    }));
     const baseQuoteOrRate = {
         id: quote.steps[0].requestId,
         rate,

package/dist/esm/swappers/RelaySwapper/utils/relayTokenToAssetId.js

@@ -109,11 +109,6 @@ export const relayTokenToAssetId = (relayToken) => {
                     assetReference: ASSET_REFERENCE.Plasma,
                     assetNamespace: ASSET_NAMESPACE.slip44,
                 };
-            case CHAIN_REFERENCE.PlumeMainnet:
-                return {
-                    assetReference: ASSET_REFERENCE.Plume,
-                    assetNamespace: ASSET_NAMESPACE.slip44,
-                };
             case CHAIN_REFERENCE.MantleMainnet:
                 return {
                     assetReference: ASSET_REFERENCE.Mantle,
@@ -139,9 +134,9 @@ export const relayTokenToAssetId = (relayToken) => {
                     assetReference: ASSET_REFERENCE.Katana,
                     assetNamespace: ASSET_NAMESPACE.slip44,
                 };
-            case CHAIN_REFERENCE.FlowEvmMainnet:
+            case CHAIN_REFERENCE.EtherealMainnet:
                 return {
-                    assetReference: ASSET_REFERENCE.FlowEvm,
+                    assetReference: ASSET_REFERENCE.Ethereal,
                     assetNamespace: ASSET_NAMESPACE.slip44,
                 };
             case CHAIN_REFERENCE.CeloMainnet:
@@ -149,6 +144,16 @@ export const relayTokenToAssetId = (relayToken) => {
                     assetReference: ASSET_REFERENCE.Celo,
                     assetNamespace: ASSET_NAMESPACE.slip44,
                 };
+            case CHAIN_REFERENCE.FlowEvmMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.FlowEvm,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.PlumeMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Plume,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
             case CHAIN_REFERENCE.StoryMainnet:
                 return {
                     assetReference: ASSET_REFERENCE.Story,
@@ -214,6 +219,16 @@ export const relayTokenToAssetId = (relayToken) => {
                     assetReference: ASSET_REFERENCE.Soneium,
                     assetNamespace: ASSET_NAMESPACE.slip44,
                 };
+            case CHAIN_REFERENCE.SeiMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Sei,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.AbstractMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Abstract,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
             default:
                 throw Error(`chainId '${relayToken.chainId}' not supported`);
         }

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

@@ -1,7 +1,9 @@
+import { tonChainId } from '@shapeshiftoss/caip';
 import { Err, Ok } from '@sniptt/monads';
 import { SettlementMethod } from '@ston-fi/omniston-sdk';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
 import { STONFI_DEFAULT_SLIPPAGE_BPS, STONFI_QUOTE_TIMEOUT_MS } from '../utils/constants.js';
 import { affiliateBpsToNumber, calculateRate, slippageDecimalToBps, tonAddressToOmnistonAddress, validateTonAssets, waitForQuote, } from '../utils/helpers.js';
@@ -36,7 +38,7 @@ export const getTradeQuote = async (input) => {
     try {
         const slippageBps = slippageDecimalToBps(slippageTolerancePercentageDecimal, STONFI_DEFAULT_SLIPPAGE_BPS);
         const referrerFeeBps = affiliateBpsToNumber(affiliateBps);
-        const tonTreasuryAddress = getTreasuryAddressFromChainId(sellAsset.chainId);
+        const tonTreasuryAddress = getTreasuryAddressFromChainId(tonChainId);
         const referrerAddress = tonAddressToOmnistonAddress(tonTreasuryAddress);
         const quoteResult = await waitForQuote(omniston, {
             settlementMethods: [SettlementMethod.SETTLEMENT_METHOD_SWAP],
@@ -100,6 +102,15 @@ export const getTradeQuote = async (input) => {
                     allowanceContract: '0x0',
                     estimatedExecutionTimeMs: 30000,
                     stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

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

@@ -2,6 +2,7 @@ import { Err, Ok } from '@sniptt/monads';
 import { SettlementMethod } from '@ston-fi/omniston-sdk';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
 import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
 import { STONFI_DEFAULT_SLIPPAGE_BPS, STONFI_QUOTE_TIMEOUT_MS } from '../utils/constants.js';
 import { affiliateBpsToNumber, calculateRate, slippageDecimalToBps, tonAddressToOmnistonAddress, validateTonAssets, waitForQuote, } from '../utils/helpers.js';
@@ -86,6 +87,15 @@ export const getTradeRate = async (input) => {
                     allowanceContract: '0x0000000000000000000000000000000000000000',
                     estimatedExecutionTimeMs: 30000,
                     stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
                 },
             ],
         };

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

@@ -4,6 +4,7 @@ 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';
@@ -184,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/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/thorchain-utils/getL1RateOrQuote.js

@@ -2,21 +2,25 @@ import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
 import * as adapters from '@shapeshiftoss/chain-adapters';
 import { assertUnreachable, BigAmount, bn, bnOrZero, contractAddressOrUndefined, convertDecimalPercentageToBasisPoints, convertPrecision, isFulfilled, isRejected, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
+import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
 import { TronWeb } from 'tronweb';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../index.js';
+import { buildAffiliateFee } from '../swappers/utils/affiliateFee.js';
 import { TradeQuoteError } from '../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../utils.js';
 import * as evm from './evm/index.js';
 import { getLimitWithManualSlippage } from './getLimitWithManualSlippage/getLimitWithManualSlippage.js';
 import { getQuote } from './getQuote.js';
 import { addLimitToMemo, assertAndProcessMemo, getAffiliate, getNativePrecision, getSwapSource, } from './index.js';
+import * as solana from './solana/index.js';
 import * as tron from './tron/index.js';
 import * as utxo from './utxo/index.js';
 const SAFE_GAS_LIMIT = '100000'; // depositWithExpiry()
+const SOLANA_MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
 export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapperName) => {
     const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, accountNumber, receiveAddress, affiliateBps: requestedAffiliateBps, } = input;
-    const { config, assertGetEvmChainAdapter, assertGetUtxoChainAdapter, assertGetCosmosSdkChainAdapter, } = deps;
+    const { config, assertGetEvmChainAdapter, assertGetUtxoChainAdapter, assertGetCosmosSdkChainAdapter, assertGetSolanaChainAdapter, } = deps;
     // "NativePrecision" is intended to indicate the base unit precision of the asset
     // for the corresponding swapper network (THORChain or MAYAChain)
     // (CACAO = 10, everything else = 8)
@@ -167,6 +171,14 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                     accountNumber,
                     allowanceContract,
                     feeData,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps: route.affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    }),
                     thorchainSpecific: {
                         maxStreamingQuantity: route.quote.max_streaming_quantity,
                     },
@@ -279,10 +291,51 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             }));
         }
         case CHAIN_NAMESPACE.Solana: {
-            return Err(makeSwapErrorRight({
-                message: 'Solana is not supported',
-                code: TradeQuoteError.UnsupportedTradePair,
+            const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+            const sendAddress = input.sendAddress;
+            const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
+                const memo = getMemo(route);
+                const protocolFees = getProtocolFees(route.quote);
+                const feeData = await (async () => {
+                    if (!sendAddress)
+                        return { networkFeeCryptoBaseUnit: undefined, protocolFees };
+                    const { vault } = await solana.getThorTxData({ sellAsset, config, swapperName });
+                    const memoInstruction = new TransactionInstruction({
+                        keys: [],
+                        programId: new PublicKey(SOLANA_MEMO_PROGRAM_ID),
+                        data: Buffer.from(memo, 'utf8'),
+                    });
+                    const transferInstruction = SystemProgram.transfer({
+                        fromPubkey: new PublicKey(sendAddress),
+                        toPubkey: new PublicKey(vault),
+                        lamports: BigInt(sellAmountCryptoBaseUnit),
+                    });
+                    const { fast } = await adapter.getFeeData({
+                        to: vault,
+                        value: '0',
+                        chainSpecific: {
+                            from: sendAddress,
+                            tokenId: contractAddressOrUndefined(sellAsset.assetId),
+                            instructions: [memoInstruction, transferInstruction],
+                        },
+                    });
+                    return { networkFeeCryptoBaseUnit: fast.txFee, protocolFees };
+                })();
+                return makeThorTradeRateOrQuote({
+                    route,
+                    allowanceContract: '0x0',
+                    memo,
+                    feeData,
+                });
             }));
+            const routes = maybeRoutes.filter(isFulfilled).map(r => r.value);
+            if (!routes.length)
+                return Err(makeSwapErrorRight({
+                    message: 'Unable to create any routes',
+                    code: TradeQuoteError.UnsupportedTradePair,
+                    cause: maybeRoutes.filter(isRejected).map(r => r.reason),
+                }));
+            return Ok(routes);
         }
         case CHAIN_NAMESPACE.Tron: {
             const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {

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

@@ -13,6 +13,7 @@ export * from './getL1RateOrQuote.js';
 export * from './getPoolDetails.js';
 export * as cosmossdk from './cosmossdk/index.js';
 export * as evm from './evm/index.js';
+export * as solana from './solana/index.js';
 export * as tron from './tron/index.js';
 export * as utxo from './utxo/index.js';
 export declare const getChainIdBySwapper: (swapperName: SwapperName) => import("@shapeshiftoss/caip").ChainId;
@@ -21,7 +22,7 @@ export declare const isThorTradeQuote: (quote: TradeQuote | undefined) => quote
 export declare const getDaemonUrl: (config: SwapperConfig, swapperName: SwapperName) => string;
 export declare const getMidgardUrl: (config: SwapperConfig, swapperName: SwapperName) => string;
 export declare const isNativeAsset: (assetId: AssetId, swapperName: SwapperName) => boolean;
-export declare const getNativePrecision: (assetId: AssetId, swapperName: SwapperName) => 10 | 8;
+export declare const getNativePrecision: (assetId: AssetId, swapperName: SwapperName) => 8 | 10;
 export declare const getNativeFee: (swapperName: SwapperName) => "2000000" | "2000000000";
 export declare const getAffiliate: (swapperName: SwapperName) => "ss" | "ssmaya";
 export declare const getPoolAssetId: ({ assetId, swapperName, }: {

package/dist/esm/thorchain-utils/index.js

@@ -14,6 +14,7 @@ export * from './getL1RateOrQuote.js';
 export * from './getPoolDetails.js';
 export * as cosmossdk from './cosmossdk/index.js';
 export * as evm from './evm/index.js';
+export * as solana from './solana/index.js';
 export * as tron from './tron/index.js';
 export * as utxo from './utxo/index.js';
 export const getChainIdBySwapper = (swapperName) => {

package/dist/esm/thorchain-utils/solana/constants.d.ts

@@ -0,0 +1 @@
+export declare const MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";

package/dist/esm/thorchain-utils/solana/constants.js

@@ -0,0 +1,3 @@
+// Solana Memo Program v2
+// https://spl.solana.com/memo
+export const MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';

package/dist/esm/thorchain-utils/solana/getSolanaTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedSolanaTransactionArgs, SwapperName } from '../../types.js';
+export declare const getSolanaTransactionFees: (args: GetUnsignedSolanaTransactionArgs, swapperName: SwapperName) => Promise<string>;