@shapeshiftoss/swapper 17.7.3 → 18.1.0

package/dist/cjs/utils/solana/computeBudgetInstructions.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withComputeUnitLimit = exports.omitComputeBudgetInstructions = exports.isComputeBudgetInstruction = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const web3_js_1 = require("@solana/web3.js");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const isComputeBudgetInstruction = (instruction) => instruction.programId.toString() === web3_js_1.ComputeBudgetProgram.programId.toString();
+exports.isComputeBudgetInstruction = isComputeBudgetInstruction;
+// Provider payloads carry their own budget instructions - strip them so ours are set from
+// measured simulation and the payload never carries duplicates (solana rejects them)
+const omitComputeBudgetInstructions = (instructions) => instructions.filter(instruction => !(0, exports.isComputeBudgetInstruction)(instruction));
+exports.omitComputeBudgetInstructions = omitComputeBudgetInstructions;
+// Quote transaction data carries a static compute unit limit so api consumers can execute
+// without simulating - the dynamic priority fee is added at execution time
+const withComputeUnitLimit = ({ instructions, computeUnits, includeComputeBudget, computeBudget = {}, }) => {
+    // Plain native transfers broadcast without a compute budget
+    if (!includeComputeBudget)
+        return instructions;
+    const { marginMultiplier, minComputeUnits } = computeBudget;
+    const units = Number(bignumber_js_1.default.max((0, utils_1.bnOrZero)(computeUnits), minComputeUnits ?? 0)
+        .times(marginMultiplier ?? 1)
+        .toFixed(0));
+    return [...instructions, web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units })];
+};
+exports.withComputeUnitLimit = withComputeUnitLimit;

package/dist/cjs/utils/solana/constants.d.ts

@@ -0,0 +1 @@
+export declare const SOLANA_PLACEHOLDER_ADDRESS = "FxXyPB5RH4uHLPPJR5H89zGwZp19juBetmRwrxfsLj2j";

package/dist/cjs/utils/solana/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLANA_PLACEHOLDER_ADDRESS = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+// The DAO treasury is a rent-exempt system account we control, usable as a payer stand-in for
+// rate estimation without a connected wallet (simulation requires the payer to exist and cover
+// the transfer, so estimation transfers 1 lamport - compute consumption is amount-independent)
+exports.SOLANA_PLACEHOLDER_ADDRESS = utils_1.DAO_TREASURY_SOLANA;

package/dist/cjs/utils/solana/getSolanaExecutionContext.d.ts

@@ -0,0 +1,10 @@
+import type { GetUnsignedSolanaTransactionArgs } from '../../types';
+export declare const getSolanaExecutionContext: ({ stepIndex, tradeQuote, assertGetSolanaChainAdapter, }: GetUnsignedSolanaTransactionArgs) => {
+    step: import("../../types").TradeQuoteStep;
+    adapter: import("packages/chain-adapters/src/solana").ChainAdapter;
+    transactionData: {
+        type: "solana_instructions";
+        instructions: import("@solana/web3.js").TransactionInstruction[];
+        addressLookupTableAddresses: string[];
+    };
+};

package/dist/cjs/utils/solana/getSolanaExecutionContext.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSolanaExecutionContext = void 0;
+const utils_1 = require("../../utils");
+const getSolanaExecutionContext = ({ stepIndex, tradeQuote, assertGetSolanaChainAdapter, }) => {
+    if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+        throw new Error('unable to execute a trade rate');
+    const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+    const { transactionData, sellAsset } = step;
+    if (transactionData?.type !== 'solana_instructions')
+        throw new Error('invalid solana transaction');
+    const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+    return { step, adapter, transactionData };
+};
+exports.getSolanaExecutionContext = getSolanaExecutionContext;

package/dist/cjs/utils/solana/getSolanaNetworkFeeCryptoBaseUnit.d.ts

@@ -0,0 +1,15 @@
+import type { solana } from '@shapeshiftoss/chain-adapters';
+import type { TransactionInstruction } from '@solana/web3.js';
+type GetSolanaNetworkFeeCryptoBaseUnitArgs = {
+    adapter: solana.ChainAdapter;
+    from: string;
+    instructions: TransactionInstruction[];
+    addressLookupTableAddresses?: string[];
+    tokenId?: string;
+};
+export declare const getSolanaNetworkFeeCryptoBaseUnit: ({ adapter, from, instructions, addressLookupTableAddresses, tokenId, }: GetSolanaNetworkFeeCryptoBaseUnitArgs) => Promise<{
+    networkFeeCryptoBaseUnit: string;
+    feeData: import("@shapeshiftoss/chain-adapters").FeeData<import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet>;
+    includeComputeBudget: boolean;
+}>;
+export {};

