@shapeshiftoss/swapper 20.4.0 → 20.6.0

package/dist/esm/constants.js

@@ -10,6 +10,7 @@ import { chainflipApi, chainflipSwapper } from './swappers/ChainflipSwapper/inde
 import { cowApi, cowSwapper } from './swappers/CowSwapper/index.js';
 import { debridgeApi, debridgeSwapper } from './swappers/DebridgeSwapper/index.js';
 import { fyndApi, fyndSwapper } from './swappers/FyndSwapper/index.js';
+import { kyberApi, kyberSwapper } from './swappers/KyberSwapper/index.js';
 import { mayachainApi, mayachainSwapper } from './swappers/MayachainSwapper/index.js';
 import { nearIntentsApi, nearIntentsSwapper } from './swappers/NearIntentsSwapper/index.js';
 import { portalsApi, portalsSwapper } from './swappers/PortalsSwapper/index.js';
@@ -109,6 +110,10 @@ export const swappers = {
         ...fyndSwapper,
         ...fyndApi,
     },
+    [SwapperName.KyberSwap]: {
+        ...kyberSwapper,
+        ...kyberApi,
+    },
     [SwapperName.Test]: undefined,
 };
 const DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE = '0.002';
@@ -137,6 +142,7 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
         case SwapperName.Zrx:
         case SwapperName.Bebop:
         case SwapperName.Fynd:
+        case SwapperName.KyberSwap:
         case SwapperName.Test:
             return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.CowSwap:

package/dist/esm/index.d.ts

@@ -16,6 +16,7 @@ export * from './swappers/SunioSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
 export * from './swappers/DebridgeSwapper/index.js';
 export * from './swappers/FyndSwapper/index.js';
+export * from './swappers/KyberSwapper/index.js';
 export * from './swappers/PortalsSwapper/index.js';
 export * from './swappers/ThorchainSwapper/index.js';
 export * from './swappers/MayachainSwapper/index.js';

package/dist/esm/index.js

@@ -16,6 +16,7 @@ export * from './swappers/SunioSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
 export * from './swappers/DebridgeSwapper/index.js';
 export * from './swappers/FyndSwapper/index.js';
+export * from './swappers/KyberSwapper/index.js';
 export * from './swappers/PortalsSwapper/index.js';
 export * from './swappers/ThorchainSwapper/index.js';
 export * from './swappers/MayachainSwapper/index.js';

package/dist/esm/swappers/AcrossSwapper/utils/getAcrossStepData.js

@@ -4,7 +4,7 @@ import { Err, Ok } from '@sniptt/monads';
 import { AddressLookupTableAccount, PublicKey, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
 import { TradeQuoteError } from '../../../types.js';
 import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight, makeTradeStepBuildFailedErr, } from '../../../utils/index.js';
-import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
 import { getSolanaNetworkFeeCryptoBaseUnit } from '../../../utils/solana/index.js';
 export async function getAcrossStepData(args) {
     const { swapTx, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, from, type, input, fallbackNetworkFeeCryptoBaseUnit, deps, } = args;
@@ -18,7 +18,6 @@ export async function getAcrossStepData(args) {
                 to: swapTx.to,
                 data: swapTx.data,
                 value: swapTx.value ?? '0',
-                gasLimit: swapTx.gas,
             };
             const stateOverride = {
                 sellAsset,
@@ -26,20 +25,12 @@ export async function getAcrossStepData(args) {
                 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: swapTx.gas,
+                    simulation: { transactionData, from, stateOverride },
+                }).catch(() => fallbackNetworkFeeCryptoBaseUnit);
                 const stepData = { networkFeeCryptoBaseUnit };
                 return Ok(stepData);
             }
@@ -50,6 +41,7 @@ export async function getAcrossStepData(args) {
                     from,
                     supportsEIP1559,
                     stateOverride,
+                    providerGasLimit: swapTx.gas,
                 });
                 const stepData = { transactionData, networkFeeCryptoBaseUnit };
                 return Ok(stepData);

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

