@shapeshiftoss/swapper 17.6.9 → 17.6.11

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

@@ -1,22 +1,26 @@
 import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
 import * as adapters from '@shapeshiftoss/chain-adapters';
-import { assertUnreachable, bn, bnOrZero, contractAddressOrUndefined, convertDecimalPercentageToBasisPoints, convertPrecision, fromBaseUnit, isFulfilled, isRejected, toBaseUnit, } from '@shapeshiftoss/utils';
+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)
@@ -75,7 +79,13 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
         : '0';
     const getRouteBuyAmountBeforeFeesCryptoBaseUnit = (quote) => {
         const buyAmountBeforeFeesCryptoThorPrecision = bn(quote.expected_amount_out).plus(quote.fees.total);
-        return toBaseUnit(fromBaseUnit(buyAmountBeforeFeesCryptoThorPrecision, buyAssetNativePrecision), buyAsset.precision);
+        return BigAmount.fromPrecision({
+            value: BigAmount.fromBaseUnit({
+                value: buyAmountBeforeFeesCryptoThorPrecision,
+                precision: buyAssetNativePrecision,
+            }).toPrecision(),
+            precision: buyAsset.precision,
+        }).toBaseUnit();
     };
     const getProtocolFees = (quote) => {
         // Fees consist of liquidity, outbound, and affiliate fees
@@ -161,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,
                     },
@@ -215,7 +233,11 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             const sellAdapter = assertGetUtxoChainAdapter(sellAsset.chainId);
             const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
                 const memo = getMemo(route);
-                const { vault } = await utxo.getThorTxData({ sellAsset, config, swapperName });
+                const { vault } = await utxo.getThorTxData({
+                    sellAsset,
+                    config,
+                    swapperName,
+                });
                 const feeData = await (async () => {
                     const protocolFees = getProtocolFees(route.quote);
                     // This is a rate without a wallet connected, so we can't get fees
@@ -269,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) => {
@@ -284,9 +347,15 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                         const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
                         const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
                         // Get vault address
-                        const { vault } = await tron.getThorTxData({ sellAsset, config, swapperName });
+                        const { vault } = await tron.getThorTxData({
+                            sellAsset,
+                            config,
+                            swapperName,
+                        });
                         // Estimate fees using the receive address for accurate energy calculation
-                        const tronWeb = new TronWeb({ fullHost: deps.config.VITE_TRON_NODE_URL });
+                        const tronWeb = new TronWeb({
+                            fullHost: deps.config.VITE_TRON_NODE_URL,
+                        });
                         const params = await tronWeb.trx.getChainParameters();
                         const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
                         const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 100;
@@ -296,7 +365,10 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                             try {
                                 const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
                                     { type: 'address', value: vault },
-                                    { type: 'uint256', value: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+                                    {
+                                        type: 'uint256',
+                                        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                                    },
                                 ], input.receiveAddress);
                                 const energyUsed = result.energy_used ?? 65000;
                                 const energyFee = energyUsed * energyPrice * 1.5; // 1.5x safety margin
@@ -361,6 +433,12 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                 code: TradeQuoteError.UnsupportedTradePair,
             }));
         }