package/dist/cjs/utils/solana/getSolanaNetworkFeeCryptoBaseUnit.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSolanaNetworkFeeCryptoBaseUnit = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const web3_js_1 = require("@solana/web3.js");
+const calculateAccountCreationCosts_1 = require("./calculateAccountCreationCosts");
+const computeBudgetInstructions_1 = require("./computeBudgetInstructions");
+const MAX_COMPUTE_UNITS = 1_400_000;
+const getSolanaNetworkFeeCryptoBaseUnit = async ({ adapter, from, instructions, addressLookupTableAddresses = [], tokenId, }) => {
+    // Plain native transfers broadcast without a compute budget (matching wallet sends); anything
+    // else includes one - token transfers (tokenId covers native shape estimations), memos, swaps
+    const includeComputeBudget = Boolean(tokenId) ||
+        instructions.some(instruction => !instruction.programId.equals(web3_js_1.SystemProgram.programId));
+    const hasComputeBudgetInstructions = instructions.some(computeBudgetInstructions_1.isComputeBudgetInstruction);
+    const estimationInstructions = includeComputeBudget && !hasComputeBudgetInstructions
+        ? [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: MAX_COMPUTE_UNITS }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 0 }),
+            ...instructions,
+        ]
+        : instructions;
+    const { fast } = await adapter.getFeeData({
+        to: '',
+        value: '0',
+        chainSpecific: {
+            from,
+            addressLookupTableAccounts: addressLookupTableAddresses,
+            instructions: estimationInstructions,
+        },
+    });
+    // Rent for any token account creation in the instructions is part of what the payer spends
+    const networkFeeCryptoBaseUnit = (0, utils_1.bn)(fast.txFee)
+        .plus((0, calculateAccountCreationCosts_1.calculateAccountCreationCosts)(instructions))
+        .toString();
+    return { networkFeeCryptoBaseUnit, feeData: fast, includeComputeBudget };
+};
+exports.getSolanaNetworkFeeCryptoBaseUnit = getSolanaNetworkFeeCryptoBaseUnit;

package/dist/cjs/utils/solana/getSolanaTransactionFees.d.ts

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

package/dist/cjs/utils/solana/getSolanaTransactionFees.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSolanaTransactionFees = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const getSolanaExecutionContext_1 = require("./getSolanaExecutionContext");
+const getSolanaNetworkFeeCryptoBaseUnit_1 = require("./getSolanaNetworkFeeCryptoBaseUnit");
+const getSolanaTransactionFees = async (args) => {
+    const { step, adapter, transactionData } = (0, getSolanaExecutionContext_1.getSolanaExecutionContext)(args);
+    const { networkFeeCryptoBaseUnit } = await (0, getSolanaNetworkFeeCryptoBaseUnit_1.getSolanaNetworkFeeCryptoBaseUnit)({
+        adapter,
+        from: args.from,
+        instructions: transactionData.instructions,
+        addressLookupTableAddresses: transactionData.addressLookupTableAddresses,
+        tokenId: (0, utils_1.contractAddressOrUndefined)(step.sellAsset.assetId),
+    });
+    return networkFeeCryptoBaseUnit;
+};
+exports.getSolanaTransactionFees = getSolanaTransactionFees;

package/dist/cjs/utils/solana/getUnsignedSolanaTransaction.d.ts

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