@@ -1,6 +1,6 @@
 import { quoteToCalls } from '@avnu/avnu-sdk';
 import { toAddressNList } from '@shapeshiftoss/chain-adapters';
-import { CallData, hash, validateAndParseAddress } from 'starknet';
+import { CallData, hash, transaction, validateAndParseAddress } from 'starknet';
 import { checkStarknetSwapStatus, createDefaultStatusResponse, getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote, } from '../../utils/index.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.js';
@@ -8,7 +8,7 @@ import { toHexString } from './utils/helpers.js';
 export const avnuApi = {
     getTradeQuote: (input, deps) => getTradeQuote(input, deps),
     getTradeRate: (input, deps) => getTradeRate(input, deps),
-    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, slippageTolerancePercentageDecimal, assertGetStarknetChainAdapter, }) => {
+    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, callsOnly, slippageTolerancePercentageDecimal, assertGetStarknetChainAdapter, }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
@@ -34,19 +34,23 @@ export const avnuApi = {
         if (!avnuCalls || avnuCalls.length === 0) {
             throw new Error('No swap calls returned from AVNU - quote may have expired');
         }
-        // Build the full invoke transaction calldata from AVNU calls
-        // Format: [call_array_length, contract1, selector1, calldata_len1, ...calldata1, ...]
-        const fullCalldata = [avnuCalls.length.toString()];
-        for (const call of avnuCalls) {
+        const calls = avnuCalls.map(call => {
             const rawCalldata = call.calldata ?? [];
-            const calldataArray = Array.isArray(rawCalldata) ? rawCalldata : CallData.compile(rawCalldata);
-            const selector = hash.getSelectorFromName(call.entrypoint);
-            // Normalize contract address from AVNU to ensure consistent format
-            const normalizedContractAddress = validateAndParseAddress(call.contractAddress);
-            fullCalldata.push(normalizedContractAddress, selector, calldataArray.length.toString(), ...calldataArray.map(cd => String(cd)));
+            const calldata = Array.isArray(rawCalldata) ? rawCalldata : CallData.compile(rawCalldata);
+            return {
+                contractAddress: validateAndParseAddress(call.contractAddress),
+                entrypoint: call.entrypoint,
+                calldata: calldata.map(String),
+            };
+        });
+        if (callsOnly) {
+            return {
+                addressNList: toAddressNList(adapter.getBip44Params({ accountNumber })),
+                txHash: '',
+                calls,
+            };
         }
-        // Format calldata for RPC (convert all values to proper hex format)
-        const formattedCalldata = fullCalldata.map(toHexString);
+        const formattedCalldata = transaction.getExecuteCalldata(calls, '1').map(toHexString);
         // Get nonce using adapter method (checks deployment status and returns appropriate nonce)
         const chainIdHex = await adapter.getStarknetProvider().getChainId();
         const nonce = await adapter.getNonce(normalizedFrom);
@@ -144,6 +148,7 @@ export const avnuApi = {
         return {
             addressNList: toAddressNList(adapter.getBip44Params({ accountNumber })),
             txHash,
+            calls,
             _txDetails: {
                 fromAddress: normalizedFrom,
                 calldata: formattedCalldata,

package/dist/esm/swappers/BebopSwapper/utils/getBebopStepData.js

@@ -3,46 +3,41 @@ import { bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { fromHex } from 'viem';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
-import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
 export async function getBebopStepData(args) {
     const { tx, spenderAddress, sellAsset, sellAmountCryptoBaseUnit, type, input, from, deps } = args;
     const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
     const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
-    if (type === 'rate') {
-        const networkFeeCryptoBaseUnit = await (async () => {
-            try {
-                return await getEvmNetworkFeeCryptoBaseUnit({
-                    adapter,
-                    supportsEIP1559,
-                    gasLimit: bnOrZero(tx.gas).toString(),
-                });
-            }
-            catch {
-                return bnOrZero(tx.gas).times(bnOrZero(tx.gasPrice)).toFixed(0);
-            }
-        })();
-        const stepData = { networkFeeCryptoBaseUnit };
-        return Ok(stepData);
-    }
     const transactionData = {
         type: 'evm',
         chainId: Number(fromChainId(sellAsset.chainId).chainReference),
         to: tx.to,
         data: tx.data,
         value: fromHex(tx.value, 'bigint').toString(),
-        gasLimit: tx.gas?.toString(),
     };
+    const stateOverride = {
+        sellAsset,
+        sellAmountCryptoBaseUnit,
+        spenderAddress,
+    };
+    if (type === 'rate') {
+        const networkFeeCryptoBaseUnit = await getEvmRateNetworkFeeCryptoBaseUnit({
+            adapter,
+            supportsEIP1559,
+            providerGasLimit: tx.gas?.toString(),
+            simulation: { transactionData, from, stateOverride },
+        }).catch(() => bnOrZero(tx.gas).times(bnOrZero(tx.gasPrice)).toFixed(0));
+        const stepData = { networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
     try {
         const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
             adapter,
             transactionData,
             from,
             supportsEIP1559,
-            stateOverride: {
-                sellAsset,
-                sellAmountCryptoBaseUnit,
-                spenderAddress,
-            },
+            stateOverride,
+            providerGasLimit: tx.gas?.toString(),
         });
         const stepData = { transactionData, networkFeeCryptoBaseUnit };
         return Ok(stepData);

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeQuote.test.js

@@ -54,6 +54,7 @@ describe('getTradeQuote', () => {
             assertGetNearChainAdapter: () => vi.fn(),
             assertGetStarknetChainAdapter: () => vi.fn(),
             assertGetTonChainAdapter: () => vi.fn(),
+            assertGetAptosChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeRate.test.js

@@ -34,6 +34,7 @@ describe('getTradeRate', () => {
             assertGetNearChainAdapter: () => vi.fn(),
             assertGetStarknetChainAdapter: () => vi.fn(),
             assertGetTonChainAdapter: () => vi.fn(),
+            assertGetAptosChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },

package/dist/esm/swappers/ButterSwap/utils/getButterSwapStepData.js

@@ -5,7 +5,7 @@ import { AddressLookupTableAccount, PublicKey, TransactionMessage, VersionedTran
 import { fromHex } from 'viem';
 import { TradeQuoteError } from '../../../types.js';
 import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight, 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 { BUTTERSWAP_TRON_DEFAULT_BANDWIDTH_BYTES, BUTTERSWAP_TRON_FALLBACK_SWAP_ENERGY, } from './constants.js';
@@ -25,10 +25,10 @@ export async function getButterSwapStepData(args) {
             if (args.type === 'rate') {
                 const networkFeeCryptoBaseUnit = await (async () => {
                     try {
-                        return await getEvmNetworkFeeCryptoBaseUnit({
+                        return await getEvmRateNetworkFeeCryptoBaseUnit({
                             adapter,
                             supportsEIP1559,
-                            gasLimit: bnOrZero(route.gasEstimatedTarget).toFixed(),
+                            providerGasLimit: bnOrZero(route.gasEstimatedTarget).toFixed(),
                         });
                     }
                     catch {
@@ -52,13 +52,12 @@ export async function getButterSwapStepData(args) {
                     supportsEIP1559,
                     transactionData,
                     from,
-                    // Butter's gasEstimatedTarget lands short on chain (observed 24% under actual, causing
-                    // in-flight OOG/SWAP_FAIL reverts) - estimate ourselves instead
                     stateOverride: {
                         sellAsset,
                         sellAmountCryptoBaseUnit,
                         spenderAddress,
                     },
+                    providerGasLimit: bnOrZero(route.gasEstimatedTarget).toFixed(),
                 });
                 const stepData = { transactionData, networkFeeCryptoBaseUnit };
                 return Ok(stepData);

package/dist/esm/swappers/ButterSwap/utils/getButterSwapStepData.test.js

@@ -94,7 +94,7 @@ describe('getButterSwapStepData', () => {
             });
             // gasEstimatedTarget 1159118 is ignored - the tx carries the buffered on chain estimate
             expect(actual.unwrap()).toEqual({
-                networkFeeCryptoBaseUnit: '500000000000000',
+                networkFeeCryptoBaseUnit: '600000000000000',
                 transactionData: {
                     type: 'evm',
                     chainId: 1,
@@ -121,7 +121,7 @@ describe('getButterSwapStepData', () => {
             const { transactionData, networkFeeCryptoBaseUnit } = actual.unwrap();
             // The buffered limit is set on the tx data in place, so the executable tx always carries one
             expect(transactionData).toMatchObject({ gasLimit: '600000' });
-            expect(networkFeeCryptoBaseUnit).toBe('500000000000000');
+            expect(networkFeeCryptoBaseUnit).toBe('600000000000000');
         });
         it('errors rather than falling back to the provider fee when quote estimation fails', async () => {
             const actual = await getButterSwapStepData({

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

@@ -1,4 +1,4 @@
-import { getProvidersExcluding } from '@cetusprotocol/aggregator-sdk';
+import { getProvidersExcluding, PYTH_ORACLE_BASED_DEXES } from '@cetusprotocol/aggregator-sdk';
 import { Transaction } from '@mysten/sui/transactions';
 import { toAddressNList } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
@@ -8,7 +8,6 @@ import { SwapperName } from '../../types.js';
 import { checkSuiSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils/index.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.js';
-import { PYTH_DEPENDENT_PROVIDERS } from './utils/constants.js';
 import { findBestRoute, getAggregatorClient, getCoinType, getSuiClient } from './utils/helpers.js';
 export const cetusApi = {
     getTradeQuote: (input, deps) => getTradeQuote(input, deps),
@@ -20,12 +19,12 @@ export const cetusApi = {
         const { accountNumber, sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = step;
         const adapter = assertGetSuiChainAdapter(sellAsset.chainId);
         const rpcUrl = config.VITE_SUI_NODE_URL;
-        const client = getAggregatorClient(rpcUrl);
+        const client = getAggregatorClient(rpcUrl, from);
         const suiClient = getSuiClient(rpcUrl);
         const sellCoinType = getCoinType(sellAsset);
         const buyCoinType = getCoinType(buyAsset);
         // Exclude Pyth-dependent providers to avoid oracle failures
-        const providersWithoutPyth = getProvidersExcluding(PYTH_DEPENDENT_PROVIDERS);
+        const providersWithoutPyth = getProvidersExcluding(PYTH_ORACLE_BASED_DEXES);
         const routerData = await findBestRoute(client, sellCoinType, buyCoinType, sellAmountIncludingProtocolFeesCryptoBaseUnit, providersWithoutPyth);
         if (!routerData) {
             throw new Error(`No route found for ${sellAsset.symbol}/${buyAsset.symbol}`);

package/dist/esm/swappers/CetusSwapper/swapperApi/getCetusStepData.js

@@ -5,9 +5,11 @@ import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constant
 import { SwapperName } from '../../../types.js';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
 import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
+// The 0x0 dummy sender only holds dust SUI, so server-side gas selection exceeds the payment object limit
+const UNFUNDED_SENDER_ERRORS = ['Insufficient balance of', 'maximum number of gas payment objects'];
 export async function getCetusStepData(args) {
     const { routerData, rpcUrl, slippageTolerancePercentageDecimal, from } = args;
-    const client = getAggregatorClient(rpcUrl);
+    const client = getAggregatorClient(rpcUrl, from);
     const suiClient = getSuiClient(rpcUrl);
     const slippage = bnOrZero(slippageTolerancePercentageDecimal ??
         getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Cetus)).toNumber();
@@ -17,12 +19,14 @@ export async function getCetusStepData(args) {
         txb.setSender(from);
         await client.fastRouterSwap({ router: routerData, slippage, txb, refreshAllCoins: true });
         const transactionBytes = await txb.build({ client: suiClient });
-        const dryRunResult = await suiClient.dryRunTransactionBlock({
-            transactionBlock: transactionBytes,
+        const dryRunResult = await suiClient.simulateTransaction({
+            transaction: transactionBytes,
+            include: { effects: true },
         });
-        const computationCost = BigInt(dryRunResult.effects.gasUsed.computationCost);
-        const storageCost = BigInt(dryRunResult.effects.gasUsed.storageCost);
-        const storageRebate = BigInt(dryRunResult.effects.gasUsed.storageRebate);
+        const { gasUsed } = (dryRunResult.Transaction ?? dryRunResult.FailedTransaction).effects;
+        const computationCost = BigInt(gasUsed.computationCost);
+        const storageCost = BigInt(gasUsed.storageCost);
+        const storageRebate = BigInt(gasUsed.storageRebate);
         const netStorageCost = storageCost > storageRebate ? storageCost - storageRebate : 0n;
         return (computationCost + netStorageCost).toString();
     };
@@ -33,8 +37,9 @@ export async function getCetusStepData(args) {
             return Ok(stepData);
         }
         catch (error) {
-            // Walletless rates have no coins to dry-run against - degrade to an unknown fee, but a real route/build error still fails
-            if (error instanceof Error && error.message.includes('Not enough coins of type')) {
+            // Walletless rates have no usable coins to dry-run against - degrade to an unknown fee, but a real route/build error still fails
+            const errorMessage = error instanceof Error ? error.message : '';
+            if (UNFUNDED_SENDER_ERRORS.some(message => errorMessage.includes(message))) {
                 const stepData = { networkFeeCryptoBaseUnit: undefined };
                 return Ok(stepData);
             }

package/dist/esm/swappers/CetusSwapper/swapperApi/getCetusTradeContext.js

@@ -1,10 +1,9 @@
-import { getProvidersExcluding } from '@cetusprotocol/aggregator-sdk';
+import { getProvidersExcluding, PYTH_ORACLE_BASED_DEXES } from '@cetusprotocol/aggregator-sdk';
 import { Err, Ok } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
 import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
-import { PYTH_DEPENDENT_PROVIDERS } from '../utils/constants.js';
 import { assertValidTrade, findBestRoute, getAggregatorClient, getCoinType } from '../utils/helpers.js';
 export const getCetusTradeContext = async (input, deps) => {
     const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
@@ -17,7 +16,7 @@ export const getCetusTradeContext = async (input, deps) => {
         const sellCoinType = getCoinType(sellAsset);
         const buyCoinType = getCoinType(buyAsset);
         // Exclude Pyth-dependent providers to avoid oracle failures
-        const providersWithoutPyth = getProvidersExcluding(PYTH_DEPENDENT_PROVIDERS);
+        const providersWithoutPyth = getProvidersExcluding(PYTH_ORACLE_BASED_DEXES);
         const routerData = await findBestRoute(client, sellCoinType, buyCoinType, sellAmountIncludingProtocolFeesCryptoBaseUnit, providersWithoutPyth);
         if (!routerData) {
             return Err(makeSwapErrorRight({

package/dist/esm/swappers/CetusSwapper/utils/constants.d.ts

@@ -1,5 +1,4 @@
 import type { ChainId } from '@shapeshiftoss/caip';
 export declare const SUPPORTED_CETUS_CHAIN_IDS: readonly ChainId[];
 export declare const isSupportedChainId: (chainId: ChainId) => chainId is ChainId;
-export declare const PYTH_DEPENDENT_PROVIDERS: string[];
 export declare const CETUS_FEE_ESTIMATE_DUMMY_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";

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

@@ -3,6 +3,5 @@ export const SUPPORTED_CETUS_CHAIN_IDS = [suiChainId];
 export const isSupportedChainId = (chainId) => {
     return SUPPORTED_CETUS_CHAIN_IDS.includes(chainId);
 };
-export const PYTH_DEPENDENT_PROVIDERS = ['HAEDALPMM', 'HAEDALHMMV2', 'METASTABLE'];
 // Placeholder sender for walletless rate fee estimation - dry-run needs a sender, real coins aren't required
 export const CETUS_FEE_ESTIMATE_DUMMY_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000000';

package/dist/esm/swappers/CetusSwapper/utils/helpers.d.ts

@@ -1,11 +1,11 @@
 import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
 import { AggregatorClient } from '@cetusprotocol/aggregator-sdk';
-import { SuiClient } from '@mysten/sui/client';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
 import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
 import type { SwapErrorRight } from '../../../types.js';
-export declare const getAggregatorClient: (rpcUrl: string) => AggregatorClient;
-export declare const getSuiClient: (rpcUrl: string) => SuiClient;
+export declare const getSuiClient: (rpcUrl: string) => SuiGrpcClient;
+export declare const getAggregatorClient: (rpcUrl: string, signer?: string) => AggregatorClient;
 export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
     sellAsset: Asset;
     buyAsset: Asset;

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

@@ -1,32 +1,21 @@
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
-import { SuiClient } from '@mysten/sui/client';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
 import { fromAssetId } from '@shapeshiftoss/caip';
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils/index.js';
 import { isSupportedChainId } from './constants.js';
 let suiClientInstance;
-let aggregatorClientInstance;
 let currentRpcUrl;
-export const getAggregatorClient = (rpcUrl) => {
-    if (!aggregatorClientInstance || !suiClientInstance || currentRpcUrl !== rpcUrl) {
-        suiClientInstance = new SuiClient({ url: rpcUrl });
-        aggregatorClientInstance = new AggregatorClient({
-            client: suiClientInstance,
-            env: Env.Mainnet,
-            signer: '0x0',
-        });
-        currentRpcUrl = rpcUrl;
-    }
-    return aggregatorClientInstance;
-};
 export const getSuiClient = (rpcUrl) => {
     if (!suiClientInstance || currentRpcUrl !== rpcUrl) {
-        suiClientInstance = new SuiClient({ url: rpcUrl });
+        suiClientInstance = new SuiGrpcClient({ network: 'mainnet', baseUrl: rpcUrl });
         currentRpcUrl = rpcUrl;
     }
     return suiClientInstance;
 };
+// Cetus merges the swap output into an existing coin owned by signer, so it must be the tx sender
+export const getAggregatorClient = (rpcUrl, signer) => new AggregatorClient({ client: getSuiClient(rpcUrl), env: Env.Mainnet, signer });
 export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
     if (!isSupportedChainId(sellAsset.chainId)) {
         return Err(makeSwapErrorRight({

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeStepData.d.ts

@@ -4,7 +4,6 @@ import type { DebridgeTx } from './types.js';
 type BaseArgs = {
     tx: DebridgeTx;
     sellAmountCryptoBaseUnit: string;
-    gasLimit: string | undefined;
     spenderAddress: string;
     fallbackNetworkFeeCryptoBaseUnit: string | undefined;
 };

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeStepData.js

@@ -3,7 +3,7 @@ import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
 import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
 export async function getDebridgeStepData(args) {
-    const { tx, sellAmountCryptoBaseUnit, gasLimit, spenderAddress, fallbackNetworkFeeCryptoBaseUnit, sellAsset, from, type, input, deps, } = args;
+    const { tx, sellAmountCryptoBaseUnit, spenderAddress, fallbackNetworkFeeCryptoBaseUnit, sellAsset, from, type, input, deps, } = args;
     const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
     const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
     const transactionData = {
@@ -12,7 +12,6 @@ export async function getDebridgeStepData(args) {
         to: tx.to,
         data: tx.data,
         value: tx.value,
-        gasLimit,
     };
     const stateOverride = {
         sellAsset,
@@ -20,20 +19,14 @@ export async function getDebridgeStepData(args) {
         spenderAddress,
     };
     if (type === 'rate') {
-        const networkFeeCryptoBaseUnit = await (async () => {
-            try {
-                return await getEvmNetworkFeeCryptoBaseUnit({
-                    adapter,
-                    transactionData,
-                    from,
-                    supportsEIP1559,
-                    stateOverride,
-                });
-            }
-            catch {
-                return fallbackNetworkFeeCryptoBaseUnit;
-            }
-        })();
+        // deBridge returns a flat gas limit far above actual usage, so rates simulate instead
+        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride,
+        }).catch(() => fallbackNetworkFeeCryptoBaseUnit);
         const stepData = { networkFeeCryptoBaseUnit };
         return Ok(stepData);
     }

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeTradeContext.js

@@ -82,7 +82,6 @@ export const getDebridgeTradeContext = async ({ input, deps, senderAddress, reci
         stepDataArgs: {
             tx: quote.tx,
             sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            gasLimit: quote.gasLimit,
             fallbackNetworkFeeCryptoBaseUnit: quote.fallbackNetworkFeeCryptoBaseUnit,
             sellAsset,
             spenderAddress: allowanceContract,
@@ -135,7 +134,6 @@ const fetchCrossChainQuote = async ({ input, deps, sellDebridgeChainId, buyDebri
         isSameChainSwap: false,
         slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
         tx: quote.tx,
-        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
         fallbackNetworkFeeCryptoBaseUnit: quote.estimatedTransactionFee?.total,
     });
 };
@@ -191,7 +189,6 @@ const fetchSameChainQuote = async ({ input, deps, sellDebridgeChainId, senderAdd
         slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
             (quote.slippage ? bnOrZero(quote.slippage).div(100).toString() : undefined),
         tx: quote.tx,
-        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
         fallbackNetworkFeeCryptoBaseUnit: quote.estimatedTransactionFee?.total,
     });
 };

package/dist/esm/swappers/FyndSwapper/utils/getFyndStepData.js

@@ -1,7 +1,7 @@
 import { fromChainId } from '@shapeshiftoss/caip';
 import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
-import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
 export async function getFyndStepData(args) {
     const { quote, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, from, type, input, deps } = args;
     const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
@@ -15,15 +15,12 @@ export async function getFyndStepData(args) {
     };
     const stateOverride = { sellAsset, sellAmountCryptoBaseUnit, spenderAddress };
     if (type === 'rate') {
-        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+        const networkFeeCryptoBaseUnit = await getEvmRateNetworkFeeCryptoBaseUnit({
             adapter,
-            transactionData,
-            from,
             supportsEIP1559,
-            stateOverride,
-        })
-            .catch(() => getEvmNetworkFeeCryptoBaseUnit({ adapter, supportsEIP1559, gasLimit: quote.gas_estimate }))
-            .catch(() => undefined);
+            providerGasLimit: quote.gas_estimate,
+            simulation: { transactionData, from, stateOverride },
+        }).catch(() => undefined);
         const stepData = { networkFeeCryptoBaseUnit };
         return Ok(stepData);
     }
@@ -34,6 +31,7 @@ export async function getFyndStepData(args) {
             from,
             supportsEIP1559,
             stateOverride,
+            providerGasLimit: quote.gas_estimate,
         });
         const stepData = { transactionData, networkFeeCryptoBaseUnit };
         return Ok(stepData);

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

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const kyberSwapper: Swapper;

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

@@ -0,0 +1,2 @@
+import { executeEvmTransaction } from '../../utils/index.js';
+export const kyberSwapper = { executeEvmTransaction };

package/dist/esm/swappers/KyberSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const kyberApi: SwapperApi;

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

@@ -0,0 +1,11 @@
+import { checkEvmSwapStatus } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getKyberTradeQuote } from './swapperApi/getKyberTradeQuote.js';
+import { getKyberTradeRate } from './swapperApi/getKyberTradeRate.js';
+export const kyberApi = {
+    getTradeQuote: (input, deps) => getKyberTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getKyberTradeRate(input, deps),
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
+    checkTradeStatus: checkEvmSwapStatus,
+};

package/dist/esm/swappers/KyberSwapper/index.d.ts

@@ -0,0 +1,2 @@
+export { kyberApi } from './endpoints.js';
+export { kyberSwapper } from './KyberSwapper.js';

package/dist/esm/swappers/KyberSwapper/index.js

@@ -0,0 +1,2 @@
+export { kyberApi } from './endpoints.js';
+export { kyberSwapper } from './KyberSwapper.js';

package/dist/esm/swappers/KyberSwapper/swapperApi/getKyberTradeQuote.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { KyberTradeQuoteInput } from '../types.js';
+export declare const getKyberTradeQuote: (input: KyberTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;