@shapeshiftoss/swapper 20.4.0 → 20.5.0

package/dist/cjs/swappers/RelaySwapper/utils/getRelayStepData.js

@@ -37,7 +37,6 @@ async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUnit, spe
             to,
             value,
             data: callData,
-            gasLimit: (0, utils_1.bnOrZero)(relayGasLimit).gt(0) ? relayGasLimit : undefined,
         };
         const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
         const stateOverride = {
@@ -46,20 +45,12 @@ async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUnit, spe
             spenderAddress,
         };
         if (type === 'rate') {
-            const networkFeeCryptoBaseUnit = await (async () => {
-                try {
-                    return await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
-                        adapter,
-                        transactionData,
-                        from,
-                        supportsEIP1559,
-                        stateOverride,
-                    });
-                }
-                catch {
-                    return fallbackNetworkFeeCryptoBaseUnit;
-                }
-            })();
+            const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmRateNetworkFeeCryptoBaseUnit)({
+                adapter,
+                supportsEIP1559,
+                providerGasLimit: relayGasLimit,
+                simulation: { transactionData, from, stateOverride },
+            }).catch(() => fallbackNetworkFeeCryptoBaseUnit);
             const stepData = { networkFeeCryptoBaseUnit };
             return (0, monads_1.Ok)(stepData);
         }
@@ -71,6 +62,7 @@ async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUnit, spe
                 from,
                 supportsEIP1559,
                 stateOverride,
+                providerGasLimit: relayGasLimit,
             });
             const stepData = { transactionData, networkFeeCryptoBaseUnit };
             return (0, monads_1.Ok)(stepData);

package/dist/cjs/swappers/ThorchainSwapper/getTradeQuote/getTradeQuote.test.js

@@ -81,7 +81,7 @@ const expectedQuoteResponse = [
                             asset: assets_1.ETH,
                         },
                     },
-                    networkFeeCryptoBaseUnit: '400000',
+                    networkFeeCryptoBaseUnit: '480000',
                 },
                 rate: '143505.61489594191334131621',
                 source: types_1.SwapperName.Thorchain,
@@ -132,7 +132,7 @@ const expectedQuoteResponse = [
                             asset: assets_1.ETH,
                         },
                     },
-                    networkFeeCryptoBaseUnit: '400000',
+                    networkFeeCryptoBaseUnit: '480000',
                 },
                 rate: '157530.57158846677816130059',
                 source: `${types_1.SwapperName.Thorchain} • Streaming`,

package/dist/cjs/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.js

@@ -42,7 +42,7 @@ const getZrxTradeQuote = async (input, deps) => {
     });
     if (maybeZrxQuoteResponse.isErr())
         return (0, monads_1.Err)(maybeZrxQuoteResponse.unwrapErr());
-    const { sellAmount, buyAmount, fees, permit2, transaction, route } = maybeZrxQuoteResponse.unwrap();
+    const { sellAmount, buyAmount, fees, permit2, transaction, totalNetworkFee, route } = maybeZrxQuoteResponse.unwrap();
     const permit2Eip712 = permit2?.eip712;
     const permit2Deadline = permit2Eip712 ? Number(permit2Eip712.message.deadline) : undefined;
     if (permit2Deadline !== undefined &&
@@ -93,6 +93,8 @@ const getZrxTradeQuote = async (input, deps) => {
         type: 'quote',
         input,
         transaction,
+        totalNetworkFee,
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
         permit2Eip712,
         from: receiveAddress,
     });

package/dist/cjs/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/cjs/swappers/ZrxSwapper/utils/getZrxStepData.js

@@ -7,21 +7,22 @@ const monads_1 = require("@sniptt/monads");
 const utils_2 = require("../../../utils");
 const evm_1 = require("../../../utils/evm");
 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: (0, utils_1.bnOrZero)(args.totalNetworkFee).toFixed(),