package/dist/cjs/utils/solana/getUnsignedSolanaTransaction.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnsignedSolanaTransaction = void 0;
+const computeBudgetInstructions_1 = require("./computeBudgetInstructions");
+const getSolanaExecutionContext_1 = require("./getSolanaExecutionContext");
+// Quote instructions carry the static compute unit limit - only the dynamic priority fee is
+// fetched here, mirroring evm's quote-time gas limit + execution-time gas price split
+const getUnsignedSolanaTransaction = async (args) => {
+    const { step, adapter, transactionData } = (0, getSolanaExecutionContext_1.getSolanaExecutionContext)(args);
+    const { accountNumber } = step;
+    const { instructions, addressLookupTableAddresses } = transactionData;
+    // Plain native transfers carry no compute budget and broadcast without one
+    const includeComputeBudget = instructions.some(computeBudgetInstructions_1.isComputeBudgetInstruction);
+    const priorityFees = includeComputeBudget ? await adapter.getPriorityFees() : undefined;
+    return adapter.buildSendApiTransaction({
+        from: args.from,
+        to: '',
+        value: '0',
+        accountNumber,
+        chainSpecific: {
+            addressLookupTableAccounts: addressLookupTableAddresses,
+            instructions: instructions.map(instruction => adapter.convertInstruction(instruction)),
+            ...(priorityFees && { computeUnitPrice: priorityFees.fast }),
+        },
+    });
+};
+exports.getUnsignedSolanaTransaction = getUnsignedSolanaTransaction;

package/dist/cjs/utils/solana/index.d.ts

@@ -0,0 +1,7 @@
+export * from './calculateAccountCreationCosts';
+export * from './computeBudgetInstructions';
+export * from './constants';
+export * from './getSolanaNetworkFeeCryptoBaseUnit';
+export * from './getSolanaTransactionFees';
+export * from './getUnsignedSolanaTransaction';
+export * from './isSolanaTransactionOversized';