+        case CHAIN_NAMESPACE.Ton: {
+            return Err(makeSwapErrorRight({
+                message: 'TON is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
         default:
             return assertUnreachable(chainNamespace);
     }

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

@@ -1,5 +1,5 @@
 import { bchAssetId } from '@shapeshiftoss/caip';
-import { bn, fromBaseUnit, toBaseUnit } from '@shapeshiftoss/utils';
+import { BigAmount, bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import qs from 'qs';
 import { TradeQuoteError } from '../types.js';
@@ -19,9 +19,15 @@ export const getQuote = async (input, deps) => {
     });
     const buyPoolId = getPoolAssetId({ assetId: buyAssetId, swapperName });
     const sellPoolId = getPoolAssetId({ assetId: sellAsset.assetId, swapperName });
-    const sellAmountCryptoPrecision = fromBaseUnit(sellAmountCryptoBaseUnit, sellAsset.precision);
+    const sellAmountCryptoPrecision = BigAmount.fromBaseUnit({
+        value: sellAmountCryptoBaseUnit,
+        precision: sellAsset.precision,
+    }).toPrecision();
     // All pool amounts are native precision regardless of token precision
-    const sellAmountCryptoThorBaseUnit = bn(toBaseUnit(sellAmountCryptoPrecision, getNativePrecision(sellAsset.assetId, swapperName)));
+    const sellAmountCryptoThorBaseUnit = bn(BigAmount.fromPrecision({
+        value: sellAmountCryptoPrecision,
+        precision: getNativePrecision(sellAsset.assetId, swapperName),
+    }).toBaseUnit());
     // The swap endpoint expects BCH receiveAddress's to be stripped of the "bitcoincash:" prefix
     const parsedReceiveAddress = receiveAddress && buyAssetId === bchAssetId
         ? receiveAddress.replace('bitcoincash:', '')

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

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

@@ -0,0 +1,37 @@
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getThorTxData } from './getThorTxData.js';
+const MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
+export const getSolanaTransactionFees = async (args, swapperName) => {
+    const { tradeQuote, stepIndex, from, assertGetSolanaChainAdapter, config } = args;
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const { memo } = tradeQuote;
+    if (!memo)
+        throw new Error('Memo is required');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
+    const { vault } = await getThorTxData({ sellAsset, config, swapperName });
+    const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+    const memoInstruction = new TransactionInstruction({
+        keys: [],
+        programId: new PublicKey(MEMO_PROGRAM_ID),
+        data: Buffer.from(memo, 'utf8'),
+    });
+    const transferInstruction = SystemProgram.transfer({
+        fromPubkey: new PublicKey(from),
+        toPubkey: new PublicKey(vault),
+        lamports: BigInt(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+    });
+    const { fast } = await adapter.getFeeData({
+        to: vault,
+        value: '0',
+        chainSpecific: {
+            from,
+            tokenId: contractAddressOrUndefined(sellAsset.assetId),
+            instructions: [memoInstruction, transferInstruction],
+        },
+    });
+    return fast.txFee;
+};

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

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { SwapperConfig, SwapperName } from '../../types.js';
+type GetThorTxDataArgs = {
+    sellAsset: Asset;
+    config: SwapperConfig;
+    swapperName: SwapperName;
+};
+type GetThorTxDataReturn = {
+    vault: string;
+};
+export declare const getThorTxData: ({ sellAsset, config, swapperName, }: GetThorTxDataArgs) => Promise<GetThorTxDataReturn>;
+export {};

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

@@ -0,0 +1,10 @@
+import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
+import { getDaemonUrl } from '../index.js';
+export const getThorTxData = async ({ sellAsset, config, swapperName, }) => {
+    const daemonUrl = getDaemonUrl(config, swapperName);
+    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, false, swapperName);
+    if (res.isErr())
+        throw res.unwrapErr();
+    const { address: vault } = res.unwrap();
+    return { vault };
+};

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

@@ -0,0 +1,3 @@
+import type { SolanaSignTx } from '@shapeshiftoss/hdwallet-core';
+import type { GetUnsignedSolanaTransactionArgs, SwapperName } from '../../types.js';
+export declare const getUnsignedSolanaTransaction: (args: GetUnsignedSolanaTransactionArgs, swapperName: SwapperName) => Promise<SolanaSignTx>;

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

@@ -0,0 +1,60 @@
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getThorTxData } from './getThorTxData.js';
+const MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
+// Each ComputeBudgetProgram instruction (setComputeUnitLimit, setComputeUnitPrice) costs 150 CU.
+// Fee estimation doesn't include these, so we add a fixed buffer to cover them.
+const COMPUTE_BUDGET_INSTRUCTION_OVERHEAD_CU = 300;
+export const getUnsignedSolanaTransaction = async (args, swapperName) => {
+    const { tradeQuote, stepIndex, from, assertGetSolanaChainAdapter, config } = args;
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const { memo } = tradeQuote;
+    if (!memo)
+        throw new Error('Memo is required');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
+    const { vault } = await getThorTxData({
+        sellAsset,
+        config,
+        swapperName,
+    });
+    const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+    const memoInstruction = new TransactionInstruction({
+        keys: [],
+        programId: new PublicKey(MEMO_PROGRAM_ID),
+        data: Buffer.from(memo, 'utf8'),
+    });
+    const transferInstruction = SystemProgram.transfer({
+        fromPubkey: new PublicKey(from),
+        toPubkey: new PublicKey(vault),
+        lamports: BigInt(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+    });
+    const { fast } = await adapter.getFeeData({
+        to: vault,
+        value: '0',
+        chainSpecific: {
+            from,
+            tokenId: contractAddressOrUndefined(sellAsset.assetId),
+            instructions: [memoInstruction, transferInstruction],
+        },
+    });
+    const memoHdwalletInstruction = {
+        keys: [],
+        programId: MEMO_PROGRAM_ID,
+        data: Buffer.from(memo, 'utf8'),
+    };
+    return adapter.buildSendApiTransaction({
+        from,
+        to: vault,
+        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        accountNumber,
+        chainSpecific: {
+            instructions: [memoHdwalletInstruction],
+            computeUnitLimit: String(Number(fast.chainSpecific.computeUnits) + COMPUTE_BUDGET_INSTRUCTION_OVERHEAD_CU),
+            computeUnitPrice: fast.chainSpecific.priorityFee,
+            tokenId: contractAddressOrUndefined(sellAsset.assetId),
+        },
+    });
+};

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

@@ -0,0 +1,3 @@
+export * from './getThorTxData.js';
+export * from './getUnsignedSolanaTransaction.js';
+export * from './getSolanaTransactionFees.js';

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

@@ -0,0 +1,3 @@
+export * from './getThorTxData.js';
+export * from './getUnsignedSolanaTransaction.js';
+export * from './getSolanaTransactionFees.js';

package/dist/esm/tron-utils/getUnsignedTronTransaction.js

@@ -1,16 +1,36 @@
+import { tronAssetId } from '@shapeshiftoss/caip';
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
 export const getUnsignedTronTransaction = ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }) => {
     if (!isExecutableTradeQuote(tradeQuote))
         throw new Error('Unable to execute a trade rate quote');
     const step = getExecutableTradeStep(tradeQuote, stepIndex);
-    const { accountNumber, sellAsset, relayTransactionMetadata, nearIntentsSpecific } = step;
+    const { accountNumber, sellAsset, relayTransactionMetadata, nearIntentsSpecific, butterSwapTransactionMetadata, } = step;
     const adapter = assertGetTronChainAdapter(sellAsset.chainId);
+    if (butterSwapTransactionMetadata) {
+        const { to, data, method, args, value: butterValue } = butterSwapTransactionMetadata;
+        if (!to)
+            throw new Error('Missing Butter swap contract address');
+        if (!data)
+            throw new Error('Missing Butter swap transaction data');
+        // Use Butter's value field which includes swap fees for same-chain swaps
+        // For native TRX sells, also include the sell amount
+        const isNativeTron = sellAsset.assetId === tronAssetId;
+        const value = isNativeTron ? step.sellAmountIncludingProtocolFeesCryptoBaseUnit : butterValue;
+        return adapter.buildCustomApiTx({
+            from,
+            to,
+            accountNumber,
+            data,
+            value,
+            method,
+            args,
+        });
+    }
     const to = relayTransactionMetadata?.to ?? nearIntentsSpecific?.depositAddress;
     if (!to)
         throw new Error('Missing transaction destination address');
     const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-    // Extract contract address for TRC20 tokens
     const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
     return adapter.buildSendApiTransaction({
         to,