+            networkFeeCryptoBaseUnit: args.totalNetworkFee ?? undefined,
         };
         return (0, monads_1.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((0, caip_1.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',
@@ -30,12 +31,30 @@ async function getZrxStepData(args) {
         }),
     };
     try {
-        const networkFeeCryptoBaseUnit = await (0, evm_1.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 (!(0, evm_1.isPositiveGasLimit)(transaction.gas))
+                    throw new Error('missing 0x gas limit');
+                transactionData.gasLimit = (0, evm_1.bufferGasLimit)(transaction.gas);
+                // 0x's total is their gas cost plus the L1 data fee on OP-stack chains
+                const l1FeeCryptoBaseUnit = utils_1.BigNumber.max((0, utils_1.bnOrZero)(totalNetworkFee).minus((0, utils_1.bnOrZero)(transaction.gas).times(transaction.gasPrice)), 0);
+                const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    supportsEIP1559,
+                    gasLimit: transactionData.gasLimit,
+                });
+                return (0, utils_1.bnOrZero)(networkFeeCryptoBaseUnit).plus(l1FeeCryptoBaseUnit).toFixed(0);
+            }
+            return (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                adapter,
+                transactionData,
+                from,
+                supportsEIP1559,
+                stateOverride: { sellAsset, sellAmountCryptoBaseUnit },
+                providerGasLimit: transaction.gas,
+            });
+        })();
         const stepData = { transactionData, networkFeeCryptoBaseUnit };
         return (0, monads_1.Ok)(stepData);
     }

