@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/esm/utils/{tenderly → evm}/storageSlots.js

@@ -1,18 +1,12 @@
-import { concat, keccak256, maxUint256, pad, toHex } from 'viem';
-// keccak256(concat(pad(address), pad(slot)))
-export const getBalanceStorageSlot = (userAddress, balanceSlotNumber = 0) => {
-    const paddedAddress = pad(userAddress.toLowerCase(), { size: 32 });
-    const paddedSlot = pad(toHex(balanceSlotNumber), { size: 32 });
-    return keccak256(concat([paddedAddress, paddedSlot]));
-};
-// keccak256(spender, keccak256(owner, slot))
-export const getAllowanceStorageSlot = (ownerAddress, spenderAddress, allowanceSlotNumber = 1) => {
-    const paddedOwner = pad(ownerAddress.toLowerCase(), { size: 32 });
-    const paddedAllowanceSlot = pad(toHex(allowanceSlotNumber), { size: 32 });
-    const innerSlot = keccak256(concat([paddedOwner, paddedAllowanceSlot]));
-    const paddedSpender = pad(spenderAddress.toLowerCase(), { size: 32 });
-    return keccak256(concat([paddedSpender, innerSlot]));
+import { concat, keccak256, pad, toHex } from 'viem';
+const getMappingStorageSlot = (key, slot, layout) => {
+    const paddedKey = pad(key.toLowerCase(), { size: 32 });
+    const paddedSlot = pad(typeof slot === 'number' ? toHex(slot) : slot, { size: 32 });
+    return keccak256(concat(layout === 'vyper' ? [paddedSlot, paddedKey] : [paddedKey, paddedSlot]));
 };
+export const getBalanceStorageSlot = (userAddress, balanceSlotNumber, layout = 'solidity') => getMappingStorageSlot(userAddress, balanceSlotNumber, layout);
+// Nested mapping - the outer (spender) hash chains onto the inner (owner) hash
+export const getAllowanceStorageSlot = (ownerAddress, spenderAddress, allowanceSlotNumber, layout = 'solidity') => getMappingStorageSlot(spenderAddress, getMappingStorageSlot(ownerAddress, allowanceSlotNumber, layout), layout);
 // Most ERC20s: balance at slot 0, allowance at slot 1
 // Slot 51/52 pattern (StandardArbERC20, some L2 implementations)
 // Slot 5/6 pattern (Wormhole bridge)
@@ -79,8 +73,3 @@ export const getTokenAllowanceSlot = (tokenAddress) => {
     // Standard ERC20: allowance at slot 1
     return 1;
 };
-// USDC slot 9: bit 255 is blacklist flag, must keep cleared
-export const getMaxBalanceValue = (tokenAddress) => {
-    const slot = getTokenBalanceSlot(tokenAddress);
-    return slot === 9 ? toHex(maxUint256 >> 1n) : toHex(maxUint256);
-};

package/dist/esm/{swappers/utils/helpers → utils}/helpers.d.ts

@@ -1,3 +1,5 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+export declare const FALLBACK_QUOTE_DEADLINE_MS = 60000;
+export declare const normalizeEpochToMs: (value: number) => number;
 export declare const isNativeEvmAsset: (assetId: AssetId) => boolean;
 export declare const getTreasuryAddressFromChainId: (chainId: ChainId) => string;

package/dist/esm/{swappers/utils/helpers → utils}/helpers.js

@@ -1,6 +1,18 @@
 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_BOB, 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';
+// Deadline for providers without their own expiry - short enough to keep priced amounts honest
+export const FALLBACK_QUOTE_DEADLINE_MS = 60_000;
+// Bands are unambiguous for any realistic date: unix s land ~2e9, ms ~2e12, µs ~2e15, ns ~2e18
+export const normalizeEpochToMs = (value) => {
+    if (value < 1e12)
+        return value * 1000;
+    if (value < 1e15)
+        return value;
+    if (value < 1e18)
+        return Math.floor(value / 1000);
+    return Math.floor(value / 1e6);
+};
 export const isNativeEvmAsset = (assetId) => {
     const { chainId } = fromAssetId(assetId);
     switch (chainId) {

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

@@ -0,0 +1,49 @@
+import { thorchainChainId } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { treasuryChainIds } from '@shapeshiftoss/utils';
+import { describe, expect, it } from 'vitest';
+import { getTreasuryAddressFromChainId, normalizeEpochToMs } from './helpers.js';
+describe('getTreasuryAddressFromChainId', () => {
+    // Affiliate and fee recipient addresses for every swapper flow through here, so pin the values
+    // rather than the wiring - a chain pointing at another chain's treasury misroutes revenue silently
+    const expectedTreasuryAddressByChainId = {
+        [KnownChainIds.EthereumMainnet]: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+        [KnownChainIds.OptimismMainnet]: '0x6268d07327f4fb7380732dc6d63d95F88c0E083b',
+        [KnownChainIds.AvalancheMainnet]: '0x74d63F31C2335b5b3BA7ad2812357672b2624cEd',
+        [KnownChainIds.PolygonMainnet]: '0xB5F944600785724e31Edb90F9DFa16dBF01Af000',
+        [KnownChainIds.GnosisMainnet]: '0xb0E3175341794D1dc8E5F02a02F9D26989EbedB3',
+        [KnownChainIds.BnbSmartChainMainnet]: '0x8b92b1698b57bEDF2142297e9397875ADBb2297E',
+        [KnownChainIds.ArbitrumMainnet]: '0x38276553F8fbf2A027D901F8be45f00373d8Dd48',
+        [KnownChainIds.BaseMainnet]: '0x9c9aA90363630d4ab1D9dbF416cc3BBC8d3Ed502',
+        [KnownChainIds.MonadMainnet]: '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC',
+        [KnownChainIds.HyperEvmMainnet]: '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC',
+        [KnownChainIds.BobMainnet]: '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC',
+        [KnownChainIds.BitcoinMainnet]: 'bc1q9xrjfet2a05r3jvsxx66rru7pysevk5dvqasdw9eeea3rfqlk33qr4hghh',
+        [KnownChainIds.SolanaMainnet]: 'FxXyPB5RH4uHLPPJR5H89zGwZp19juBetmRwrxfsLj2j',
+        [KnownChainIds.StarknetMainnet]: '0x07ac2252f2da7cbf085e7a5ddc1318243aa818607cdd430dd2e17dd5d487606a',
+        [KnownChainIds.TonMainnet]: 'UQAHHeOhXst-zSGGigQ8KgDzz89nACBR4TxXwXNjU4DsriLb',
+    };
+    it.each(treasuryChainIds)('returns the treasury address for %s', chainId => {
+        expect(getTreasuryAddressFromChainId(chainId)).toBe(expectedTreasuryAddressByChainId[chainId]);
+    });
+    it('throws for unsupported chains', () => {
+        expect(() => getTreasuryAddressFromChainId(thorchainChainId)).toThrow('[getTreasuryAddressFromChainId] - Unsupported chainId');
+    });
+});
+describe('normalizeEpochToMs', () => {
+    // 2026-08-05T00:00:00Z expressed in each unit
+    const epochS = 1785888000;
+    const epochMs = epochS * 1000;
+    it('converts unix seconds to ms', () => {
+        expect(normalizeEpochToMs(epochS)).toBe(epochMs);
+    });
+    it('passes milliseconds through', () => {
+        expect(normalizeEpochToMs(epochMs)).toBe(epochMs);
+    });
+    it('converts microseconds to ms', () => {
+        expect(normalizeEpochToMs(epochMs * 1000)).toBe(epochMs);
+    });
+    it('converts nanoseconds to ms', () => {
+        expect(normalizeEpochToMs(epochMs * 1e6)).toBe(epochMs);
+    });
+});

package/dist/{cjs/utils.d.ts → esm/utils/index.d.ts}

@@ -6,26 +6,36 @@ import type { Asset, EvmChainId } from '@shapeshiftoss/types';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import type { Result } from '@sniptt/monads';
 import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-import type { EvmTransactionExecutionProps, ExecutableTradeStep, NearTransactionExecutionProps, SolanaTransactionExecutionProps, StarknetTransactionExecutionProps, SuiTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, TonTransactionExecutionProps, TradeQuote, TradeQuoteStep, TradeRate, TradeStatus, TronTransactionExecutionProps } from './types';
-import { TradeQuoteError } from './types';
+import type { TypedData } from 'eip-712';
+import type { CommonSwapMetadata, EvmTransactionExecutionProps, NearTransactionExecutionProps, SolanaTransactionExecutionProps, StarknetTransactionExecutionProps, SuiTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, SwapMetadata, SwapperMetadata, TonTransactionExecutionProps, TradeQuote, TradeQuoteStep, TradeRate, TradeRateStep, TradeStatus, TronTransactionExecutionProps } from '../types.js';
+import { TradeQuoteError } from '../types.js';
+export declare const getPermit2Eip712: (step: TradeQuoteStep | TradeRateStep | undefined) => TypedData | undefined;
 export declare const makeSwapErrorRight: ({ details, cause, code, message, }: {
     message: string;
     details?: unknown;
     cause?: unknown;
     code?: TradeQuoteError | undefined;
 }) => SwapErrorRight;
+export declare const assertQuoteAddresses: ({ sendAddress, receiveAddress, }: {
+    sendAddress?: string | undefined;
+    receiveAddress?: string | undefined;
+}) => Result<{
+    sendAddress: string;
+    receiveAddress: string;
+}, SwapErrorRight>;
 export declare const createTradeAmountTooSmallErr: (details?: {
     minAmountCryptoBaseUnit: string;
     assetId: AssetId;
 }) => SwapErrorRight;
+export declare const makeNetworkFeeEstimationFailedErr: (context: string, cause?: unknown) => SwapErrorRight;
+export declare const makeTradeStepBuildFailedErr: (context: string, cause?: unknown) => SwapErrorRight;
 export declare const createCache: (maxAge: number, cachedUrls: string[], axiosConfig: AxiosRequestConfig) => AxiosInstance;
-export declare const AsyncResultOf: <T>(promise: Promise<T>) => Promise<Result<T, Error>>;
 export declare const makeSwapperAxiosServiceMonadic: (service: AxiosInstance) => {
     get: <T = any>(url: string, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T, any, {}>, SwapErrorRight>>;
     post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T_1, any, {}>, SwapErrorRight>>;
     delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T_2, any, {}>, SwapErrorRight>>;
 };
-export declare const getHopByIndex: (quote: TradeQuote | TradeRate | undefined, index: SupportedTradeQuoteStepIndex) => TradeQuoteStep | undefined;
+export declare const getHopByIndex: (quote: TradeQuote | TradeRate | undefined, index: SupportedTradeQuoteStepIndex) => TradeQuoteStep | TradeRateStep | undefined;
 export declare const executeEvmTransaction: (txToSign: SignTx<EvmChainId>, callbacks: EvmTransactionExecutionProps) => Promise<string>;
 export declare const executeSolanaTransaction: (txToSign: SolanaSignTx, callbacks: SolanaTransactionExecutionProps) => Promise<string>;
 export declare const executeTronTransaction: (txToSign: TronSignTx, callbacks: TronTransactionExecutionProps) => Promise<string>;
@@ -59,8 +69,7 @@ export declare const getInputOutputRate: ({ sellAmountCryptoBaseUnit, buyAmountC
     buyAsset: Asset;
 }) => string;
 export declare const isExecutableTradeQuote: (quote: TradeQuote | TradeRate) => quote is TradeQuote;
-export declare const isExecutableTradeStep: (step: TradeQuoteStep) => step is ExecutableTradeStep;
-export declare const getExecutableTradeStep: (tradeQuote: TradeQuote, stepIndex: SupportedTradeQuoteStepIndex) => ExecutableTradeStep;
+export declare const getExecutableTradeStep: (tradeQuote: TradeQuote, stepIndex: SupportedTradeQuoteStepIndex) => TradeQuoteStep;
 export declare const checkSolanaSwapStatus: ({ txHash, address, assertGetSolanaChainAdapter, }: {
     txHash: string;
     address: string | undefined;
@@ -78,3 +87,25 @@ export declare const checkStarknetSwapStatus: ({ txHash, assertGetStarknetChainA
 export declare class SolanaLogsError extends Error {
     constructor(name: string);
 }
+export declare const buildSwapMetadata: (step: TradeQuoteStep | TradeRateStep, common: CommonSwapMetadata) => SwapMetadata;
+export declare const getSwapMetadata: <S extends "avnu" | "bebop" | "bob" | "chainflip" | "debridge" | "nearIntents" | "relay" | "stonfi" | "thorchain" | "mayachain">(metadata: SwapperMetadata | undefined, name: S) => Extract<import("../swappers/AvnuSwapper/types.js").AvnuMetadata, {
+    name: S;
+}> | Extract<import("../swappers/BebopSwapper/types.js").BebopMetadata, {
+    name: S;
+}> | Extract<import("../swappers/BobGatewaySwapper/types.js").BobGatewayMetadata, {
+    name: S;
+}> | Extract<import("../index.js").ChainflipMetadata, {
+    name: S;
+}> | Extract<import("../swappers/DebridgeSwapper/utils/types.js").DebridgeMetadata, {
+    name: S;
+}> | Extract<import("../swappers/NearIntentsSwapper/index.js").NearIntentsMetadata, {
+    name: S;
+}> | Extract<import("../swappers/RelaySwapper/utils/types.js").RelayMetadata, {
+    name: S;
+}> | Extract<import("../swappers/StonfiSwapper/index.js").StonfiMetadata, {
+    name: S;
+}> | Extract<import("./thorchain/index.js").ThorchainMetadata, {
+    name: S;
+}> | Extract<import("./thorchain/index.js").MayachainMetadata, {
+    name: S;
+}>;

package/dist/esm/{utils.js → utils/index.js}

@@ -5,8 +5,13 @@ import { BigAmount, bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import Axios from 'axios';
 import { setupCache } from 'axios-cache-interceptor';
-import { fetchSafeTransactionInfo } from './safe-utils/index.js';
-import { TradeQuoteError } from './types.js';
+import { TradeQuoteError } from '../types.js';
+import { fetchSafeTransactionInfo } from './safe/index.js';
+export const getPermit2Eip712 = (step) => {
+    return step?.transactionData?.type === 'evm'
+        ? step.transactionData.signatureRequired?.eip712
+        : undefined;
+};
 export const makeSwapErrorRight = ({ details, cause, code, message, }) => ({
     name: 'SwapError',
     message,
@@ -14,11 +19,36 @@ export const makeSwapErrorRight = ({ details, cause, code, message, }) => ({
     cause,
     code,
 });
+export const assertQuoteAddresses = ({ sendAddress, receiveAddress, }) => {
+    if (!sendAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'sendAddress is required',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    if (!receiveAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'receiveAddress is required',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    return Ok({ sendAddress, receiveAddress });
+};
 export const createTradeAmountTooSmallErr = (details) => makeSwapErrorRight({
     code: TradeQuoteError.SellAmountBelowMinimum,
     message: 'Sell amount is too small',
     details,
 });
+export const makeNetworkFeeEstimationFailedErr = (context, cause) => makeSwapErrorRight({
+    code: TradeQuoteError.NetworkFeeEstimationFailed,
+    message: `[${context}] Error estimating network fee`,
+    cause,
+});
+export const makeTradeStepBuildFailedErr = (context, cause) => makeSwapErrorRight({
+    code: TradeQuoteError.InvalidResponse,
+    message: `[${context}] Error building trade step`,
+    cause,
+});
 const getRequestFilter = (cachedUrls) => (request) => !cachedUrls.some(url => request.url?.includes(url));
 export const createCache = (maxAge, cachedUrls, axiosConfig) => {
     const filter = getRequestFilter(cachedUrls);
@@ -33,7 +63,7 @@ export const createCache = (maxAge, cachedUrls, axiosConfig) => {
     return axiosInstance;
 };
 // https://github.com/sniptt-official/monads/issues/111
-export const AsyncResultOf = async (promise) => {
+const AsyncResultOf = async (promise) => {
     try {
         return Ok(await promise);
     }
@@ -185,13 +215,11 @@ export const getInputOutputRate = ({ sellAmountCryptoBaseUnit, buyAmountCryptoBa
     return bn(buyAmountCryptoHuman).div(sellAmountCryptoHuman).toFixed();
 };
 export const isExecutableTradeQuote = (quote) => quote.quoteOrRate === 'quote';
-export const isExecutableTradeStep = (step) => step.accountNumber !== undefined;
 export const getExecutableTradeStep = (tradeQuote, stepIndex) => {
-    const step = getHopByIndex(tradeQuote, stepIndex);
+    // A TradeQuote is executable by construction, so its steps are TradeQuoteStep (accountNumber set)
+    const step = tradeQuote.steps[stepIndex];
     if (!step)
         throw new Error(`No hop found for stepIndex ${stepIndex}`);
-    if (!isExecutableTradeStep(step))
-        throw Error('Unable to execute a trade rate step');
     return step;
 };
 export const checkSolanaSwapStatus = async ({ txHash, address, assertGetSolanaChainAdapter, }) => {
@@ -292,3 +320,12 @@ export class SolanaLogsError extends Error {
         this.name = name;
     }
 }
+export const buildSwapMetadata = (step, common) => ({
+    ...common,
+    swapperMetadata: step.swapperMetadata,
+});
+export const getSwapMetadata = (metadata, name) => {
+    if (metadata?.name !== name)
+        throw new Error(`Expected ${name} swap metadata`);
+    return metadata;
+};

package/dist/esm/utils/solana/calculateAccountCreationCosts.d.ts

@@ -0,0 +1,3 @@
+import type { TransactionInstruction } from '@solana/web3.js';
+export declare const ATA_RENT_LAMPORTS = 2040000;
+export declare const calculateAccountCreationCosts: (instructions: TransactionInstruction[]) => string;

package/dist/esm/utils/solana/calculateAccountCreationCosts.js

@@ -0,0 +1,10 @@
+import { ASSOCIATED_PROGRAM_ID } from '@coral-xyz/anchor/dist/cjs/utils/token';
+import { bnOrZero } from '@shapeshiftoss/utils';
+export const ATA_RENT_LAMPORTS = 2040000;
+// Rent paid to create any associated token accounts the transaction opens (e.g. a first-time
+// transfer of an SPL token to a recipient that doesn't yet hold it). Included in reported
+// network fees so the displayed cost matches what the payer actually spends.
+export const calculateAccountCreationCosts = (instructions) => {
+    const ataCreationCount = instructions.filter(instruction => instruction.programId.toString() === ASSOCIATED_PROGRAM_ID.toString()).length;
+    return bnOrZero(ATA_RENT_LAMPORTS).times(ataCreationCount).toString();
+};

package/dist/esm/utils/solana/computeBudgetInstructions.d.ts

@@ -0,0 +1,13 @@
+import type { TransactionInstruction } from '@solana/web3.js';
+export type SolanaComputeBudgetOptions = {
+    marginMultiplier?: number;
+    minComputeUnits?: number;
+};
+export declare const isComputeBudgetInstruction: (instruction: TransactionInstruction) => boolean;
+export declare const omitComputeBudgetInstructions: (instructions: TransactionInstruction[]) => TransactionInstruction[];
+export declare const withComputeUnitLimit: ({ instructions, computeUnits, includeComputeBudget, computeBudget, }: {
+    instructions: TransactionInstruction[];
+    computeUnits: string;
+    includeComputeBudget: boolean;
+    computeBudget?: SolanaComputeBudgetOptions | undefined;
+}) => TransactionInstruction[];

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

@@ -0,0 +1,19 @@
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { ComputeBudgetProgram } from '@solana/web3.js';
+import BigNumber from 'bignumber.js';
+export const isComputeBudgetInstruction = (instruction) => instruction.programId.toString() === ComputeBudgetProgram.programId.toString();
+// 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)
+export const omitComputeBudgetInstructions = (instructions) => instructions.filter(instruction => !isComputeBudgetInstruction(instruction));
+// 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
+export 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.max(bnOrZero(computeUnits), minComputeUnits ?? 0)
+        .times(marginMultiplier ?? 1)
+        .toFixed(0));
+    return [...instructions, ComputeBudgetProgram.setComputeUnitLimit({ units })];
+};

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

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

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

@@ -0,0 +1,5 @@
+import { DAO_TREASURY_SOLANA } from '@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)
+export const SOLANA_PLACEHOLDER_ADDRESS = DAO_TREASURY_SOLANA;

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

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

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

@@ -0,0 +1,11 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils/index.js';
+export const getSolanaExecutionContext = ({ stepIndex, tradeQuote, assertGetSolanaChainAdapter, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('unable to execute a trade rate');
+    const step = 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 };
+};

package/dist/esm/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/esm/utils/solana/getSolanaNetworkFeeCryptoBaseUnit.js

@@ -0,0 +1,33 @@
+import { bn } from '@shapeshiftoss/utils';
+import { ComputeBudgetProgram, SystemProgram } from '@solana/web3.js';
+import { calculateAccountCreationCosts } from './calculateAccountCreationCosts.js';
+import { isComputeBudgetInstruction } from './computeBudgetInstructions.js';
+const MAX_COMPUTE_UNITS = 1_400_000;
+export 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(SystemProgram.programId));
+    const hasComputeBudgetInstructions = instructions.some(isComputeBudgetInstruction);
+    const estimationInstructions = includeComputeBudget && !hasComputeBudgetInstructions
+        ? [
+            ComputeBudgetProgram.setComputeUnitLimit({ units: MAX_COMPUTE_UNITS }),
+            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 = bn(fast.txFee)
+        .plus(calculateAccountCreationCosts(instructions))
+        .toString();
+    return { networkFeeCryptoBaseUnit, feeData: fast, includeComputeBudget };
+};

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

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

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

@@ -0,0 +1,14 @@
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { getSolanaExecutionContext } from './getSolanaExecutionContext.js';
+import { getSolanaNetworkFeeCryptoBaseUnit } from './getSolanaNetworkFeeCryptoBaseUnit.js';
+export const getSolanaTransactionFees = async (args) => {
+    const { step, adapter, transactionData } = getSolanaExecutionContext(args);
+    const { networkFeeCryptoBaseUnit } = await getSolanaNetworkFeeCryptoBaseUnit({
+        adapter,
+        from: args.from,
+        instructions: transactionData.instructions,
+        addressLookupTableAddresses: transactionData.addressLookupTableAddresses,
+        tokenId: contractAddressOrUndefined(step.sellAsset.assetId),
+    });
+    return networkFeeCryptoBaseUnit;
+};

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

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

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

@@ -0,0 +1,23 @@
+import { isComputeBudgetInstruction } from './computeBudgetInstructions.js';
+import { getSolanaExecutionContext } from './getSolanaExecutionContext.js';
+// 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
+export const getUnsignedSolanaTransaction = async (args) => {
+    const { step, adapter, transactionData } = getSolanaExecutionContext(args);
+    const { accountNumber } = step;
+    const { instructions, addressLookupTableAddresses } = transactionData;
+    // Plain native transfers carry no compute budget and broadcast without one
+    const includeComputeBudget = instructions.some(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 }),
+        },
+    });
+};

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

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

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

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

package/dist/esm/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/esm/utils/solana/isSolanaTransactionOversized.js

@@ -0,0 +1,19 @@
+import { AddressLookupTableAccount, MessageV0, PublicKey, VersionedTransaction, } from '@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;
+export const isSolanaTransactionOversized = async ({ adapter, from, instructions, addressLookupTableAddresses, }) => {
+    if (!instructions.length)
+        return false;
+    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(from),
+        instructions,
+        recentBlockhash: PublicKey.default.toString(),
+        addressLookupTableAccounts: lookupTableAccounts,
+    });
+    return new VersionedTransaction(messageV0).serialize().length > SOLANA_MAX_TX_SIZE_BYTES;
+};

package/dist/esm/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/esm/{swappers/utils → utils}/test-data/setupSwapQuote.d.ts

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

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

@@ -1,5 +1,5 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
-import { SwapperName } from '../../../types.js';
+import { SwapperName } from '../../types.js';
 import { FOX_MAINNET, WETH } from './assets.js';
 export const setupQuote = () => {
     const sellAsset = { ...FOX_MAINNET };
@@ -7,6 +7,7 @@ export const setupQuote = () => {
     const tradeQuote = {
         quoteOrRate: 'quote',
         id: 'foobar',
+        deadline: Date.now() + 60_000,
         receiveAddress: '0x1234',
         affiliateBps: '0',
         slippageTolerancePercentageDecimal: '0',

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

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

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

@@ -1,7 +1,8 @@
 import { mayachainChainId, thorchainChainId } from '@shapeshiftoss/caip';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { mayachain, thorchain } from '@shapeshiftoss/utils';
 import axios from 'axios';
-import { checkSafeTransactionStatus } from '../utils.js';
+import { checkSafeTransactionStatus } from '../../utils/index.js';
 import { getLatestThorTxStatusMessage } from './getLatestThorTxStatusMessage.js';
 import { parseThorBuyTxHash } from './parseBuyTxHash.js';
 export const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, nodeUrl, apiUrl, nativeChain, }) => {
@@ -21,6 +22,9 @@ export const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartC
             // Mutate txHash and continue with regular status check flow.
             txHash = maybeSafeTransactionStatus.buyTxHash;
         }
+        const swapperTxId = txHash.replace(/^0x/, '');
+        const nativeExplorerTxLink = nativeChain === 'THOR' ? thorchain.explorerTxLink : mayachain.explorerTxLink;
+        const swapperTxLink = `${nativeExplorerTxLink}${swapperTxId}`;
         // check for native chain tx errors
         if ((chainId === thorchainChainId && nativeChain === 'THOR') ||
             (chainId === mayachainChainId && nativeChain === 'MAYA')) {
@@ -29,6 +33,8 @@ export const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartC
                 return {
                     status: TxStatus.Failed,
                     buyTxHash: undefined,
+                    swapperTxId,
+                    swapperTxLink,
                     message: tx.events[0].error.message,
                 };
             }
@@ -40,7 +46,13 @@ export const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartC
         ]);
         // We care about txStatusData errors because it drives all of the status logic.
         if ('error' in txStatusData) {
-            return { buyTxHash: undefined, status: TxStatus.Unknown, message: undefined };
+            return {
+                buyTxHash: undefined,
+                status: 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
@@ -50,16 +62,22 @@ export const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartC
         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: TxStatus.Failed, message: undefined };
+            return { buyTxHash, status: 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: TxStatus.Confirmed, message: undefined };
+            return {
+                buyTxHash,
+                status: TxStatus.Confirmed,
+                swapperTxId,
+                swapperTxLink,
+                message: undefined,
+            };
         }
         const message = getLatestThorTxStatusMessage(txStatusData, hasOutboundL1Tx);
-        return { buyTxHash, status: TxStatus.Pending, message };
+        return { buyTxHash, status: TxStatus.Pending, swapperTxId, swapperTxLink, message };
     }
     catch (e) {
         const message = (() => {