@shapeshiftoss/swapper 20.3.0 → 20.5.0

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

@@ -0,0 +1 @@
+export declare const getZrxNativeCheckDeadline: (data: string) => number | undefined;

package/dist/esm/swappers/ZrxSwapper/utils/getZrxNativeCheckDeadline.js

@@ -0,0 +1,22 @@
+import { decodeFunctionData, parseAbi, toFunctionSelector } from 'viem';
+const settlerAbi = parseAbi([
+    'function execute((address recipient, address buyToken, uint256 minAmountOut) slippage, bytes[] actions, bytes32 zid)',
+    'function NATIVE_CHECK(uint256 deadline, uint256 msgValue)',
+]);
+const NATIVE_CHECK_SELECTOR = toFunctionSelector('function NATIVE_CHECK(uint256,uint256)');
+// Native sells carry no Permit2, but Settler reverts with SignatureExpired past any NATIVE_CHECK deadline
+export const getZrxNativeCheckDeadline = (data) => {
+    try {
+        const { functionName, args } = decodeFunctionData({ abi: settlerAbi, data: data });
+        if (functionName !== 'execute')
+            return undefined;
+        const deadlines = args[1]
+            .filter(action => action.startsWith(NATIVE_CHECK_SELECTOR))
+            .map(action => decodeFunctionData({ abi: settlerAbi, data: action }))
+            .flatMap(decoded => decoded.functionName === 'NATIVE_CHECK' ? [Number(decoded.args[0])] : []);
+        return deadlines.length ? Math.min(...deadlines) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};

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

@@ -5,10 +5,12 @@ export type GetZrxStepDataArgs = StepDataArgs<unknown, {
     totalNetworkFee: string | null;
 }, {
     transaction: ZrxQuoteResponse['transaction'];
+    totalNetworkFee: string | null;
+    sellAmountCryptoBaseUnit: string;
     permit2Eip712: NonNullable<ZrxQuoteResponse['permit2']>['eip712'] | undefined;
 }>;
 type ZrxRateStepData = {
-    networkFeeCryptoBaseUnit: string;
+    networkFeeCryptoBaseUnit: string | undefined;
 };
 type ZrxQuoteStepData = {
     transactionData: TxBuildData;

package/dist/esm/swappers/ZrxSwapper/utils/getZrxStepData.js

@@ -1,24 +1,25 @@
 import { fromChainId } from '@shapeshiftoss/caip';
-import { bnOrZero } from '@shapeshiftoss/utils';
+import { BigNumber, bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
-import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { bufferGasLimit, getEvmNetworkFeeCryptoBaseUnit, isPositiveGasLimit, } from '../../../utils/evm/index.js';
 export async function getZrxStepData(args) {
+    // 0x's total includes the L1 data fee on OP-stack chains, which pricing their gas limit would drop
     if (args.type === 'rate') {
         const stepData = {
-            networkFeeCryptoBaseUnit: bnOrZero(args.totalNetworkFee).toFixed(),
+            networkFeeCryptoBaseUnit: args.totalNetworkFee ?? undefined,
         };
         return Ok(stepData);
     }
-    const { sellAsset, transaction, permit2Eip712, from, input, deps } = args;
+    const { sellAsset, sellAmountCryptoBaseUnit, transaction, totalNetworkFee, permit2Eip712, from, input, deps, } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
     const transactionData = {
         type: 'evm',
         chainId: Number(fromChainId(sellAsset.chainId).chainReference),
         to: transaction.to,
         data: transaction.data,
         value: transaction.value,
-        // 0x simulate with a valid permit2 signature, which can't be reproduced before signing, so trust their gas limit
-        gasLimit: transaction.gas || undefined,
         ...(permit2Eip712 && {
             signatureRequired: {
                 type: 'permit2',
@@ -27,12 +28,30 @@ export async function getZrxStepData(args) {
         }),
     };
     try {
-        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
-            adapter: deps.assertGetEvmChainAdapter(sellAsset.chainId),
-            transactionData,
-            from,
-            supportsEIP1559: 'supportsEIP1559' in input ? input.supportsEIP1559 : false,
-        });
+        const networkFeeCryptoBaseUnit = await (async () => {
+            // Permit2 calldata needs the signature, so it can't be simulated before signing
+            if (permit2Eip712) {
+                if (!isPositiveGasLimit(transaction.gas))
+                    throw new Error('missing 0x gas limit');
+                transactionData.gasLimit = bufferGasLimit(transaction.gas);
+                // 0x's total is their gas cost plus the L1 data fee on OP-stack chains
+                const l1FeeCryptoBaseUnit = BigNumber.max(bnOrZero(totalNetworkFee).minus(bnOrZero(transaction.gas).times(transaction.gasPrice)), 0);
+                const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    supportsEIP1559,
+                    gasLimit: transactionData.gasLimit,
+                });
+                return bnOrZero(networkFeeCryptoBaseUnit).plus(l1FeeCryptoBaseUnit).toFixed(0);
+            }
+            return getEvmNetworkFeeCryptoBaseUnit({
+                adapter,
+                transactionData,
+                from,
+                supportsEIP1559,
+                stateOverride: { sellAsset, sellAmountCryptoBaseUnit },
+                providerGasLimit: transaction.gas,
+            });
+        })();
         const stepData = { transactionData, networkFeeCryptoBaseUnit };
         return Ok(stepData);
     }

package/dist/esm/types.d.ts

@@ -1,7 +1,7 @@
 import type { AccountId, AssetId, ChainId } from '@shapeshiftoss/caip';
-import type { ChainAdapter, CosmosSdkChainAdapter, EvmChainAdapter, near, SignTx, solana, starknet, sui, ton, tron, UtxoChainAdapter } from '@shapeshiftoss/chain-adapters';
-import type { HDWallet, SolanaSignTx, StarknetSignTx, SuiSignTx } from '@shapeshiftoss/hdwallet-core';
-import type { Asset, AssetsByIdPartial, CosmosSdkChainId, EvmChainId, KnownChainIds, NearChainId, OrderCreation, PartialRecord, SolanaChainId, StarknetChainId, SuiChainId, TonChainId, TronChainId, UtxoAccountType, UtxoChainId } from '@shapeshiftoss/types';
+import type { aptos, ChainAdapter, CosmosSdkChainAdapter, EvmChainAdapter, near, SignTx, solana, starknet, sui, ton, tron, UtxoChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { AptosSignTx, HDWallet, SolanaSignTx, StarknetSignTx, SuiSignTx } from '@shapeshiftoss/hdwallet-core';
+import type { AptosChainId, Asset, AssetsByIdPartial, CosmosSdkChainId, EvmChainId, KnownChainIds, NearChainId, OrderCreation, PartialRecord, SolanaChainId, StarknetChainId, SuiChainId, TonChainId, TronChainId, UtxoAccountType, UtxoChainId } from '@shapeshiftoss/types';
 import type { TxStatus } from '@shapeshiftoss/unchained-client';
 import type { Result } from '@sniptt/monads';
 import type { TransactionInstruction } from '@solana/web3.js';
@@ -43,6 +43,8 @@ export type SwapperConfig = {
     VITE_COWSWAP_BASE_URL: string;
     VITE_PORTALS_BASE_URL: string;
     VITE_ZRX_BASE_URL: string;
+    VITE_FYND_BASE_URL: string;
+    VITE_KYBER_BASE_URL: string;
     VITE_CHAINFLIP_API_KEY: string;
     VITE_CHAINFLIP_API_URL: string;
     VITE_FEATURE_CHAINFLIP_SWAP_DCA: boolean;
@@ -56,6 +58,7 @@ export type SwapperConfig = {
     VITE_ACROSS_API_KEY: string;
     VITE_DEBRIDGE_API_URL: string;
     VITE_BOB_GATEWAY_API_KEY: string;
+    VITE_SYMBIOSIS_API_URL: string;
 };
 export declare enum SwapperName {
     Thorchain = "THORChain",
@@ -76,7 +79,10 @@ export declare enum SwapperName {
     Stonfi = "STON.fi",
     Across = "Across",
     Debridge = "deBridge",
-    BobGateway = "BOB Gateway"
+    BobGateway = "BOB Gateway",
+    Symbiosis = "Symbiosis",
+    Fynd = "Fynd",
+    KyberSwap = "KyberSwap"
 }
 export type SwapSource = SwapperName | `${SwapperName} • ${string}`;
 export type SwapErrorRight = {
@@ -178,6 +184,12 @@ export type GetTonTradeQuoteInput = CommonTradeQuoteInput & {
 export type GetTonTradeRateInput = CommonTradeRateInput & {
     chainId: TonChainId;
 };
+export type GetAptosTradeQuoteInput = CommonTradeQuoteInput & {
+    chainId: AptosChainId;
+};
+export type GetAptosTradeRateInput = CommonTradeRateInput & {
+    chainId: AptosChainId;
+};
 export type GetSolanaTradeQuoteInput = CommonTradeQuoteInput & {
     chainId: SolanaChainId;
 };
@@ -209,8 +221,8 @@ export type GetUtxoTradeRateInput = CommonTradeRateInput & {
     xpub: string | undefined;
 };
 export type GetUtxoTradeQuoteInput = GetUtxoTradeQuoteWithWallet;
-export type GetTradeQuoteInput = GetUtxoTradeQuoteInput | GetEvmTradeQuoteInput | GetCosmosSdkTradeQuoteInput | GetTronTradeQuoteInput | GetNearTradeQuoteInput | GetTonTradeQuoteInput | GetSolanaTradeQuoteInput | GetStarknetTradeQuoteInput | GetSuiTradeQuoteInput;
-export type GetTradeRateInput = GetEvmTradeRateInput | GetCosmosSdkTradeRateInput | GetUtxoTradeRateInput | GetTronTradeRateInput | GetNearTradeRateInput | GetTonTradeRateInput | GetSolanaTradeRateInput | GetStarknetTradeRateInput | GetSuiTradeRateInput;
+export type GetTradeQuoteInput = GetUtxoTradeQuoteInput | GetEvmTradeQuoteInput | GetCosmosSdkTradeQuoteInput | GetTronTradeQuoteInput | GetNearTradeQuoteInput | GetTonTradeQuoteInput | GetSolanaTradeQuoteInput | GetStarknetTradeQuoteInput | GetSuiTradeQuoteInput | GetAptosTradeQuoteInput;
+export type GetTradeRateInput = GetEvmTradeRateInput | GetCosmosSdkTradeRateInput | GetUtxoTradeRateInput | GetTronTradeRateInput | GetNearTradeRateInput | GetTonTradeRateInput | GetSolanaTradeRateInput | GetStarknetTradeRateInput | GetSuiTradeRateInput | GetAptosTradeRateInput;
 export type WithExactBuyAmount<T extends {
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
 }> = T extends unknown ? Omit<T, 'sellAmountIncludingProtocolFeesCryptoBaseUnit'> & {
@@ -265,12 +277,15 @@ export type StarknetSwapperDeps = {
 export type TonSwapperDeps = {
     assertGetTonChainAdapter: (chainId: ChainId) => ton.ChainAdapter;
 };
+export type AptosSwapperDeps = {
+    assertGetAptosChainAdapter: (chainId: ChainId) => aptos.ChainAdapter;
+};
 export type SwapperDeps = {
     assetsById: AssetsByIdPartial;
     config: SwapperConfig;
     mixPanel: Mixpanel | undefined;
     assertGetChainAdapter: (chainId: ChainId) => ChainAdapter<KnownChainIds>;
-} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps & TonSwapperDeps;
+} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps & TonSwapperDeps & AptosSwapperDeps;
 export type AffiliateFee = {
     assetId: AssetId;
     amountCryptoBaseUnit: string;
@@ -324,6 +339,11 @@ export type TxBuildData = {
     value: string;
     data?: string;
     memo?: string;
+} | {
+    type: 'aptos';
+    payload: string;
+    gasUnitPrice: string;
+    maxGasAmount: string;
 } | {
     type: 'cowswap';
     chainId: ChainId;
@@ -343,9 +363,6 @@ export type TradeStepCommon = {
     estimatedExecutionTimeMs: number | undefined;
     swapperMetadata?: SwapperMetadata;
     stonfiTransactionData?: StonfiTransactionData;
-    chainflipSpecific?: {
-        depositAddress?: string;
-    };
     affiliateFee?: AffiliateFee;
 };
 export type TradeQuoteStep = TradeStepCommon & {
@@ -452,7 +469,7 @@ export type TradeQuote = TradeQuoteBase & {
 } & {
     quoteOrRate: 'quote';
     receiveAddress: string;
-    deadline: number;
+    deadline?: number;
 };
 export type MultiHopTradeQuote = TradeQuote & {
     steps: MultiHopTradeQuoteSteps;
@@ -514,6 +531,9 @@ export type StarknetTransactionExecutionProps = {
 export type TonTransactionExecutionProps = {
     signAndBroadcastTransaction: (txToSign: ton.TonSignTx) => Promise<string>;
 };
+export type AptosTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: AptosSignTx) => Promise<string>;
+};
 type EvmAccountMetadata = {
     from: string;
 };
@@ -531,6 +551,7 @@ type NearAccountMetadata = {
 };
 type StarknetAccountMetadata = {
     from: string;
+    callsOnly?: boolean;
 };
 type UtxoAccountMetadata = {
     senderAddress: string;
@@ -560,6 +581,10 @@ type TonAccountMetadata = {
     from: string;
 };
 export type GetUnsignedTonTransactionArgs = CommonGetUnsignedTransactionArgs & TonAccountMetadata & TonSwapperDeps;
+type AptosAccountMetadata = {
+    from: string;
+};
+export type GetUnsignedAptosTransactionArgs = CommonGetUnsignedTransactionArgs & AptosAccountMetadata & AptosSwapperDeps;
 export type GetUnsignedEvmMessageArgs = CommonGetUnsignedTransactionArgs & EvmAccountMetadata & Omit<EvmSwapperDeps, 'fetchIsSmartContractAddressQuery'>;
 export type GetUnsignedSolanaMessageArgs = CommonGetUnsignedTransactionArgs;
 export type GetUnsignedUtxoTransactionArgs = CommonGetUnsignedTransactionArgs & UtxoAccountMetadata & UtxoSwapperDeps;
@@ -571,7 +596,7 @@ export type CheckTradeStatusInput = {
     stepIndex: SupportedTradeQuoteStepIndex;
     config: SwapperConfig;
     swap: Swap | undefined;
-} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps & TonSwapperDeps;
+} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps & TonSwapperDeps & AptosSwapperDeps;
 export type TradeStatus = {
     status: TxStatus;
     buyTxHash: string | undefined;
@@ -597,6 +622,7 @@ export type Swapper = {
     executeNearTransaction?: (txToSign: near.NearSignTx, callbacks: NearTransactionExecutionProps) => Promise<string>;
     executeStarknetTransaction?: (txToSign: StarknetSignTx, callbacks: StarknetTransactionExecutionProps) => Promise<string>;
     executeTonTransaction?: (txToSign: ton.TonSignTx, callbacks: TonTransactionExecutionProps) => Promise<string>;
+    executeAptosTransaction?: (txToSign: AptosSignTx, callbacks: AptosTransactionExecutionProps) => Promise<string>;
 };
 export type SwapperApi = {
     checkTradeStatus: (input: CheckTradeStatusInput) => Promise<TradeStatus>;
@@ -615,6 +641,7 @@ export type SwapperApi = {
     getUnsignedNearTransaction?: (input: GetUnsignedNearTransactionArgs) => Promise<near.NearSignTx>;
     getUnsignedStarknetTransaction?: (input: GetUnsignedStarknetTransactionArgs) => Promise<StarknetSignTx>;
     getUnsignedTonTransaction?: (input: GetUnsignedTonTransactionArgs) => Promise<ton.TonSignTx>;
+    getUnsignedAptosTransaction?: (input: GetUnsignedAptosTransactionArgs) => Promise<AptosSignTx>;
     getEvmTransactionFees?: (input: GetUnsignedEvmTransactionArgs) => Promise<string>;
     getSolanaTransactionFees?: (input: GetUnsignedSolanaTransactionArgs) => Promise<string>;
     getSuiTransactionFees?: (input: GetUnsignedSuiTransactionArgs) => Promise<string>;
@@ -624,6 +651,7 @@ export type SwapperApi = {
     getNearTransactionFees?: (input: GetUnsignedNearTransactionArgs) => Promise<string>;
     getStarknetTransactionFees?: (input: GetUnsignedStarknetTransactionArgs) => Promise<string>;
     getTonTransactionFees?: (input: GetUnsignedTonTransactionArgs) => Promise<string>;
+    getAptosTransactionFees?: (input: GetUnsignedAptosTransactionArgs) => Promise<string>;
 };
 export type QuoteResult = Result<TradeQuote[], SwapErrorRight> & {
     swapperName: SwapperName;
@@ -652,6 +680,7 @@ export type SuiTransactionExecutionInput = CommonTradeExecutionInput & SuiTransa
 export type NearTransactionExecutionInput = CommonTradeExecutionInput & NearTransactionExecutionProps & NearAccountMetadata;
 export type StarknetTransactionExecutionInput = CommonTradeExecutionInput & StarknetTransactionExecutionProps & StarknetAccountMetadata;
 export type TonTransactionExecutionInput = CommonTradeExecutionInput & TonTransactionExecutionProps & TonAccountMetadata;
+export type AptosTransactionExecutionInput = CommonTradeExecutionInput & AptosTransactionExecutionProps & AptosAccountMetadata;
 export declare enum TradeExecutionEvent {
     SellTxHash = "sellTxHash",
     Status = "status",

package/dist/esm/types.js

@@ -19,6 +19,9 @@ export var SwapperName;
     SwapperName["Across"] = "Across";
     SwapperName["Debridge"] = "deBridge";
     SwapperName["BobGateway"] = "BOB Gateway";
+    SwapperName["Symbiosis"] = "Symbiosis";
+    SwapperName["Fynd"] = "Fynd";
+    SwapperName["KyberSwap"] = "KyberSwap";
 })(SwapperName || (SwapperName = {}));
 export var TradeQuoteError;
 (function (TradeQuoteError) {

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

@@ -0,0 +1,2 @@
+export declare const APTOS_PLACEHOLDER_ADDRESS = "0x1";
+export declare const APTOS_RATE_SIMULATION_VALUE = "1";

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

@@ -0,0 +1,4 @@
+// The aptos framework account usable as a sender stand-in for walletless rates
+export const APTOS_PLACEHOLDER_ADDRESS = '0x1';
+// Rates only price the transfer, so the sender doesn't need to hold the sell amount
+export const APTOS_RATE_SIMULATION_VALUE = '1';

package/dist/esm/utils/aptos/getAptosTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedAptosTransactionArgs } from '../../types.js';
+export declare const getAptosTransactionFees: ({ tradeQuote, stepIndex, }: Pick<GetUnsignedAptosTransactionArgs, 'tradeQuote' | 'stepIndex'>) => Promise<string>;

package/dist/esm/utils/aptos/getAptosTransactionFees.js

@@ -0,0 +1,9 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils/index.js';
+export const getAptosTransactionFees = ({ tradeQuote, stepIndex, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    if (!step.feeData.networkFeeCryptoBaseUnit)
+        throw new Error('Missing network fee in quote');
+    return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+};

package/dist/esm/utils/aptos/getUnsignedAptosTransaction.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedAptosTransactionArgs } from '../../types.js';
+export declare const getUnsignedAptosTransaction: ({ stepIndex, tradeQuote, from, assertGetAptosChainAdapter, }: GetUnsignedAptosTransactionArgs) => Promise<import("@shapeshiftoss/hdwallet-core").AptosSignTx>;

package/dist/esm/utils/aptos/getUnsignedAptosTransaction.js

@@ -0,0 +1,12 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils/index.js';
+export const getUnsignedAptosTransaction = ({ stepIndex, tradeQuote, from, assertGetAptosChainAdapter, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { accountNumber, sellAsset, transactionData } = step;
+    if (transactionData?.type !== 'aptos')
+        throw new Error('Missing aptos transactionData');
+    const adapter = assertGetAptosChainAdapter(sellAsset.chainId);
+    const { payload, gasUnitPrice, maxGasAmount } = transactionData;
+    return adapter.buildCustomApiTx({ from, accountNumber, payload, gasUnitPrice, maxGasAmount });
+};

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

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './getAptosTransactionFees.js';
+export * from './getUnsignedAptosTransaction.js';

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

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './getAptosTransactionFees.js';
+export * from './getUnsignedAptosTransaction.js';

package/dist/esm/utils/evm/getEvmNetworkFeeCryptoBaseUnit.d.ts

@@ -1,22 +1,35 @@
 import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
 import type { Asset } from '@shapeshiftoss/types';
 import type { TxBuildData } from '../../types.js';
-type GetEvmNetworkFeeCryptoBaseUnitArgs = {
+export declare const EVM_GAS_LIMIT_BUFFER = 1.2;
+export declare const bufferGasLimit: (gasLimit: string) => string;
+export declare const isPositiveGasLimit: (gasLimit: string | null | undefined) => gasLimit is string;
+type EvmFeeArgs = {
     adapter: EvmChainAdapter;
     supportsEIP1559: boolean;
-} & ({
-    gasLimit: string;
-} | {
+};
+type EvmSimulationArgs = {
     transactionData: Extract<TxBuildData, {
         type: 'evm';
     }>;
     from: string;
-    gasLimitBuffer?: number;
     stateOverride?: {
         sellAsset: Asset;
         sellAmountCryptoBaseUnit: string;
         spenderAddress?: string;
     };
-});
+};
+type FixedGasLimitArgs = {
+    gasLimit: string;
+};
+type SimulatedGasLimitArgs = EvmSimulationArgs & {
+    providerGasLimit?: string | null;
+};
+type GetEvmNetworkFeeCryptoBaseUnitArgs = EvmFeeArgs & (FixedGasLimitArgs | SimulatedGasLimitArgs);
 export declare const getEvmNetworkFeeCryptoBaseUnit: (args: GetEvmNetworkFeeCryptoBaseUnitArgs) => Promise<string>;
+type GetEvmRateNetworkFeeCryptoBaseUnitArgs = EvmFeeArgs & {
+    providerGasLimit: string | null | undefined;
+    simulation?: EvmSimulationArgs;
+};
+export declare const getEvmRateNetworkFeeCryptoBaseUnit: ({ providerGasLimit, simulation, ...feeArgs }: GetEvmRateNetworkFeeCryptoBaseUnitArgs) => Promise<string>;
 export {};

package/dist/esm/utils/evm/getEvmNetworkFeeCryptoBaseUnit.js

@@ -1,48 +1,55 @@
 import { evm } from '@shapeshiftoss/chain-adapters';
 import { bnOrZero } from '@shapeshiftoss/utils';
-import { estimateGasWithStateOverride, getMinimalStateOverride, withTimeout } from './stateOverride.js';
+import { estimateGasWithStateOverride, EstimationTimeoutError, getMinimalStateOverride, withTimeout, } from './stateOverride.js';
+export const EVM_GAS_LIMIT_BUFFER = 1.2;
+export const bufferGasLimit = (gasLimit) => bnOrZero(gasLimit).times(EVM_GAS_LIMIT_BUFFER).toFixed(0);
+export const isPositiveGasLimit = (gasLimit) => bnOrZero(gasLimit).gt(0);
+const priceGasLimit = async ({ adapter, supportsEIP1559 }, gasLimit) => {
+    const { average: gasPrices } = await adapter.getGasFeeData();
+    return evm.calcNetworkFeeCryptoBaseUnit({ ...gasPrices, supportsEIP1559, gasLimit });
+};
+// Prices the buffered limit, since the signer must hold enough to cover the full limit
 export const getEvmNetworkFeeCryptoBaseUnit = async (args) => {
     const { adapter, supportsEIP1559 } = args;
-    // Price a provider gas limit with fresh gas prices - no on chain estimation
-    const priceProviderGasLimit = async (gasLimit) => {
-        const { average: gasPrices } = await adapter.getGasFeeData();
-        return evm.calcNetworkFeeCryptoBaseUnit({ ...gasPrices, supportsEIP1559, gasLimit });
-    };
-    // Rate network fee: the caller passed a provider gas limit directly
     if (!('transactionData' in args))
-        return priceProviderGasLimit(args.gasLimit);
-    const { transactionData, from, gasLimitBuffer = 1.2 } = args;
-    // Executable quote: the provider supplied a gas limit on the tx data, price it as-is
-    const providerGasLimit = transactionData.gasLimit;
-    if (providerGasLimit && bnOrZero(providerGasLimit).gt(0)) {
-        return priceProviderGasLimit(providerGasLimit);
-    }
+        return priceGasLimit(args, args.gasLimit);
+    const { transactionData, from, providerGasLimit } = args;
     const { to, data, value } = transactionData;
     if (args.stateOverride) {
         const { sellAsset, sellAmountCryptoBaseUnit, spenderAddress } = args.stateOverride;
-        // Best effort - a timeout, undiscoverable slot, or an rpc without stateOverride support falls
-        // through to plain estimation, which succeeds whenever the seller's state was sufficient anyway
-        const overriddenGasLimit = await withTimeout((async () => {
-            const overrideArgs = {
-                sellAsset,
-                sellAmountCryptoBaseUnit,
-                from,
-                spenderAddress,
-                value,
-            };
-            const stateOverride = await getMinimalStateOverride(overrideArgs);
-            if (!stateOverride)
+        const overrideArgs = { sellAsset, sellAmountCryptoBaseUnit, from, spenderAddress, value };
+        // null when the override can't be built (an undiscoverable storage slot or a failed read),
+        // undefined when nothing needs overriding or the simulation timed out
+        const overriddenGasLimit = await withTimeout(getMinimalStateOverride(overrideArgs).then(stateOverride => stateOverride &&
+            estimateGasWithStateOverride({ ...overrideArgs, to, data, stateOverride }), () => null)).catch(error => {
+            // The missing state makes a plain estimate revert too, so only a timeout falls through to it
+            if (error instanceof EstimationTimeoutError)
                 return undefined;
-            return estimateGasWithStateOverride({ ...overrideArgs, to, data, stateOverride });
-        })()).catch(() => undefined);
+            throw error;
+        });
+        if (overriddenGasLimit === null && isPositiveGasLimit(providerGasLimit)) {
+            transactionData.gasLimit = bufferGasLimit(providerGasLimit);
+            return priceGasLimit(args, transactionData.gasLimit);
+        }
         if (overriddenGasLimit) {
-            transactionData.gasLimit = bnOrZero(overriddenGasLimit).times(gasLimitBuffer).toFixed(0);
-            return priceProviderGasLimit(overriddenGasLimit);
+            transactionData.gasLimit = bufferGasLimit(overriddenGasLimit);
+            return priceGasLimit(args, transactionData.gasLimit);
         }
     }
-    // Estimate on chain, then set the buffered limit on the tx data in place so the executable tx
-    // always carries a gas limit
-    const estimatedFees = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-    transactionData.gasLimit = bnOrZero(estimatedFees.gasLimit).times(gasLimitBuffer).toFixed(0);
-    return estimatedFees.networkFeeCryptoBaseUnit;
+    const { average: { chainSpecific: feeData }, } = await adapter.getFeeData({ to, value, chainSpecific: { from, data } });
+    transactionData.gasLimit = bufferGasLimit(feeData.gasLimit);
+    return evm.calcNetworkFeeCryptoBaseUnit({
+        ...feeData,
+        supportsEIP1559,
+        gasLimit: transactionData.gasLimit,
+    });
+};
+// Rates price a provider's limit as given (it carries its own margin) and simulate without one
+export const getEvmRateNetworkFeeCryptoBaseUnit = ({ providerGasLimit, simulation, ...feeArgs }) => {
+    if (isPositiveGasLimit(providerGasLimit)) {
+        return priceGasLimit(feeArgs, providerGasLimit);
+    }
+    if (simulation)
+        return getEvmNetworkFeeCryptoBaseUnit({ ...feeArgs, ...simulation });
+    return Promise.reject(new Error('no gas limit to price'));
 };

package/dist/esm/utils/evm/getEvmNetworkFeeCryptoBaseUnit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/evm/getEvmNetworkFeeCryptoBaseUnit.test.js

@@ -0,0 +1,101 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from './getEvmNetworkFeeCryptoBaseUnit.js';
+import { estimateGasWithStateOverride, EstimationTimeoutError, getMinimalStateOverride, } from './stateOverride.js';
+vi.mock('./stateOverride', async (importActual) => ({
+    ...(await importActual()),
+    getMinimalStateOverride: vi.fn(),
+    estimateGasWithStateOverride: vi.fn(),
+}));
+const gasFees = { gasPrice: '10' };
+const makeTransactionData = () => ({ type: 'evm', to: '0x1', data: '0x', value: '0' });
+const makeArgs = (adapter) => ({
+    adapter: adapter,
+    supportsEIP1559: false,
+    transactionData: makeTransactionData(),
+    from: '0x0000000000000000000000000000000000000001',
+    stateOverride: { sellAsset: {}, sellAmountCryptoBaseUnit: '1' },
+});
+describe('getEvmNetworkFeeCryptoBaseUnit state override', () => {
+    beforeEach(() => {
+        vi.mocked(getMinimalStateOverride).mockReset();
+        vi.mocked(estimateGasWithStateOverride).mockReset();
+    });
+    it('buffers the override gas limit onto the tx and prices the buffered limit', async () => {
+        vi.mocked(getMinimalStateOverride).mockResolvedValue([]);
+        vi.mocked(estimateGasWithStateOverride).mockResolvedValue('200');
+        const args = makeArgs({ getGasFeeData: vi.fn().mockResolvedValue({ average: gasFees }) });
+        await expect(getEvmNetworkFeeCryptoBaseUnit(args)).resolves.toBe('2400');
+        expect(args.transactionData.gasLimit).toBe('240');
+    });
+    it('falls back to plain estimation when the override simulation times out', async () => {
+        vi.mocked(getMinimalStateOverride).mockResolvedValue([]);
+        vi.mocked(estimateGasWithStateOverride).mockRejectedValue(new EstimationTimeoutError());
+        const getFeeData = vi.fn().mockResolvedValue({
+            average: { chainSpecific: { gasLimit: '100', ...gasFees } },
+        });
+        const args = makeArgs({
+            getGasFeeData: vi.fn().mockResolvedValue({ average: gasFees }),
+            getFeeData,
+        });
+        await expect(getEvmNetworkFeeCryptoBaseUnit(args)).resolves.toBe('1200');
+        expect(args.transactionData.gasLimit).toBe('120');
+    });
+    it('estimates over a provider gas limit already set on the tx', async () => {
+        vi.mocked(getMinimalStateOverride).mockResolvedValue([]);
+        vi.mocked(estimateGasWithStateOverride).mockResolvedValue('200');
+        const args = makeArgs({ getGasFeeData: vi.fn().mockResolvedValue({ average: gasFees }) });
+        args.transactionData.gasLimit = '150';
+        await expect(getEvmNetworkFeeCryptoBaseUnit(args)).resolves.toBe('2400');
+        expect(args.transactionData.gasLimit).toBe('240');
+    });
+    it('signs the buffered provider limit when the needed override cannot be built', async () => {
+        vi.mocked(getMinimalStateOverride).mockRejectedValue(new Error('Unable to locate allowance slot'));
+        const args = {
+            ...makeArgs({ getGasFeeData: vi.fn().mockResolvedValue({ average: gasFees }) }),
+            providerGasLimit: '300',
+        };
+        await expect(getEvmNetworkFeeCryptoBaseUnit(args)).resolves.toBe('3600');
+        expect(args.transactionData.gasLimit).toBe('360');
+        expect(estimateGasWithStateOverride).not.toHaveBeenCalled();
+    });
+    it('fails rather than trusting the provider limit when the overridden simulation reverts', async () => {
+        vi.mocked(getMinimalStateOverride).mockResolvedValue([]);
+        vi.mocked(estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+        const getFeeData = vi.fn();
+        const args = {
+            ...makeArgs({ getGasFeeData: vi.fn().mockResolvedValue({ average: gasFees }), getFeeData }),
+            providerGasLimit: '300',
+        };
+        await expect(getEvmNetworkFeeCryptoBaseUnit(args)).rejects.toThrow('execution reverted');
+        expect(getFeeData).not.toHaveBeenCalled();
+    });
+});
+describe('getEvmRateNetworkFeeCryptoBaseUnit', () => {
+    beforeEach(() => {
+        vi.mocked(getMinimalStateOverride).mockReset();
+        vi.mocked(estimateGasWithStateOverride).mockReset();
+    });
+    it('prices the provider limit as given without simulating', async () => {
+        const { transactionData, from, stateOverride, ...feeArgs } = makeArgs({
+            getGasFeeData: vi.fn().mockResolvedValue({ average: gasFees }),
+        });
+        await expect(getEvmRateNetworkFeeCryptoBaseUnit({
+            ...feeArgs,
+            providerGasLimit: '300',
+            simulation: { transactionData, from, stateOverride },
+        })).resolves.toBe('3000');
+        expect(getMinimalStateOverride).not.toHaveBeenCalled();
+    });
+    it('simulates when the provider has no gas limit', async () => {
+        vi.mocked(getMinimalStateOverride).mockResolvedValue([]);
+        vi.mocked(estimateGasWithStateOverride).mockResolvedValue('200');
+        const { transactionData, from, stateOverride, ...feeArgs } = makeArgs({
+            getGasFeeData: vi.fn().mockResolvedValue({ average: gasFees }),
+        });
+        await expect(getEvmRateNetworkFeeCryptoBaseUnit({
+            ...feeArgs,
+            providerGasLimit: undefined,
+            simulation: { transactionData, from, stateOverride },
+        })).resolves.toBe('2400');
+    });
+});

package/dist/esm/utils/evm/stateOverride.d.ts

@@ -1,5 +1,8 @@
 import type { Asset } from '@shapeshiftoss/types';
 import type { StateOverride } from 'viem';
+export declare class EstimationTimeoutError extends Error {
+    constructor();
+}
 export declare const withTimeout: <T>(promise: Promise<T>) => Promise<T>;
 export type GetMinimalStateOverrideArgs = {
     sellAsset: Asset;

package/dist/esm/utils/evm/stateOverride.js

@@ -26,13 +26,18 @@ const discoveredSlots = new Map();
 const rawDiscoveredSlots = new Map();
 const failedSlotDiscoveries = new Map();
 const FAILED_DISCOVERY_TTL_MS = 60_000;
+export class EstimationTimeoutError extends Error {
+    constructor() {
+        super('State override estimation timed out');
+    }
+}
 export const withTimeout = async (promise) => {
     let timer;
     try {
         return await Promise.race([
             promise,
             new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error('State override estimation timed out')), ESTIMATION_TIMEOUT_MS);
+                timer = setTimeout(() => reject(new EstimationTimeoutError()), ESTIMATION_TIMEOUT_MS);
             }),
         ]);
     }
@@ -288,7 +293,7 @@ export const getMinimalStateOverride = async ({ sellAsset, sellAmountCryptoBaseU
 // only the missing state. Estimation runs on our own RPCs - the node applies the same engine over
 // the patched pre-state, so the only systematic delta is the unrealized allowance-decrement refund
 // (a few k gas high, conservative).
-export const estimateGasWithStateOverride = ({ to, data, stateOverride: prebuiltStateOverride, ...overrideArgs }) => withTimeout((async () => {
+export const estimateGasWithStateOverride = async ({ to, data, stateOverride: prebuiltStateOverride, ...overrideArgs }) => {
     const client = assertGetViemClient(overrideArgs.sellAsset.chainId);
     const stateOverride = prebuiltStateOverride ?? (await getMinimalStateOverride(overrideArgs));
     const gasLimit = await client.estimateGas({
@@ -299,4 +304,4 @@ export const estimateGasWithStateOverride = ({ to, data, stateOverride: prebuilt
         ...(stateOverride ? { stateOverride } : {}),
     });
     return gasLimit.toString();
-})());
+};