package/dist/cjs/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';
@@ -44,6 +44,7 @@ export type SwapperConfig = {
     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;
@@ -80,7 +81,8 @@ export declare enum SwapperName {
     Debridge = "deBridge",
     BobGateway = "BOB Gateway",
     Symbiosis = "Symbiosis",
-    Fynd = "Fynd"
+    Fynd = "Fynd",
+    KyberSwap = "KyberSwap"
 }
 export type SwapSource = SwapperName | `${SwapperName} • ${string}`;
 export type SwapErrorRight = {
@@ -182,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;
 };
@@ -213,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'> & {
@@ -269,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;
@@ -328,6 +339,11 @@ export type TxBuildData = {
     value: string;
     data?: string;
     memo?: string;
+} | {
+    type: 'aptos';
+    payload: string;
+    gasUnitPrice: string;
+    maxGasAmount: string;
 } | {
     type: 'cowswap';
     chainId: ChainId;
@@ -515,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;
 };
@@ -532,6 +551,7 @@ type NearAccountMetadata = {
 };
 type StarknetAccountMetadata = {
     from: string;
+    callsOnly?: boolean;
 };
 type UtxoAccountMetadata = {
     senderAddress: string;
@@ -561,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;
@@ -572,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;
@@ -598,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>;
@@ -616,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>;
@@ -625,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;
@@ -653,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/cjs/types.js

@@ -24,6 +24,7 @@ var SwapperName;
     SwapperName["BobGateway"] = "BOB Gateway";
     SwapperName["Symbiosis"] = "Symbiosis";
     SwapperName["Fynd"] = "Fynd";
+    SwapperName["KyberSwap"] = "KyberSwap";
 })(SwapperName || (exports.SwapperName = SwapperName = {}));
 var TradeQuoteError;
 (function (TradeQuoteError) {

package/dist/cjs/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/cjs/utils/aptos/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APTOS_RATE_SIMULATION_VALUE = exports.APTOS_PLACEHOLDER_ADDRESS = void 0;
+// The aptos framework account usable as a sender stand-in for walletless rates
+exports.APTOS_PLACEHOLDER_ADDRESS = '0x1';
+// Rates only price the transfer, so the sender doesn't need to hold the sell amount
+exports.APTOS_RATE_SIMULATION_VALUE = '1';

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAptosTransactionFees = void 0;
+const utils_1 = require("../../utils");
+const getAptosTransactionFees = ({ tradeQuote, stepIndex, }) => {
+    if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+    if (!step.feeData.networkFeeCryptoBaseUnit)
+        throw new Error('Missing network fee in quote');
+    return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+};
+exports.getAptosTransactionFees = getAptosTransactionFees;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnsignedAptosTransaction = void 0;
+const utils_1 = require("../../utils");
+const getUnsignedAptosTransaction = ({ stepIndex, tradeQuote, from, assertGetAptosChainAdapter, }) => {
+    if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+        throw new Error('Unable to execute a trade rate');
+    const step = (0, utils_1.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 });
+};
+exports.getUnsignedAptosTransaction = getUnsignedAptosTransaction;

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

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

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

@@ -0,0 +1,19 @@
+"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("./constants"), exports);
+__exportStar(require("./getAptosTransactionFees"), exports);
+__exportStar(require("./getUnsignedAptosTransaction"), exports);

package/dist/cjs/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';
-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/cjs/utils/evm/getEvmNetworkFeeCryptoBaseUnit.js

@@ -1,52 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEvmNetworkFeeCryptoBaseUnit = void 0;
+exports.getEvmRateNetworkFeeCryptoBaseUnit = exports.getEvmNetworkFeeCryptoBaseUnit = exports.isPositiveGasLimit = exports.bufferGasLimit = exports.EVM_GAS_LIMIT_BUFFER = void 0;
 const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const utils_1 = require("@shapeshiftoss/utils");
 const stateOverride_1 = require("./stateOverride");
+exports.EVM_GAS_LIMIT_BUFFER = 1.2;
+const bufferGasLimit = (gasLimit) => (0, utils_1.bnOrZero)(gasLimit).times(exports.EVM_GAS_LIMIT_BUFFER).toFixed(0);
+exports.bufferGasLimit = bufferGasLimit;
+const isPositiveGasLimit = (gasLimit) => (0, utils_1.bnOrZero)(gasLimit).gt(0);
+exports.isPositiveGasLimit = isPositiveGasLimit;
+const priceGasLimit = async ({ adapter, supportsEIP1559 }, gasLimit) => {
+    const { average: gasPrices } = await adapter.getGasFeeData();
+    return chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({ ...gasPrices, supportsEIP1559, gasLimit });
+};
+// Prices the buffered limit, since the signer must hold enough to cover the full limit
 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 chain_adapters_1.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 && (0, utils_1.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 (0, stateOverride_1.withTimeout)((async () => {
-            const overrideArgs = {
-                sellAsset,
-                sellAmountCryptoBaseUnit,
-                from,
-                spenderAddress,
-                value,
-            };
-            const stateOverride = await (0, stateOverride_1.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 (0, stateOverride_1.withTimeout)((0, stateOverride_1.getMinimalStateOverride)(overrideArgs).then(stateOverride => stateOverride &&
+            (0, stateOverride_1.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 stateOverride_1.EstimationTimeoutError)
                 return undefined;
-            return (0, stateOverride_1.estimateGasWithStateOverride)({ ...overrideArgs, to, data, stateOverride });
-        })()).catch(() => undefined);
+            throw error;
+        });
+        if (overriddenGasLimit === null && (0, exports.isPositiveGasLimit)(providerGasLimit)) {
+            transactionData.gasLimit = (0, exports.bufferGasLimit)(providerGasLimit);
+            return priceGasLimit(args, transactionData.gasLimit);
+        }
         if (overriddenGasLimit) {
-            transactionData.gasLimit = (0, utils_1.bnOrZero)(overriddenGasLimit).times(gasLimitBuffer).toFixed(0);
-            return priceProviderGasLimit(overriddenGasLimit);
+            transactionData.gasLimit = (0, exports.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 chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-    transactionData.gasLimit = (0, utils_1.bnOrZero)(estimatedFees.gasLimit).times(gasLimitBuffer).toFixed(0);
-    return estimatedFees.networkFeeCryptoBaseUnit;
+    const { average: { chainSpecific: feeData }, } = await adapter.getFeeData({ to, value, chainSpecific: { from, data } });
+    transactionData.gasLimit = (0, exports.bufferGasLimit)(feeData.gasLimit);
+    return chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+        ...feeData,
+        supportsEIP1559,
+        gasLimit: transactionData.gasLimit,
+    });
 };
 exports.getEvmNetworkFeeCryptoBaseUnit = getEvmNetworkFeeCryptoBaseUnit;
+// Rates price a provider's limit as given (it carries its own margin) and simulate without one
+const getEvmRateNetworkFeeCryptoBaseUnit = ({ providerGasLimit, simulation, ...feeArgs }) => {
+    if ((0, exports.isPositiveGasLimit)(providerGasLimit)) {
+        return priceGasLimit(feeArgs, providerGasLimit);
+    }
+    if (simulation)
+        return (0, exports.getEvmNetworkFeeCryptoBaseUnit)({ ...feeArgs, ...simulation });
+    return Promise.reject(new Error('no gas limit to price'));
+};
+exports.getEvmRateNetworkFeeCryptoBaseUnit = getEvmRateNetworkFeeCryptoBaseUnit;

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

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