@shapeshiftoss/swapper 20.4.0 → 20.6.0

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

@@ -1,9 +1,9 @@
 import { fromChainId } from '@shapeshiftoss/caip';
 import { tron } from '@shapeshiftoss/chain-adapters';
-import { bnOrZero, contractAddressOrUndefined, isToken } from '@shapeshiftoss/utils';
+import { contractAddressOrUndefined, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr, makeTradeStepBuildFailedErr } from '../../../utils/index.js';
-import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
 import { getSolanaNetworkFeeCryptoBaseUnit, omitComputeBudgetInstructions, withComputeUnitLimit, } from '../../../utils/solana/index.js';
 import { getTronContractCallFallbackFeeCryptoBaseUnit, getTronContractCallNetworkFeeCryptoBaseUnit, } from '../../../utils/tron/index.js';
 import { getUtxoNetworkFeeCryptoBaseUnit } from '../../../utils/utxo/index.js';
@@ -34,7 +34,6 @@ export async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUn
             to,
             value,
             data: callData,
-            gasLimit: bnOrZero(relayGasLimit).gt(0) ? relayGasLimit : undefined,
         };
         const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
         const stateOverride = {
@@ -43,20 +42,12 @@ export async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUn
             spenderAddress,
         };
         if (type === 'rate') {
-            const networkFeeCryptoBaseUnit = await (async () => {
-                try {
-                    return await getEvmNetworkFeeCryptoBaseUnit({
-                        adapter,
-                        transactionData,
-                        from,
-                        supportsEIP1559,
-                        stateOverride,
-                    });
-                }
-                catch {
-                    return fallbackNetworkFeeCryptoBaseUnit;
-                }
-            })();
+            const networkFeeCryptoBaseUnit = await getEvmRateNetworkFeeCryptoBaseUnit({
+                adapter,
+                supportsEIP1559,
+                providerGasLimit: relayGasLimit,
+                simulation: { transactionData, from, stateOverride },
+            }).catch(() => fallbackNetworkFeeCryptoBaseUnit);
             const stepData = { networkFeeCryptoBaseUnit };
             return Ok(stepData);
         }
@@ -68,6 +59,7 @@ export async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUn
                 from,
                 supportsEIP1559,
                 stateOverride,
+                providerGasLimit: relayGasLimit,
             });
             const stepData = { transactionData, networkFeeCryptoBaseUnit };
             return Ok(stepData);

package/dist/esm/swappers/RelaySwapper/utils/relayTokenToAssetId.js

@@ -234,6 +234,11 @@ export const relayTokenToAssetId = (relayToken) => {
                     assetReference: ASSET_REFERENCE.Robinhood,
                     assetNamespace: ASSET_NAMESPACE.slip44,
                 };
+            case CHAIN_REFERENCE.ElysiumMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Elysium,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
             default:
                 throw Error(`chainId '${relayToken.chainId}' not supported`);
         }

package/dist/esm/swappers/ThorchainSwapper/generated/generatedThorLongtailTokens.json

@@ -1018,6 +1018,7 @@
     "eip155:1/erc20:0xcbb8f1bda10b9696c57e13bc128fe674769dcec0",
     "eip155:1/erc20:0x72dfb2e44f59c5ad2bafe84314e5b99a7cd5075e",
     "eip155:1/erc20:0xce682c89c63d2850cb2ca898e44d6c7c30d897a6",
+    "eip155:1/erc20:0x68749665ff8d2d112fa859aa293f07a622782f38",
     "eip155:43114/erc20:0xc891eb4cbdeff6e073e859e987815ed1505c2acd",
     "eip155:43114/erc20:0xd24c2ad096400b6fbcd2ad8b24e7acbc21a1da64",
     "eip155:43114/erc20:0x47c3118ad183712acd42648e9e522e13690f29a0",

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

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

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

@@ -39,7 +39,7 @@ export const getZrxTradeQuote = async (input, deps) => {
     });
     if (maybeZrxQuoteResponse.isErr())
         return 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 &&
@@ -90,6 +90,8 @@ export const getZrxTradeQuote = async (input, deps) => {
         type: 'quote',
         input,
         transaction,
+        totalNetworkFee,
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
         permit2Eip712,
         from: receiveAddress,
     });

package/dist/esm/swappers/ZrxSwapper/types.d.ts

@@ -4,7 +4,7 @@ import type { Address } from 'viem';
 import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types.js';
 export type ZrxTradeQuoteInput = GetEvmTradeQuoteInput;
 export type ZrxTradeRateInput = GetEvmTradeRateInput;
-export declare const zrxSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.RobinhoodMainnet];
+export declare const zrxSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.RobinhoodMainnet, KnownChainIds.ElysiumMainnet];
 export type ZrxSupportedChainId = (typeof zrxSupportedChainIds)[number];
 type ZrxFee = {
     amount: string;

package/dist/esm/swappers/ZrxSwapper/types.js

@@ -8,4 +8,5 @@ export const zrxSupportedChainIds = [
     KnownChainIds.ArbitrumMainnet,
     KnownChainIds.BaseMainnet,
     KnownChainIds.RobinhoodMainnet,
+    KnownChainIds.ElysiumMainnet,
 ];

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

@@ -19,6 +19,7 @@ export const ZRX_SUPPORTED_CHAINIDS = Object.freeze([
     KnownChainIds.ArbitrumMainnet,
     KnownChainIds.BaseMainnet,
     KnownChainIds.RobinhoodMainnet,
+    KnownChainIds.ElysiumMainnet,
 ]);
 // https://0x.org/docs/developer-resources/faqs-and-troubleshooting
 export const ZRX_NATIVE_ASSET_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

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/swappers/ZrxSwapper/utils/helpers.d.ts

@@ -6,7 +6,7 @@ import type { SwapErrorRight } from '../../../types.js';
 import type { ZrxFees, ZrxPriceResponse } from '../types.js';
 export declare const assetIdToZrxToken: (assetId: AssetId) => string;
 export declare const zrxTokenToAssetId: (token: string, chainId: ChainId) => AssetId;
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet | KnownChainIds.OptimismMainnet | KnownChainIds.BnbSmartChainMainnet | KnownChainIds.PolygonMainnet | KnownChainIds.ArbitrumMainnet | KnownChainIds.BaseMainnet | KnownChainIds.RobinhoodMainnet;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet | KnownChainIds.OptimismMainnet | KnownChainIds.BnbSmartChainMainnet | KnownChainIds.PolygonMainnet | KnownChainIds.ArbitrumMainnet | KnownChainIds.BaseMainnet | KnownChainIds.RobinhoodMainnet | KnownChainIds.ElysiumMainnet;
 export declare const isWrappedNativeSell: (route: ZrxPriceResponse['route']) => boolean;
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;

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

@@ -61,6 +61,11 @@ export const zrxTokenToAssetId = (token, chainId) => {
                     assetReference: ASSET_REFERENCE.Robinhood,
                     assetNamespace: ASSET_NAMESPACE.slip44,
                 };
+            case KnownChainIds.ElysiumMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Elysium,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
             default:
                 throw Error(`chainId '${chainId}' not supported`);
         }

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';
@@ -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/esm/types.js

@@ -21,6 +21,7 @@ export var SwapperName;
     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 {};