@shapeshiftoss/swapper 20.4.0 → 20.5.0

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

@@ -0,0 +1,158 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { BigNumber, bn, bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import axios from 'axios';
+import { getAddress, isAddress, isAddressEqual } from 'viem';
+import { TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../../utils/helpers.js';
+import { KYBER_CHAINS, KYBER_NATIVE_TOKEN, KYBER_ROUTER_ADDRESS } from './constants.js';
+const isKyberSupportedChainId = (chainId) => chainId in KYBER_CHAINS;
+const invalidResponse = (message, details) => makeSwapErrorRight({ message, details, code: TradeQuoteError.InvalidResponse });
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (sellAsset.chainId !== buyAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: 'KyberSwap does not support cross-chain trades',
+            code: TradeQuoteError.CrossChainNotSupported,
+        }));
+    }
+    if (!isKyberSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: 'KyberSwap only supports configured EVM chains',
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return Ok(sellAsset.chainId);
+};
+export const assetIdToKyberToken = (assetId) => isNativeEvmAsset(assetId) ? KYBER_NATIVE_TOKEN : getAddress(fromAssetId(assetId).assetReference);
+export const getKyberFeeParams = ({ chainId, affiliateBps, }) => {
+    if (bnOrZero(affiliateBps).lte(0))
+        return undefined;
+    return {
+        feeAmount: affiliateBps,
+        chargeFeeBy: 'currency_out',
+        isInBps: true,
+        feeReceiver: getAddress(getTreasuryAddressFromChainId(chainId)),
+    };
+};
+// Kyber only returns the post-fee amountOut; the inverse is at most one base unit off
+export const getKyberBuyAmountBeforeFees = ({ buyAmountAfterFeesCryptoBaseUnit, affiliateBps, }) => {
+    if (bnOrZero(affiliateBps).lte(0))
+        return buyAmountAfterFeesCryptoBaseUnit;
+    return bn(buyAmountAfterFeesCryptoBaseUnit)
+        .times(10_000)
+        .div(bn(10_000).minus(affiliateBps))
+        .integerValue(BigNumber.ROUND_DOWN)
+        .toFixed();
+};
+export const getKyberTradeAmounts = ({ input, amountOut, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const buyAmountAfterFeesCryptoBaseUnit = amountOut;
+    const buyAmountBeforeFeesCryptoBaseUnit = getKyberBuyAmountBeforeFees({
+        buyAmountAfterFeesCryptoBaseUnit,
+        affiliateBps,
+    });
+    return {
+        rate: getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        }),
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        affiliateFee: buildAffiliateFee({
+            strategy: 'buy_asset',
+            affiliateBps,
+            sellAsset,
+            buyAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountBeforeFeesCryptoBaseUnit,
+        }),
+    };
+};
+const getKyberCodeError = ({ code, message, requestId }) => {
+    const tradeQuoteError = (() => {
+        switch (code) {
+            case 4008:
+            case 4009:
+            case 4010:
+                return TradeQuoteError.NoRouteFound;
+            case 4011:
+            case 4221:
+                return TradeQuoteError.UnsupportedTradePair;
+            case 4005:
+            case 4007:
+                return TradeQuoteError.SellAmountBelowTradeFee;
+            default:
+                return TradeQuoteError.QueryFailed;
+        }
+    })();
+    return makeSwapErrorRight({
+        message: `KyberSwap request failed: ${message}`,
+        code: tradeQuoteError,
+        details: { code, requestId },
+    });
+};
+const isKyberErrorResponse = (value) => typeof value === 'object' &&
+    value !== null &&
+    'code' in value &&
+    typeof value.code === 'number' &&
+    'message' in value &&
+    typeof value.message === 'string';
+export const getKyberRequestError = (error) => {
+    const { cause } = error;
+    if (!axios.isAxiosError(cause))
+        return error;
+    const status = cause.response?.status;
+    if (status === 429) {
+        return makeSwapErrorRight({
+            message: 'KyberSwap rate limit exceeded',
+            code: TradeQuoteError.RateLimitExceeded,
+        });
+    }
+    if (status === 404) {
+        return makeSwapErrorRight({
+            message: 'KyberSwap does not serve this chain',
+            code: TradeQuoteError.UnsupportedChain,
+        });
+    }
+    const body = cause.response?.data;
+    if (isKyberErrorResponse(body))
+        return getKyberCodeError(body);
+    return makeSwapErrorRight({
+        message: `KyberSwap request failed with status ${status}`,
+        code: TradeQuoteError.QueryFailed,
+        cause,
+    });
+};
+const isPinnedRouter = (routerAddress) => isAddress(routerAddress) && isAddressEqual(routerAddress, KYBER_ROUTER_ADDRESS);
+const unpinnedRouterError = (routerAddress) => invalidResponse(`KyberSwap router ${routerAddress} is not the pinned router`);
+export const validateKyberRoute = (response, feeParams) => {
+    if (response.code !== 0)
+        return Err(getKyberCodeError(response));
+    if (!response.data)
+        return Err(invalidResponse('KyberSwap returned no route'));
+    const { routeSummary, routerAddress } = response.data;
+    if (!isPinnedRouter(routerAddress))
+        return Err(unpinnedRouterError(routerAddress));
+    // Kyber skips the integrator fee on wrap and unwrap routes, so reject them rather than swap fee-free
+    if (feeParams && routeSummary.extraFee.feeAmount === '') {
+        return Err(makeSwapErrorRight({
+            message: 'Wrapping or unwrapping the native asset is not supported through KyberSwap',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return Ok(routeSummary);
+};
+export const validateKyberBuild = (response) => {
+    if (response.code !== 0)
+        return Err(getKyberCodeError(response));
+    if (!response.data)
+        return Err(invalidResponse('KyberSwap returned no transaction'));
+    const { routerAddress } = response.data;
+    if (!isPinnedRouter(routerAddress))
+        return Err(unpinnedRouterError(routerAddress));
+    return Ok(response.data);
+};

package/dist/esm/swappers/KyberSwapper/utils/helpers.test.d.ts

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

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

@@ -0,0 +1,108 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { describe, expect, it } from 'vitest';
+import { TradeQuoteError } from '../../../types.js';
+import { KYBER_ROUTER_ADDRESS } from './constants.js';
+import { getKyberBuyAmountBeforeFees, getKyberFeeParams, validateKyberBuild, validateKyberRoute, } from './helpers.js';
+const TREASURY = '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC';
+const UNPINNED_ROUTER = '0x1111111111111111111111111111111111111111';
+const EMPTY_EXTRA_FEE = {
+    feeAmount: '',
+    chargeFeeBy: '',
+    isInBps: false,
+    feeReceiver: '',
+};
+const hyperEvmFeeParams = getKyberFeeParams({
+    chainId: KnownChainIds.HyperEvmMainnet,
+    affiliateBps: '60',
+});
+const ROUTE = {
+    amountOut: '255332541',
+    gas: '679101',
+    gasPrice: '100000000',
+    extraFee: {
+        feeAmount: '60',
+        chargeFeeBy: 'currency_out',
+        isInBps: true,
+        feeReceiver: TREASURY.toLowerCase(),
+    },
+};
+const ROUTES_RESPONSE = {
+    code: 0,
+    message: 'successfully',
+    data: { routeSummary: ROUTE, routerAddress: KYBER_ROUTER_ADDRESS },
+    requestId: 'route-request',
+};
+const BUILD_RESPONSE = {
+    code: 0,
+    message: 'successfully',
+    data: {
+        amountOut: '255332539',
+        gas: '679101',
+        data: '0xe21fd0e9',
+        routerAddress: KYBER_ROUTER_ADDRESS,
+        transactionValue: '3000000000000000000',
+    },
+    requestId: 'build-request',
+};
+describe('getKyberFeeParams', () => {
+    it('sends no fee for a fee-free swap', () => {
+        expect(getKyberFeeParams({ chainId: KnownChainIds.HyperEvmMainnet, affiliateBps: '0' })).toBeUndefined();
+    });
+    it('charges the output in bps to the chain treasury', () => {
+        expect(hyperEvmFeeParams).toEqual({
+            feeAmount: '60',
+            chargeFeeBy: 'currency_out',
+            isInBps: true,
+            feeReceiver: TREASURY,
+        });
+    });
+});
+describe('getKyberBuyAmountBeforeFees', () => {
+    it.each([
+        ['255332541', '60', '256873783'],
+        ['54334339666759063267443', '60', '54662313548047347351552'],
+        ['123', '0', '123'],
+    ])('grosses up %s at %s bps to %s', (buyAmountAfterFeesCryptoBaseUnit, affiliateBps, gross) => {
+        expect(getKyberBuyAmountBeforeFees({ buyAmountAfterFeesCryptoBaseUnit, affiliateBps })).toBe(gross);
+    });
+});
+describe('validateKyberRoute', () => {
+    const validate = (summaryOverrides, dataOverrides = {}, feeParams = hyperEvmFeeParams) => validateKyberRoute({
+        ...ROUTES_RESPONSE,
+        data: {
+            ...ROUTES_RESPONSE.data,
+            routeSummary: { ...ROUTE, ...summaryOverrides },
+            ...dataOverrides,
+        },
+    }, feeParams);
+    it('returns the route summary', () => {
+        expect(validateKyberRoute(ROUTES_RESPONSE, hyperEvmFeeParams).unwrap()).toBe(ROUTE);
+    });
+    it('rejects an unpinned router', () => {
+        expect(validate({}, { routerAddress: UNPINNED_ROUTER }).unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+    });
+    it('rejects a route that dropped the requested fee', () => {
+        expect(validate({ extraFee: EMPTY_EXTRA_FEE }).unwrapErr().code).toBe(TradeQuoteError.UnsupportedTradePair);
+    });
+    it('accepts a fee-free route when no fee was requested', () => {
+        expect(validateKyberRoute({
+            ...ROUTES_RESPONSE,
+            data: {
+                ...ROUTES_RESPONSE.data,
+                routeSummary: { ...ROUTE, extraFee: EMPTY_EXTRA_FEE },
+            },
+        }, undefined).isOk()).toBe(true);
+    });
+});
+describe('validateKyberBuild', () => {
+    it('returns the build data', () => {
+        expect(validateKyberBuild(BUILD_RESPONSE).unwrap()).toBe(BUILD_RESPONSE.data);
+    });
+    it('rejects an unpinned router', () => {
+        const result = validateKyberBuild({
+            ...BUILD_RESPONSE,
+            data: { ...BUILD_RESPONSE.data, routerAddress: UNPINNED_ROUTER },
+        });
+        expect(result.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+    });
+});

package/dist/esm/swappers/KyberSwapper/utils/kyberService.d.ts

@@ -0,0 +1,5 @@
+export declare const kyberService: {
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
+};

package/dist/esm/swappers/KyberSwapper/utils/kyberService.js

@@ -0,0 +1,3 @@
+import axios from 'axios';
+import { makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
+export const kyberService = makeSwapperAxiosServiceMonadic(axios.create({ timeout: 10_000 }));

package/dist/esm/swappers/NearIntentsSwapper/NearIntentsSwapper.js

@@ -1,4 +1,4 @@
-import { executeEvmTransaction, executeNearTransaction, executeSolanaTransaction, executeStarknetTransaction, executeSuiTransaction, executeTonTransaction, executeTronTransaction, } from '../../utils/index.js';
+import { executeAptosTransaction, executeEvmTransaction, executeNearTransaction, executeSolanaTransaction, executeStarknetTransaction, executeSuiTransaction, executeTonTransaction, executeTronTransaction, } from '../../utils/index.js';
 export const nearIntentsSwapper = {
     supportsExternalPayment: true,
     executeEvmTransaction,
@@ -8,6 +8,7 @@ export const nearIntentsSwapper = {
     executeSuiTransaction,
     executeNearTransaction,
     executeTonTransaction,
+    executeAptosTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

package/dist/esm/swappers/NearIntentsSwapper/endpoints.js

@@ -1,5 +1,6 @@
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { createDefaultStatusResponse, getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote, } from '../../utils/index.js';
+import { getAptosTransactionFees, getUnsignedAptosTransaction } from '../../utils/aptos/index.js';
 import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
 import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
@@ -84,7 +85,7 @@ export const nearIntentsApi = {
         }
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
-    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, assertGetStarknetChainAdapter, }) => {
+    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, callsOnly, assertGetStarknetChainAdapter, }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
@@ -94,24 +95,20 @@ export const nearIntentsApi = {
         const to = depositAddress;
         const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
         const tokenContractAddress = contractAddressOrUndefined(sellAsset.assetId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value,
-            chainSpecific: {
-                from,
-                tokenContractAddress,
-            },
-            sendMax: false,
-        });
+        const maxFee = callsOnly
+            ? undefined
+            : (await adapter.getFeeData({
+                to,
+                value,
+                chainSpecific: { from, tokenContractAddress },
+                sendMax: false,
+            })).fast.chainSpecific.maxFee;
         return adapter.buildSendApiTransaction({
             from,
             to,
             value,
             accountNumber,
-            chainSpecific: {
-                tokenContractAddress,
-                maxFee: fast.chainSpecific.maxFee,
-            },
+            chainSpecific: { tokenContractAddress, maxFee, callsOnly },
         });
     },
     getStarknetTransactionFees: ({ tradeQuote, stepIndex }) => {
@@ -153,6 +150,8 @@ export const nearIntentsApi = {
         }
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
+    getUnsignedAptosTransaction,
+    getAptosTransactionFees,
     checkTradeStatus: async ({ config, swap }) => {
         if (!swap)
             throw new Error('Missing swap');

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeRate.js

@@ -54,7 +54,7 @@ const getRate = async (input, deps) => {
             {
                 ...stepCommon,
                 accountNumber,
-                feeData: { protocolFees, networkFeeCryptoBaseUnit: networkFeeCryptoBaseUnit ?? '0' },
+                feeData: { protocolFees, networkFeeCryptoBaseUnit },
             },
         ],
     };

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

@@ -1,7 +1,7 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
-import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetNearTradeQuoteInput, GetNearTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetStarknetTradeQuoteInput, GetStarknetTradeRateInput, GetSuiTradeQuoteInput, GetSuiTradeRateInput, GetTonTradeQuoteInput, GetTonTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput, WithExactBuyAmount } from '../../types.js';
-export type NearIntentsTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput | GetSuiTradeQuoteInput | GetStarknetTradeQuoteInput | GetNearTradeQuoteInput | GetTonTradeQuoteInput;
-export type NearIntentsTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput | GetSuiTradeRateInput | GetStarknetTradeRateInput | GetNearTradeRateInput | GetTonTradeRateInput;
+import type { GetAptosTradeQuoteInput, GetAptosTradeRateInput, GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetNearTradeQuoteInput, GetNearTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetStarknetTradeQuoteInput, GetStarknetTradeRateInput, GetSuiTradeQuoteInput, GetSuiTradeRateInput, GetTonTradeQuoteInput, GetTonTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput, WithExactBuyAmount } from '../../types.js';
+export type NearIntentsTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput | GetSuiTradeQuoteInput | GetStarknetTradeQuoteInput | GetNearTradeQuoteInput | GetTonTradeQuoteInput | GetAptosTradeQuoteInput;
+export type NearIntentsTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput | GetSuiTradeRateInput | GetStarknetTradeRateInput | GetNearTradeRateInput | GetTonTradeRateInput | GetAptosTradeRateInput;
 export type NearIntentsExactOutputTradeQuoteInput = WithExactBuyAmount<NearIntentsTradeQuoteInput>;
 export type NearIntentsExactOutputTradeRateInput = WithExactBuyAmount<NearIntentsTradeRateInput>;
 export type NearIntentsMetadata = {
@@ -11,6 +11,6 @@ export type NearIntentsMetadata = {
 };
 export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
 export type { GetExecutionStatusResponse, QuoteResponse, TokenResponse, } from '@defuse-protocol/one-click-sdk-typescript';
-export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.BitcoinCashMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.ZcashMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet, KnownChainIds.StarknetMainnet, KnownChainIds.MonadMainnet, KnownChainIds.NearMainnet, KnownChainIds.PlasmaMainnet, KnownChainIds.TonMainnet];
+export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.BitcoinCashMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.ZcashMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet, KnownChainIds.StarknetMainnet, KnownChainIds.MonadMainnet, KnownChainIds.NearMainnet, KnownChainIds.PlasmaMainnet, KnownChainIds.TonMainnet, KnownChainIds.AptosMainnet];
 export type NearIntentsSupportedChainId = (typeof nearIntentsSupportedChainIds)[number];
 export declare const chainIdToNearIntentsChain: Record<NearIntentsSupportedChainId, string>;

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

@@ -21,6 +21,7 @@ export const nearIntentsSupportedChainIds = [
     KnownChainIds.NearMainnet,
     KnownChainIds.PlasmaMainnet,
     KnownChainIds.TonMainnet,
+    KnownChainIds.AptosMainnet,
 ];
 export const chainIdToNearIntentsChain = {
     [KnownChainIds.EthereumMainnet]: 'eth',
@@ -43,4 +44,5 @@ export const chainIdToNearIntentsChain = {
     [KnownChainIds.MonadMainnet]: 'monad',
     [KnownChainIds.NearMainnet]: 'near',
     [KnownChainIds.TonMainnet]: 'ton',
+    [KnownChainIds.AptosMainnet]: 'aptos',
 };

package/dist/esm/swappers/NearIntentsSwapper/utils/getNearIntentsStepData.js

@@ -1,9 +1,10 @@
 import { CHAIN_NAMESPACE, fromAssetId, fromChainId } from '@shapeshiftoss/caip';
-import { evm } from '@shapeshiftoss/chain-adapters';
+import { aptos, evm } from '@shapeshiftoss/chain-adapters';
 import { bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../types.js';
 import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight } from '../../../utils/index.js';
+import { APTOS_PLACEHOLDER_ADDRESS, APTOS_RATE_SIMULATION_VALUE } from '../../../utils/aptos/index.js';
 import { EVM_PLACEHOLDER_ADDRESS, getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
 import { isNativeEvmAsset } from '../../../utils/helpers.js';
 import { ATA_RENT_LAMPORTS, getSolanaNetworkFeeCryptoBaseUnit, SOLANA_PLACEHOLDER_ADDRESS, withComputeUnitLimit, } from '../../../utils/solana/index.js';
@@ -218,6 +219,33 @@ export async function getNearIntentsStepData(args) {
                 const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
                 return Ok(stepData);
             }
+            case CHAIN_NAMESPACE.Aptos: {
+                const adapter = deps.assertGetAptosChainAdapter(sellAsset.chainId);
+                if (type === 'rate') {
+                    const { fast } = await adapter.getFeeData({
+                        to: depositAddress,
+                        value: APTOS_RATE_SIMULATION_VALUE,
+                        chainSpecific: { from: from ?? APTOS_PLACEHOLDER_ADDRESS, contractAddress },
+                    });
+                    const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                    return Ok(stepData);
+                }
+                const { fast } = await adapter.getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: { from, contractAddress },
+                });
+                const stepData = {
+                    transactionData: {
+                        type: 'aptos',
+                        payload: aptos.getSerializedTransferPayload(depositAddress, sellAmountCryptoBaseUnit, contractAddress),
+                        gasUnitPrice: fast.chainSpecific.gasUnitPrice,
+                        maxGasAmount: fast.chainSpecific.maxGasAmount,
+                    },
+                    networkFeeCryptoBaseUnit: fast.txFee,
+                };
+                return Ok(stepData);
+            }
             default:
                 return Err(makeSwapErrorRight({
                     message: `[getNearIntentsStepData] unsupported chain namespace: ${chainNamespace}`,

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

@@ -36,7 +36,7 @@ export const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
     return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
 };
 const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron', 'monad', 'plasma'];
-const TOKEN_LOOKUP_CHAINS = ['sui', 'starknet', 'ton'];
+const TOKEN_LOOKUP_CHAINS = ['sui', 'starknet', 'ton', 'aptos'];
 const NEAR_CHAIN = 'near';
 const BTC_CHAIN = 'btc';
 const WNEAR_CONTRACT_ADDRESS = 'wrap.near';
@@ -68,7 +68,7 @@ export const assetToNearIntentsAsset = async (asset) => {
         });
         return match?.assetId ?? null;
     }
-    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism, TRON, Monad), Token lookup chains (Sui, Starknet), and Solana require token lookup
+    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism, TRON, Monad), Token lookup chains (Sui, Starknet, TON, Aptos), and Solana require token lookup
     // Asset IDs use hashed format that can't be generated from contract addresses
     const requiresLookup = isNep245Chain(nearNetwork) || isTokenLookupChain(nearNetwork) || asset.chainId === solanaChainId;
     if (requiresLookup) {

package/dist/esm/swappers/PortalsSwapper/utils/getPortalsStepData.js

@@ -1,53 +1,47 @@
 import { fromChainId } from '@shapeshiftoss/caip';
-import { bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
-import { estimateGasWithStateOverride, getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
 import { fetchPortalsTradeEstimate } from './fetchPortalsTradeOrder.js';
 export async function getPortalsStepData(args) {
     const { tx, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, 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: tx.to,
+        data: tx.data,
+        value: tx.value,
+    };
+    const stateOverride = {
+        sellAsset,
+        sellAmountCryptoBaseUnit,
+        spenderAddress,
+    };
     if (args.type === 'rate') {
+        const getEstimateEndpointGasLimit = async () => {
+            const quoteEstimateResponse = await fetchPortalsTradeEstimate({
+                inputToken: args.inputToken,
+                outputToken: args.outputToken,
+                inputAmount: args.inputAmount,
+                slippageTolerancePercentage: args.slippageTolerancePercentage,
+                swapperConfig: deps.config,
+            });
+            return quoteEstimateResponse.context.gasLimit.toString();
+        };
         try {
-            // No placeholder estimation for provider built routes - overridden estimation (approval
-            // state need not exist yet) with the Portals order and estimate endpoint as fallbacks
-            const gasLimit = await (async () => {
-                try {
-                    const gasLimit = await estimateGasWithStateOverride({
-                        sellAsset,
-                        sellAmountCryptoBaseUnit,
-                        from: tx.from,
-                        spenderAddress,
-                        to: tx.to,
-                        data: tx.data,
-                        value: tx.value,
-                    });
-                    return gasLimit;
-                }
-                catch {
-                    // Portals only carry a tx gas limit on the bridge routes their estimate endpoint zeroes
-                    const { gasLimit: txGasLimit } = tx;
-                    if (txGasLimit && bnOrZero(txGasLimit).gt(0))
-                        return txGasLimit;
-                    const quoteEstimateResponse = await fetchPortalsTradeEstimate({
-                        inputToken: args.inputToken,
-                        outputToken: args.outputToken,
-                        inputAmount: args.inputAmount,
-                        slippageTolerancePercentage: args.slippageTolerancePercentage,
-                        swapperConfig: deps.config,
-                    });
-                    const estimatedGasLimit = quoteEstimateResponse.context.gasLimit.toString();
-                    if (bnOrZero(estimatedGasLimit).lte(0))
-                        throw new Error('no Portals gas limit');
-                    return estimatedGasLimit;
-                }
-            })();
-            const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            // Portals only set a tx gas limit on bridge routes, where their estimate endpoint is zero
+            const networkFeeCryptoBaseUnit = await getEvmRateNetworkFeeCryptoBaseUnit({
                 adapter,
                 supportsEIP1559,
-                gasLimit,
-            });
+                providerGasLimit: tx.gasLimit,
+                simulation: { transactionData, from: tx.from, stateOverride },
+            }).catch(async () => getEvmRateNetworkFeeCryptoBaseUnit({
+                adapter,
+                supportsEIP1559,
+                providerGasLimit: await getEstimateEndpointGasLimit(),
+            }));
             const stepData = { networkFeeCryptoBaseUnit };
             return Ok(stepData);
         }
@@ -55,27 +49,14 @@ export async function getPortalsStepData(args) {
             return Err(makeNetworkFeeEstimationFailedErr('getPortalsStepData', error));
         }
     }
-    const transactionData = {
-        type: 'evm',
-        chainId: Number(fromChainId(sellAsset.chainId).chainReference),
-        to: tx.to,
-        data: tx.data,
-        value: tx.value,
-        // Portals simulate and pad their gas limit when the order was validated, so no additional
-        // buffer - an unvalidated order carries no gas limit and estimates below instead
-        gasLimit: tx.gasLimit,
-    };
     try {
         const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
             adapter,
             transactionData,
             from: args.from,
             supportsEIP1559,
-            stateOverride: {
-                sellAsset,
-                sellAmountCryptoBaseUnit,
-                spenderAddress,
-            },
+            stateOverride,
+            providerGasLimit: tx.gasLimit,
         });
         const stepData = { transactionData, networkFeeCryptoBaseUnit };
         return Ok(stepData);

package/dist/esm/swappers/PortalsSwapper/utils/getPortalsStepData.test.js

@@ -45,11 +45,11 @@ const estimateEndpointGasLimit = (gasLimit) => vi.mocked(fetchPortalsTradeEstima
 });
 describe('getPortalsStepData rate gas limit', () => {
     beforeEach(() => vi.clearAllMocks());
-    it('falls back to the order gas limit on bridge routes the estimate endpoint zeroes', async () => {
-        vi.mocked(estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+    it('prices the order gas limit on bridge routes without simulating', async () => {
         estimateEndpointGasLimit(0);
         const actual = await rate(tx('76384'));
         expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '76384000000000' });
+        expect(estimateGasWithStateOverride).not.toHaveBeenCalled();
         expect(fetchPortalsTradeEstimate).not.toHaveBeenCalled();
     });
     it('falls back to the estimate endpoint when the order carries no gas limit', async () => {

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);