package/dist/cjs/utils/solana/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./calculateAccountCreationCosts"), exports);
+__exportStar(require("./computeBudgetInstructions"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./getSolanaNetworkFeeCryptoBaseUnit"), exports);
+__exportStar(require("./getSolanaTransactionFees"), exports);
+__exportStar(require("./getUnsignedSolanaTransaction"), exports);
+__exportStar(require("./isSolanaTransactionOversized"), exports);

package/dist/cjs/utils/solana/isSolanaTransactionOversized.d.ts

@@ -0,0 +1,8 @@
+import type { solana } from '@shapeshiftoss/chain-adapters';
+import type { TransactionInstruction } from '@solana/web3.js';
+export declare const isSolanaTransactionOversized: ({ adapter, from, instructions, addressLookupTableAddresses, }: {
+    adapter: solana.ChainAdapter;
+    from: string;
+    instructions: TransactionInstruction[];
+    addressLookupTableAddresses: string[];
+}) => Promise<boolean>;

package/dist/cjs/utils/solana/isSolanaTransactionOversized.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSolanaTransactionOversized = void 0;
+const web3_js_1 = require("@solana/web3.js");
+// Solana caps a single transaction at 1232 bytes (anything larger must be split into a Jito bundle).
+const SOLANA_MAX_TX_SIZE_BYTES = 1232;
+const isSolanaTransactionOversized = async ({ adapter, from, instructions, addressLookupTableAddresses, }) => {
+    if (!instructions.length)
+        return false;
+    const lookupTableInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAddresses);
+    const lookupTableAccounts = lookupTableInfos.map(info => new web3_js_1.AddressLookupTableAccount({
+        key: new web3_js_1.PublicKey(info.key),
+        state: web3_js_1.AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+    }));
+    const messageV0 = web3_js_1.MessageV0.compile({
+        payerKey: new web3_js_1.PublicKey(from),
+        instructions,
+        recentBlockhash: web3_js_1.PublicKey.default.toString(),
+        addressLookupTableAccounts: lookupTableAccounts,
+    });
+    return new web3_js_1.VersionedTransaction(messageV0).serialize().length > SOLANA_MAX_TX_SIZE_BYTES;
+};
+exports.isSolanaTransactionOversized = isSolanaTransactionOversized;

package/dist/cjs/utils/test-data/cryptoMarketDataById.d.ts

@@ -0,0 +1,4 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+export declare const marketDataByAssetIdUsd: Record<AssetId, {
+    price: string;
+}>;

package/dist/cjs/{swappers/utils → utils}/test-data/setupSwapQuote.d.ts

@@ -1,7 +1,7 @@
 import type { Asset } from '@shapeshiftoss/types';
-import type { TradeQuote } from '../../../types';
+import type { TradeQuote } from '../../types';
 export declare const setupQuote: () => {
-    quoteInput: import("../../../types").GetEvmTradeQuoteInputBase;
+    quoteInput: import("../../types").GetEvmTradeQuoteInput;
     tradeQuote: TradeQuote;
     buyAsset: Asset;
     sellAsset: Asset;

package/dist/cjs/{swappers/utils → utils}/test-data/setupSwapQuote.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupQuote = void 0;
 const types_1 = require("@shapeshiftoss/types");
-const types_2 = require("../../../types");
+const types_2 = require("../../types");
 const assets_1 = require("./assets");
 const setupQuote = () => {
     const sellAsset = { ...assets_1.FOX_MAINNET };

package/dist/cjs/{thorchain-utils → utils/thorchain}/checkTradeStatus.d.ts

@@ -1,4 +1,4 @@
-import type { CheckTradeStatusInput, TradeStatus } from '../types';
+import type { CheckTradeStatusInput, TradeStatus } from '../../types';
 type CheckTradeStatusInputExtended = CheckTradeStatusInput & {
     nodeUrl: string;
     apiUrl: string;

package/dist/cjs/{thorchain-utils → utils/thorchain}/checkTradeStatus.js

@@ -6,13 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkTradeStatus = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
 const axios_1 = __importDefault(require("axios"));
-const utils_1 = require("../utils");
+const utils_2 = require("../../utils");
 const getLatestThorTxStatusMessage_1 = require("./getLatestThorTxStatusMessage");
 const parseBuyTxHash_1 = require("./parseBuyTxHash");
 const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, nodeUrl, apiUrl, nativeChain, }) => {
     try {
-        const maybeSafeTransactionStatus = await (0, utils_1.checkSafeTransactionStatus)({
+        const maybeSafeTransactionStatus = await (0, utils_2.checkSafeTransactionStatus)({
             txHash,
             chainId,
             assertGetEvmChainAdapter,
@@ -27,6 +28,9 @@ const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContract
             // Mutate txHash and continue with regular status check flow.
             txHash = maybeSafeTransactionStatus.buyTxHash;
         }
+        const swapperTxId = txHash.replace(/^0x/, '');
+        const nativeExplorerTxLink = nativeChain === 'THOR' ? utils_1.thorchain.explorerTxLink : utils_1.mayachain.explorerTxLink;
+        const swapperTxLink = `${nativeExplorerTxLink}${swapperTxId}`;
         // check for native chain tx errors
         if ((chainId === caip_1.thorchainChainId && nativeChain === 'THOR') ||
             (chainId === caip_1.mayachainChainId && nativeChain === 'MAYA')) {
@@ -35,6 +39,8 @@ const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContract
                 return {
                     status: unchained_client_1.TxStatus.Failed,
                     buyTxHash: undefined,
+                    swapperTxId,
+                    swapperTxLink,
                     message: tx.events[0].error.message,
                 };
             }
@@ -46,7 +52,13 @@ const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContract
         ]);
         // We care about txStatusData errors because it drives all of the status logic.
         if ('error' in txStatusData) {
-            return { buyTxHash: undefined, status: unchained_client_1.TxStatus.Unknown, message: undefined };
+            return {
+                buyTxHash: undefined,
+                status: unchained_client_1.TxStatus.Unknown,
+                swapperTxId,
+                swapperTxLink,
+                message: undefined,
+            };
         }
         // We use planned_out_txs to determine the number of out txs because we don't want to derive
         // swap completion based on the length of out_txs which is populated as the trade executed
@@ -56,16 +68,22 @@ const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContract
         const hasOutboundL1Tx = lastOutTx !== undefined && lastOutTx.chain !== nativeChain;
         const hasOutboundNativeTx = lastOutTx !== undefined && lastOutTx.chain === nativeChain;
         if (txStatusData.planned_out_txs?.some(plannedOutTx => plannedOutTx.refund)) {
-            return { buyTxHash, status: unchained_client_1.TxStatus.Failed, message: undefined };
+            return { buyTxHash, status: unchained_client_1.TxStatus.Failed, swapperTxId, swapperTxLink, message: undefined };
         }
         // We consider the transaction confirmed as soon as we have a buyTxHash
         // For UTXOs, this means that the swap will be confirmed as soon as Txs hit the mempool
         // Which is actually correct, as we update UTXO balances optimistically
         if (!('error' in txData) && buyTxHash && (hasOutboundL1Tx || hasOutboundNativeTx)) {
-            return { buyTxHash, status: unchained_client_1.TxStatus.Confirmed, message: undefined };
+            return {
+                buyTxHash,
+                status: unchained_client_1.TxStatus.Confirmed,
+                swapperTxId,
+                swapperTxLink,
+                message: undefined,
+            };
         }
         const message = (0, getLatestThorTxStatusMessage_1.getLatestThorTxStatusMessage)(txStatusData, hasOutboundL1Tx);
-        return { buyTxHash, status: unchained_client_1.TxStatus.Pending, message };
+        return { buyTxHash, status: unchained_client_1.TxStatus.Pending, swapperTxId, swapperTxLink, message };
     }
     catch (e) {
         const message = (() => {

package/dist/cjs/{thorchain-utils → utils/thorchain}/getInboundAddressDataForChain.d.ts

@@ -1,5 +1,5 @@
 import type { AssetId } from '@shapeshiftoss/caip';
 import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight, SwapperName } from '../types';
+import type { SwapErrorRight, SwapperName } from '../../types';
 import type { InboundAddressResponse } from './types';
 export declare const getInboundAddressDataForChain: (daemonUrl: string, assetId: AssetId | undefined, excludeHalted: boolean, swapperName: SwapperName) => Promise<Result<InboundAddressResponse, SwapErrorRight>>;

package/dist/cjs/{thorchain-utils → utils/thorchain}/getInboundAddressDataForChain.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getInboundAddressDataForChain = void 0;
 const monads_1 = require("@sniptt/monads");
-const types_1 = require("../types");
-const utils_1 = require("../utils");
+const types_1 = require("../../types");
+const utils_1 = require("../../utils");
 const index_1 = require("./index");
 const service_1 = require("./service");
 const getInboundAddressDataForChain = async (daemonUrl, assetId, excludeHalted, swapperName) => {

package/dist/cjs/{thorchain-utils → utils/thorchain}/getPoolDetails.d.ts

@@ -1,7 +1,7 @@
 import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight } from '../types';
-import { SwapperName } from '../types';
+import type { SwapErrorRight } from '../../types';
+import { SwapperName } from '../../types';
 import type { ThornodePoolResponse } from './types';
 type GetPoolDetailsArgs = {
     buyAsset: Asset;

package/dist/cjs/{thorchain-utils → utils/thorchain}/getPoolDetails.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPoolDetails = void 0;
 const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
-const types_1 = require("../types");
+const types_1 = require("../../types");
 const index_1 = require("./index");
 const service_1 = require("./service");
 const getPoolDetails = async (args) => {

package/dist/cjs/{thorchain-utils → utils/thorchain}/getQuote.d.ts

@@ -1,7 +1,7 @@
 import type { AssetId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight, SwapperDeps, SwapperName } from '../types';
+import type { SwapErrorRight, SwapperDeps, SwapperName } from '../../types';
 import type { ThornodeQuoteResponseSuccess } from './types';
 type GetQuoteArgs = {
     sellAsset: Asset;

package/dist/cjs/{thorchain-utils → utils/thorchain}/getQuote.js

@@ -8,21 +8,12 @@ const caip_1 = require("@shapeshiftoss/caip");
 const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
 const qs_1 = __importDefault(require("qs"));
-const types_1 = require("../types");
-const utils_2 = require("../utils");
-const getThresholdedAffiliateBps_1 = require("./getThresholdedAffiliateBps/getThresholdedAffiliateBps");
+const types_1 = require("../../types");
+const utils_2 = require("../../utils");
 const index_1 = require("./index");
 const service_1 = require("./service");
 const getQuote = async (input, deps) => {
     const { buyAssetId, receiveAddress, sellAsset, sellAmountCryptoBaseUnit, streaming, streamingInterval, affiliateBps, swapperName, } = input;
-    // don't apply an affiliate fee if it's below the outbound fee for the inbound pool
-    const thresholdedAffiliateBps = await (0, getThresholdedAffiliateBps_1.getThresholdedAffiliateBps)({
-        sellAsset,
-        sellAmountCryptoBaseUnit,
-        affiliateBps,
-        config: deps.config,
-        swapperName,
-    });
     const buyPoolId = (0, index_1.getPoolAssetId)({ assetId: buyAssetId, swapperName });
     const sellPoolId = (0, index_1.getPoolAssetId)({ assetId: sellAsset.assetId, swapperName });
     const sellAmountCryptoPrecision = utils_1.BigAmount.fromBaseUnit({
@@ -43,34 +34,41 @@ const getQuote = async (input, deps) => {
         from_asset: sellPoolId,
         to_asset: buyPoolId,
         destination: parsedReceiveAddress,
-        affiliate_bps: thresholdedAffiliateBps,
+        affiliate_bps: affiliateBps,
         affiliate: (0, index_1.getAffiliate)(swapperName),
         ...(streaming && { streaming_interval: streamingInterval }),
     });
     const daemonUrl = (0, index_1.getDaemonUrl)(deps.config, swapperName);
     const res = await service_1.thorService.get(`${daemonUrl}/quote/swap?${queryString}`);
-    if (res.isErr())
-        return (0, monads_1.Err)(res.unwrapErr());
-    const { data } = res.unwrap();
-    const isError = 'error' in data;
-    const notEnoughFeeError = isError && /not enough fee/i.test(data.error);
-    const notEnoughToPayTxFeeError = isError && /not enough to pay transaction fee/i.test(data.error);
-    const tradingIsHaltedError = isError && /trading is halted/.test(data.error);
-    if (notEnoughFeeError || notEnoughToPayTxFeeError)
-        return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)());
-    if (tradingIsHaltedError) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `[getQuote]: Trading is halted, cannot process swap`,
-            code: types_1.TradeQuoteError.TradingHalted,
-            details: { sellAssetId: sellAsset.assetId, buyAssetId },
-        }));
-    }
-    if (isError) {
+    // Thornode returns errors as `{ error: string }` in both the 2xx body and the 4xx body.
+    // On 4xx axios rejects, so the body lands on `cause.response.data` instead of in the success data.
+    const errorMessage = (() => {
+        if (res.isErr()) {
+            const cause = res.unwrapErr().cause;
+            return cause?.response?.data?.error;
+        }
+        const { data } = res.unwrap();
+        return 'error' in data ? data.error : undefined;
+    })();
+    if (errorMessage) {
+        if (/not enough fee/i.test(errorMessage) ||
+            /not enough to pay transaction fee/i.test(errorMessage)) {
+            return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)());
+        }
+        if (/trading is halted/i.test(errorMessage)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[getQuote]: Trading is halted, cannot process swap`,
+                code: types_1.TradeQuoteError.TradingHalted,
+                details: { sellAssetId: sellAsset.assetId, buyAssetId },
+            }));
+        }
         return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: data.error,
+            message: errorMessage,
             code: types_1.TradeQuoteError.UnknownError,
         }));
     }
-    return (0, monads_1.Ok)(data);
+    if (res.isErr())
+        return (0, monads_1.Err)(res.unwrapErr());
+    return (0, monads_1.Ok)(res.unwrap().data);
 };
 exports.getQuote = getQuote;

package/dist/cjs/utils/thorchain/getThorL1TradeContexts.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, SwapperName, TradeCommon, TradeStepCommon } from '../../types';
+import type { GetThorStepDataArgs } from './getThorStepData';
+import type { ThorTradeQuoteInput, ThorTradeRateInput, ThorTradeRoute, TradeType } from './types';
+export declare const getSuccessfulTrades: <T>(settled: PromiseSettledResult<Result<T, SwapErrorRight>>[]) => Result<T[], SwapErrorRight>;
+export type ThorL1TradeContext = {
+    route: ThorTradeRoute;
+    tradeCommon: TradeCommon & {
+        isStreaming: boolean;
+        tradeType: TradeType;
+        expiry: number;
+        recommendedMinimumCryptoBaseUnit: string;
+    };
+    stepCommon: Omit<TradeStepCommon, 'feeData' | 'allowanceContract'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetThorStepDataArgs, 'type' | 'input' | 'from' | 'memo'>;
+};
+export declare const getThorL1TradeContexts: (input: ThorTradeQuoteInput | ThorTradeRateInput, deps: SwapperDeps, streamingInterval: number, tradeType: TradeType, swapperName: SwapperName) => Promise<Result<ThorL1TradeContext[], SwapErrorRight>>;