@shapeshiftoss/swapper 20.3.0 → 20.5.0

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@shapeshiftoss/types");
+const monads_1 = require("@sniptt/monads");
+const vitest_1 = require("vitest");
+const types_2 = require("../../../types");
+const assets_1 = require("../../../utils/test-data/assets");
+const fetchFromZrx_1 = require("../utils/fetchFromZrx");
+const getZrxTradeQuote_1 = require("./getZrxTradeQuote");
+vitest_1.vi.mock('../utils/fetchFromZrx', () => ({ fetchZrxQuote: vitest_1.vi.fn() }));
+vitest_1.vi.mock('../utils/getZrxStepData', () => ({
+    getZrxStepData: vitest_1.vi.fn(({ permit2Eip712 }) => Promise.resolve((0, monads_1.Ok)({
+        transactionData: {
+            type: 'evm',
+            chainId: 1,
+            to: '0x1111111111111111111111111111111111111111',
+            data: '0x1234',
+            value: '0',
+            ...(permit2Eip712 && {
+                signatureRequired: { type: 'permit2', eip712: permit2Eip712 },
+            }),
+        },
+        networkFeeCryptoBaseUnit: '100000',
+    }))),
+}));
+const input = {
+    sellAsset: assets_1.WETH,
+    buyAsset: assets_1.USDC_MAINNET,
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000',
+    sendAddress: '0x1111111111111111111111111111111111111111',
+    receiveAddress: '0x1111111111111111111111111111111111111111',
+    accountNumber: 0,
+    affiliateBps: '0',
+    allowMultiHop: false,
+    quoteOrRate: 'quote',
+    chainId: types_1.KnownChainIds.EthereumMainnet,
+    supportsEIP1559: true,
+};
+const deps = {
+    assetsById: {},
+    config: { VITE_ZRX_BASE_URL: 'https://example.com' },
+};
+const typedData = (deadline) => ({
+    domain: { name: 'Permit2', chainId: 1 },
+    types: { PermitTransferFrom: [{ name: 'deadline', type: 'uint256' }] },
+    primaryType: 'PermitTransferFrom',
+    message: { deadline },
+});
+// Live Settler calldata for an ETH -> USDC sell, NATIVE_CHECK deadline 1791997786
+const nativeSellCalldata = '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';
+const quoteResponse = (eip712, data = '0x1234') => ({
+    blockNumber: '1',
+    buyAmount: '1000000',
+    buyToken: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    sellAmount: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+    sellToken: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+    fees: { integratorFee: null, zeroExFee: null, gasFee: null },
+    issues: { allowance: null, balance: null, simulationIncomplete: false, invalidSourcesPassed: [] },
+    liquidityAvailable: true,
+    minBuyAmount: '990000',
+    route: { fills: [], tokens: [] },
+    tokenMetadata: {
+        buyToken: { buyTaxBps: null, sellTaxBps: null },
+        sellToken: { buyTaxBps: null, sellTaxBps: null },
+    },
+    totalNetworkFee: null,
+    zid: 'test',
+    permit2: eip712 ? { type: 'Permit2', hash: '0x1234', eip712 } : null,
+    transaction: {
+        to: '0x1111111111111111111111111111111111111111',
+        data,
+        gas: '100000',
+        gasPrice: '1000000000',
+        value: '0',
+    },
+});
+(0, vitest_1.describe)('getZrxTradeQuote Permit2 deadline', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.mocked(fetchFromZrx_1.fetchZrxQuote).mockResolvedValue((0, monads_1.Ok)(quoteResponse(typedData('1791934983'))));
+    });
+    vitest_1.it.each(['1791934983', 1791934983])('uses the provider deadline in milliseconds (%s)', async (deadline) => {
+        const eip712 = typedData(deadline);
+        vitest_1.vi.mocked(fetchFromZrx_1.fetchZrxQuote).mockResolvedValue((0, monads_1.Ok)(quoteResponse(eip712)));
+        const result = await (0, getZrxTradeQuote_1.getZrxTradeQuote)(input, deps);
+        (0, vitest_1.expect)(result.isOk()).toBe(true);
+        const [quote] = result.unwrap();
+        (0, vitest_1.expect)(quote.deadline).toBe(1791934983000);
+        (0, vitest_1.expect)(quote.steps[0].transactionData).toMatchObject({
+            signatureRequired: { eip712 },
+        });
+    });
+    vitest_1.it.each([undefined, null, true, '', 'invalid', '-1', '1.5', '9007199254740991'])('rejects an invalid Permit2 deadline (%s)', async (deadline) => {
+        vitest_1.vi.mocked(fetchFromZrx_1.fetchZrxQuote).mockResolvedValue((0, monads_1.Ok)(quoteResponse(typedData(deadline))));
+        const result = await (0, getZrxTradeQuote_1.getZrxTradeQuote)(input, deps);
+        (0, vitest_1.expect)(result.isErr()).toBe(true);
+        (0, vitest_1.expect)(result.unwrapErr().code).toBe(types_2.TradeQuoteError.InvalidResponse);
+    });
+    (0, vitest_1.it)('reads the NATIVE_CHECK deadline from native-token sell calldata', async () => {
+        vitest_1.vi.mocked(fetchFromZrx_1.fetchZrxQuote).mockResolvedValue((0, monads_1.Ok)(quoteResponse(null, nativeSellCalldata)));
+        const result = await (0, getZrxTradeQuote_1.getZrxTradeQuote)({ ...input, sellAsset: assets_1.ETH }, deps);
+        (0, vitest_1.expect)(result.isOk()).toBe(true);
+        (0, vitest_1.expect)(result.unwrap()[0].deadline).toBe(1791997786000);
+    });
+    (0, vitest_1.it)('leaves native-token quotes without a NATIVE_CHECK action free of a fabricated deadline', async () => {
+        vitest_1.vi.mocked(fetchFromZrx_1.fetchZrxQuote).mockResolvedValue((0, monads_1.Ok)(quoteResponse(null)));
+        const result = await (0, getZrxTradeQuote_1.getZrxTradeQuote)({ ...input, sellAsset: assets_1.ETH }, deps);
+        (0, vitest_1.expect)(result.isOk()).toBe(true);
+        (0, vitest_1.expect)(result.unwrap()[0].deadline).toBeUndefined();
+    });
+});

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

@@ -1,5 +1,6 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
-import type { Address, TypedData } from 'viem';
+import type { TypedData } from 'eip-712';
+import type { Address } from 'viem';
 import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types';
 export type ZrxTradeQuoteInput = GetEvmTradeQuoteInput;
 export type ZrxTradeRateInput = GetEvmTradeRateInput;

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZrxNativeCheckDeadline = void 0;
+const viem_1 = require("viem");
+const settlerAbi = (0, viem_1.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 = (0, viem_1.toFunctionSelector)('function NATIVE_CHECK(uint256,uint256)');
+// Native sells carry no Permit2, but Settler reverts with SignatureExpired past any NATIVE_CHECK deadline
+const getZrxNativeCheckDeadline = (data) => {
+    try {
+        const { functionName, args } = (0, viem_1.decodeFunctionData)({ abi: settlerAbi, data: data });
+        if (functionName !== 'execute')
+            return undefined;
+        const deadlines = args[1]
+            .filter(action => action.startsWith(NATIVE_CHECK_SELECTOR))
+            .map(action => (0, viem_1.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;
+    }
+};
+exports.getZrxNativeCheckDeadline = getZrxNativeCheckDeadline;

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

@@ -22,6 +22,9 @@ var SwapperName;
     SwapperName["Across"] = "Across";
     SwapperName["Debridge"] = "deBridge";
     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;