@dynamic-labs/sdk-react-core 4.4.3 → 4.5.0

package/src/lib/utils/hooks/useTransactionSimulation/classes/useEVMTransactionSimulation.js

@@ -0,0 +1,131 @@
+'use client'
+import { __awaiter } from '../../../../../../_virtual/_tslib.js';
+import { useState, useEffect, useCallback } from 'react';
+import { simulateBlockaidUserOperation, simulateBlockaidEVMTransaction } from '../../../../data/api/transactions/blockaid.js';
+import { isZeroDevConnector, calculateAAFees, generateAllFeeData, isEthereumWallet, calculateEVMFees } from '../utils/utils.js';
+import { useBaseTransactionSimulation } from './useBaseTransactionSimulation.js';
+
+const useEVMTransactionSimulation = () => {
+    const { simulationState, setSimulationState, nativeTokenDecimals, handleSimulationError, primaryWallet, environmentId, } = useBaseTransactionSimulation('useEVMTransactionSimulation');
+    const [chainId, setChainId] = useState();
+    useEffect(() => {
+        const fetchChainId = () => __awaiter(void 0, void 0, void 0, function* () {
+            if (primaryWallet === null || primaryWallet === void 0 ? void 0 : primaryWallet.connector) {
+                const network = yield primaryWallet.connector.getNetwork();
+                setChainId(String(network));
+            }
+        });
+        fetchChainId();
+    }, [primaryWallet === null || primaryWallet === void 0 ? void 0 : primaryWallet.connector]);
+    const simulateEVMTransactionAA = useCallback((params) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        if (!(primaryWallet === null || primaryWallet === void 0 ? void 0 : primaryWallet.connector) ||
+            !isZeroDevConnector(primaryWallet.connector)) {
+            return handleSimulationError(new Error('Account abstraction simulation requires ZeroDev connector'), 'AA');
+        }
+        if (!chainId) {
+            return handleSimulationError(new Error('No chain ID found'), 'AA');
+        }
+        const { transaction } = params;
+        try {
+            setSimulationState({ isLoading: true });
+            const connector = primaryWallet.connector;
+            const { userOperation } = yield connector.getCurrentUserOperation(transaction);
+            if (!userOperation) {
+                return handleSimulationError(new Error('failed to get user operation'), 'AA');
+            }
+            const formattedUserOperation = yield connector.formatUserOperation(userOperation);
+            const entryPoint = (_a = connector.getAccountAbstractionProvider()) === null || _a === void 0 ? void 0 : _a.account.entryPoint;
+            if (!entryPoint) {
+                return handleSimulationError(new Error('No entry point address found'), 'AA');
+            }
+            const result = yield simulateBlockaidUserOperation({
+                chainId,
+                entryPoint,
+                environmentId,
+                userOperation: formattedUserOperation,
+                value: ((_b = transaction.value) === null || _b === void 0 ? void 0 : _b.toString()) || '0',
+            });
+            if (!result) {
+                return handleSimulationError(new Error('Simulation failed: No result returned'), 'AA');
+            }
+            const fee = calculateAAFees(userOperation);
+            const isSponsored = yield connector.canSponsorTransactionGas(transaction);
+            const finalFee = isSponsored ? BigInt(0) : fee;
+            const resultWithFee = generateAllFeeData(finalFee, nativeTokenDecimals, result);
+            // Filter out native asset if it's just gas fee (no ETH transfer)
+            // this is when its an aa tx but unsponsored
+            if (!transaction.value) {
+                resultWithFee.outAssets = resultWithFee.outAssets.filter((asset) => asset.asset.type !== 'NATIVE');
+            }
+            setSimulationState({
+                isLoading: false,
+                result: resultWithFee,
+            });
+            return;
+        }
+        catch (error) {
+            return handleSimulationError(error, 'AA');
+        }
+    }), [
+        chainId,
+        primaryWallet,
+        environmentId,
+        nativeTokenDecimals,
+        handleSimulationError,
+        setSimulationState,
+    ]);
+    const simulateEVMTransaction = useCallback((params) => __awaiter(void 0, void 0, void 0, function* () {
+        var _c;
+        const { transaction } = params;
+        if (!(primaryWallet === null || primaryWallet === void 0 ? void 0 : primaryWallet.connector)) {
+            return handleSimulationError(new Error('No wallet connected'), 'EVM');
+        }
+        if (!chainId) {
+            return handleSimulationError(new Error('No chain ID found'), 'EVM');
+        }
+        try {
+            setSimulationState({ isLoading: true });
+            if (!isEthereumWallet(primaryWallet)) {
+                return handleSimulationError(new Error('EVM simulation requires Ethereum wallet'), 'EVM');
+            }
+            const publicClient = yield primaryWallet.getPublicClient();
+            const totalFee = yield calculateEVMFees(publicClient, transaction);
+            const result = yield simulateBlockaidEVMTransaction({
+                chainId,
+                data: transaction.data || '0x',
+                environmentId,
+                from: transaction.from,
+                to: transaction.to,
+                value: ((_c = transaction.value) === null || _c === void 0 ? void 0 : _c.toString()) || '0',
+            });
+            if (!result) {
+                return handleSimulationError(new Error('Simulation failed: No result returned'), 'EVM');
+            }
+            const resultWithFee = generateAllFeeData(totalFee, nativeTokenDecimals, result);
+            // Filter out native asset if it's just gas fee (no ETH transfer)
+            if (!transaction.value) {
+                resultWithFee.outAssets = resultWithFee.outAssets.filter((asset) => asset.asset.type !== 'NATIVE');
+            }
+            setSimulationState({
+                isLoading: false,
+                result: resultWithFee,
+            });
+            return;
+        }
+        catch (error) {
+            return handleSimulationError(error, 'EVM');
+        }
+    }), [
+        chainId,
+        primaryWallet,
+        environmentId,
+        nativeTokenDecimals,
+        handleSimulationError,
+        setSimulationState,
+    ]);
+    return Object.assign({ simulateEVMTransaction,
+        simulateEVMTransactionAA }, simulationState);
+};
+
+export { useEVMTransactionSimulation };

package/src/lib/utils/hooks/useTransactionSimulation/classes/useSVMTransactionSimulation.cjs

@@ -0,0 +1,82 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../../_virtual/_tslib.cjs');
+var React = require('react');
+var bs58 = require('bs58');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var blockaid = require('../../../../data/api/transactions/blockaid.cjs');
+var utils = require('../utils/utils.cjs');
+var useBaseTransactionSimulation = require('./useBaseTransactionSimulation.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
+
+const useSVMTransactionSimulation = () => {
+    const { simulationState, setSimulationState, nativeTokenDecimals, handleSimulationError, primaryWallet, environmentId, } = useBaseTransactionSimulation.useBaseTransactionSimulation('useSVMTransactionSimulation');
+    const simulateSVMTransaction = React.useCallback((params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        if (!(primaryWallet === null || primaryWallet === void 0 ? void 0 : primaryWallet.connector) || primaryWallet.chain !== sdkApiCore.ChainEnum.Sol) {
+            return handleSimulationError(new Error('Solana simulation requires Solana wallet'));
+        }
+        const transactions = Array.isArray(params.transaction)
+            ? params.transaction
+            : [params.transaction];
+        try {
+            setSimulationState({ isLoading: true });
+            let isSponsored = false;
+            const encodedTransactions = transactions.map((tx) => bs58__default["default"].encode(Uint8Array.from(tx.serialize({ requireAllSignatures: false }))));
+            isSponsored = transactions.every((tx) => utils.isSVMTransactionSponsored(tx, primaryWallet.address));
+            const compiledMessages = yield Promise.all(transactions.map((tx) => {
+                var _a;
+                if ('version' in tx) {
+                    return tx.message;
+                }
+                // legacy transactions will have this method
+                return (_a = tx.compileMessage) === null || _a === void 0 ? void 0 : _a.call(tx);
+            }));
+            const connection = yield primaryWallet.getConnection();
+            // Calculate fees for all transactions
+            const fees = yield Promise.all(compiledMessages.map((tx) => utils.getFeeWithRetry(connection, tx)));
+            const fee = fees.reduce((acc, curr) => acc + curr, BigInt(0));
+            const result = yield blockaid.simulateBlockaidSVMTransaction({
+                accountAddress: primaryWallet.address,
+                chain: (yield primaryWallet.connector.getNetwork()),
+                environmentId,
+                transactions: encodedTransactions,
+            });
+            if (!result) {
+                return handleSimulationError(new Error('Simulation failed: No result returned'));
+            }
+            const finalFee = isSponsored ? BigInt(0) : fee || BigInt(0);
+            // For Solana, we need to ensure we have a valid fee
+            if (!isSponsored && finalFee === BigInt(0)) {
+                return handleSimulationError(new Error('Failed to calculate transaction fee'));
+            }
+            const resultWithFee = utils.generateAllFeeData(finalFee, nativeTokenDecimals, result);
+            // simulations include gas fees in the outAssets, so we need to remove them
+            if (!isSponsored) {
+                resultWithFee.outAssets = utils.deductSVMFees(resultWithFee);
+            }
+            setSimulationState({
+                isLoading: false,
+                result: resultWithFee,
+            });
+            return;
+        }
+        catch (error) {
+            return handleSimulationError(error);
+        }
+    }), [
+        primaryWallet,
+        environmentId,
+        nativeTokenDecimals,
+        handleSimulationError,
+        setSimulationState,
+    ]);
+    return Object.assign({ simulateSVMTransaction }, simulationState);
+};
+
+exports.useSVMTransactionSimulation = useSVMTransactionSimulation;

package/src/lib/utils/hooks/useTransactionSimulation/classes/useSVMTransactionSimulation.d.ts

@@ -0,0 +1,12 @@
+import { ISolanaTransaction } from '@dynamic-labs/types';
+import { type TransactionType, type SimulationState, type FeeData } from './useBaseTransactionSimulation';
+export type { TransactionType, SimulationState, FeeData };
+export type SVMTransaction = ISolanaTransaction | ISolanaTransaction[];
+export type SVMTransactionParams = {
+    transaction: SVMTransaction;
+    type: Omit<TransactionType, 'SendTransaction'>;
+};
+export type SVMTransactionSimulationHook = {
+    simulateSVMTransaction: (params: SVMTransactionParams) => Promise<void>;
+} & SimulationState;
+export declare const useSVMTransactionSimulation: () => SVMTransactionSimulationHook;

package/src/lib/utils/hooks/useTransactionSimulation/classes/useSVMTransactionSimulation.js

@@ -0,0 +1,74 @@
+'use client'
+import { __awaiter } from '../../../../../../_virtual/_tslib.js';
+import { useCallback } from 'react';
+import bs58 from 'bs58';
+import { ChainEnum } from '@dynamic-labs/sdk-api-core';
+import { simulateBlockaidSVMTransaction } from '../../../../data/api/transactions/blockaid.js';
+import { isSVMTransactionSponsored, getFeeWithRetry, generateAllFeeData, deductSVMFees } from '../utils/utils.js';
+import { useBaseTransactionSimulation } from './useBaseTransactionSimulation.js';
+
+const useSVMTransactionSimulation = () => {
+    const { simulationState, setSimulationState, nativeTokenDecimals, handleSimulationError, primaryWallet, environmentId, } = useBaseTransactionSimulation('useSVMTransactionSimulation');
+    const simulateSVMTransaction = useCallback((params) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!(primaryWallet === null || primaryWallet === void 0 ? void 0 : primaryWallet.connector) || primaryWallet.chain !== ChainEnum.Sol) {
+            return handleSimulationError(new Error('Solana simulation requires Solana wallet'));
+        }
+        const transactions = Array.isArray(params.transaction)
+            ? params.transaction
+            : [params.transaction];
+        try {
+            setSimulationState({ isLoading: true });
+            let isSponsored = false;
+            const encodedTransactions = transactions.map((tx) => bs58.encode(Uint8Array.from(tx.serialize({ requireAllSignatures: false }))));
+            isSponsored = transactions.every((tx) => isSVMTransactionSponsored(tx, primaryWallet.address));
+            const compiledMessages = yield Promise.all(transactions.map((tx) => {
+                var _a;
+                if ('version' in tx) {
+                    return tx.message;
+                }
+                // legacy transactions will have this method
+                return (_a = tx.compileMessage) === null || _a === void 0 ? void 0 : _a.call(tx);
+            }));
+            const connection = yield primaryWallet.getConnection();
+            // Calculate fees for all transactions
+            const fees = yield Promise.all(compiledMessages.map((tx) => getFeeWithRetry(connection, tx)));
+            const fee = fees.reduce((acc, curr) => acc + curr, BigInt(0));
+            const result = yield simulateBlockaidSVMTransaction({
+                accountAddress: primaryWallet.address,
+                chain: (yield primaryWallet.connector.getNetwork()),
+                environmentId,
+                transactions: encodedTransactions,
+            });
+            if (!result) {
+                return handleSimulationError(new Error('Simulation failed: No result returned'));
+            }
+            const finalFee = isSponsored ? BigInt(0) : fee || BigInt(0);
+            // For Solana, we need to ensure we have a valid fee
+            if (!isSponsored && finalFee === BigInt(0)) {
+                return handleSimulationError(new Error('Failed to calculate transaction fee'));
+            }
+            const resultWithFee = generateAllFeeData(finalFee, nativeTokenDecimals, result);
+            // simulations include gas fees in the outAssets, so we need to remove them
+            if (!isSponsored) {
+                resultWithFee.outAssets = deductSVMFees(resultWithFee);
+            }
+            setSimulationState({
+                isLoading: false,
+                result: resultWithFee,
+            });
+            return;
+        }
+        catch (error) {
+            return handleSimulationError(error);
+        }
+    }), [
+        primaryWallet,
+        environmentId,
+        nativeTokenDecimals,
+        handleSimulationError,
+        setSimulationState,
+    ]);
+    return Object.assign({ simulateSVMTransaction }, simulationState);
+};
+
+export { useSVMTransactionSimulation };

package/src/lib/utils/hooks/useTransactionSimulation/index.d.ts

@@ -0,0 +1,6 @@
+export { useEVMTransactionSimulation } from './classes/useEVMTransactionSimulation';
+export { useSVMTransactionSimulation } from './classes/useSVMTransactionSimulation';
+export type { EVMTransactionSimulationHook } from './classes/useEVMTransactionSimulation';
+export type { SVMTransactionSimulationHook } from './classes/useSVMTransactionSimulation';
+export type { SimulationState } from './classes/useBaseTransactionSimulation';
+export * from './utils/utils';

package/src/lib/utils/hooks/useTransactionSimulation/utils/utils.cjs

@@ -0,0 +1,198 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../../_virtual/_tslib.cjs');
+
+const generateAllFeeData = (totalFee, nativeTokenDecimals, result) => {
+    var _a;
+    return (Object.assign(Object.assign({}, result), { feeData: {
+            humanReadableAmount: calculateHumanReadableAmount(totalFee, nativeTokenDecimals),
+            nativeAmount: totalFee,
+            usdAmount: calculateFeeUsd(totalFee, (_a = result.priceData) === null || _a === void 0 ? void 0 : _a.nativeTokenUsdPrice, nativeTokenDecimals),
+        } }));
+};
+// Base Gas Price Oracle ABI
+const gasPriceOracleAbi = [
+    {
+        inputs: [{ internalType: 'bytes', name: '_data', type: 'bytes' }],
+        name: 'getL1Fee',
+        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+// Helper to estimate L1 data fee for L2 chains that support it
+// only supports opStack chains currently
+const estimateL1DataFee = (publicClient, transaction) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    // Standard OP Stack Gas Price Oracle address
+    const oracleAddress = '0x420000000000000000000000000000000000000F';
+    try {
+        // Check if the contract exists at this address
+        const code = yield publicClient.getBytecode({
+            address: oracleAddress,
+        });
+        if (!code || code === '0x') {
+            return BigInt(0);
+        }
+        const callData = transaction.data || '0x';
+        const l1Fee = yield publicClient.readContract({
+            abi: gasPriceOracleAbi,
+            address: oracleAddress,
+            args: [callData],
+            functionName: 'getL1Fee',
+        });
+        return l1Fee;
+    }
+    catch (e) {
+        return BigInt(0);
+    }
+});
+const calculateAAFees = (userOp) => {
+    // Sum all gas units
+    const totalGasUnits = BigInt(userOp.callGasLimit || 0) +
+        BigInt(userOp.verificationGasLimit || 0) +
+        BigInt(userOp.preVerificationGas || 0);
+    // Multiply by maxFeePerGas to get the total gas cost in wei
+    const gasCost = totalGasUnits * BigInt(userOp.maxFeePerGas || 0);
+    return gasCost;
+};
+const isSVMTransactionSponsored = (transaction, from) => {
+    var _a, _b;
+    if ('version' in transaction) {
+        return from !== ((_a = transaction.message) === null || _a === void 0 ? void 0 : _a.staticAccountKeys[0].toBase58());
+    }
+    if ('feePayer' in transaction) {
+        return from !== ((_b = transaction.feePayer) === null || _b === void 0 ? void 0 : _b.toBase58());
+    }
+    return false;
+};
+const toDecimalString = (num, decimals) => {
+    // Convert to fixed decimal string
+    const str = num.toFixed(decimals);
+    // Remove trailing zeros after decimal point
+    const parts = str.split('.');
+    if (parts.length === 1)
+        return parts[0];
+    const decimalsWithoutTrailingZeros = parts[1].replace(/0+$/, '');
+    return decimalsWithoutTrailingZeros
+        ? `${parts[0]}.${decimalsWithoutTrailingZeros}`
+        : parts[0];
+};
+const calculateHumanReadableAmount = (amount, decimals) => {
+    if (!amount) {
+        return undefined;
+    }
+    // Convert to decimal by dividing by 10^decimals
+    const divisor = BigInt(Math.pow(10, decimals));
+    const wholePart = amount / divisor;
+    const fractionalPart = amount % divisor;
+    // Handle the case where there's no fractional part
+    if (fractionalPart === BigInt(0)) {
+        return wholePart.toString();
+    }
+    // Pad the fractional part with leading zeros if needed
+    const fractionalStr = fractionalPart.toString().padStart(decimals, '0');
+    // Remove trailing zeros from fractional part
+    const cleanFractionalStr = fractionalStr.replace(/0+$/, '');
+    return cleanFractionalStr
+        ? `${wholePart}.${cleanFractionalStr}`
+        : wholePart.toString();
+};
+const calculateFeeUsd = (fee, nativeTokenUsdPrice, decimals) => {
+    if (!fee || !nativeTokenUsdPrice) {
+        return undefined;
+    }
+    const humanReadableAmount = calculateHumanReadableAmount(fee, decimals);
+    if (!humanReadableAmount) {
+        return undefined;
+    }
+    const usdValue = parseFloat(humanReadableAmount) * nativeTokenUsdPrice;
+    // Use more decimals for small values, 2 decimals for larger values
+    const significantDecimals = usdValue < 0.01 ? decimals : 2;
+    return toDecimalString(usdValue, significantDecimals);
+};
+const getFeeWithRetry = (connection, message) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    if (!(connection === null || connection === void 0 ? void 0 : connection.getFeeForMessage)) {
+        return BigInt(0);
+    }
+    let res = yield connection.getFeeForMessage(message, 'confirmed');
+    let retryCount = 0;
+    while (res.value === null && retryCount < 5) {
+        res = yield connection.getFeeForMessage(message, 'confirmed');
+        retryCount++;
+    }
+    // Convert number to bigint for Solana fees
+    return res.value ? BigInt(Number(res.value)) : BigInt(0);
+});
+const getNativeTokenDecimals = (chain, networkConfigurations) => {
+    var _a, _b;
+    if (!chain || !networkConfigurations) {
+        return 18;
+    }
+    // the NetworkConfigurationMap uses 'solana" not "SOL"
+    if (chain === 'SOL') {
+        return 9;
+    }
+    const chainConfigs = networkConfigurations[chain];
+    if (!(chainConfigs === null || chainConfigs === void 0 ? void 0 : chainConfigs.length)) {
+        return 18;
+    }
+    return ((_b = (_a = chainConfigs[0]) === null || _a === void 0 ? void 0 : _a.nativeCurrency) === null || _b === void 0 ? void 0 : _b.decimals) || 18;
+};
+const isEthereumWallet = (wallet) => wallet.chain === 'EVM';
+const isZeroDevConnector = (connector) => (connector === null || connector === void 0 ? void 0 : connector.key) === 'zerodev';
+const calculateEVMFees = (publicClient, transaction) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    // Estimate gas if not provided
+    const estimatedGas = !transaction.gas
+        ? BigInt(yield publicClient.estimateGas(transaction))
+        : transaction.gas;
+    // Get current gas price which includes both base fee and priority fee
+    const gasPrice = yield publicClient.getGasPrice();
+    const l2Fee = estimatedGas * gasPrice;
+    const l1Fee = yield estimateL1DataFee(publicClient, transaction);
+    return l2Fee + l1Fee;
+});
+const deductSVMFees = (resultWithFee) => resultWithFee.outAssets
+    .map((asset) => {
+    var _a, _b, _c, _d;
+    // Only process SOL assets with valid transferOut
+    const transferOutRawValue = (_b = (_a = asset.transferOut) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.rawValue;
+    if (asset.asset.type === 'SOL' ||
+        (asset.asset.type === 'NATIVE' && transferOutRawValue)) {
+        const [transferOut] = asset.transferOut;
+        const nativeAmountStr = (_c = resultWithFee.feeData.nativeAmount) === null || _c === void 0 ? void 0 : _c.toString();
+        // If exact match, mark for removal
+        if (nativeAmountStr && transferOutRawValue === nativeAmountStr) {
+            return null;
+        }
+        if (!transferOutRawValue) {
+            return asset;
+        }
+        // Otherwise, deduct the fee from the transfer amount
+        const nativeAmountToDeduct = resultWithFee.feeData.nativeAmount || BigInt(0);
+        const newRawValue = (BigInt(transferOutRawValue) - nativeAmountToDeduct).toString();
+        const newValue = (Number(newRawValue) / Math.pow(10, 9)).toString();
+        const newUsdPrice = (Number(newValue) * (((_d = resultWithFee.priceData) === null || _d === void 0 ? void 0 : _d.nativeTokenUsdPrice) || 0)).toString();
+        return Object.assign(Object.assign({}, asset), { transferOut: [
+                Object.assign(Object.assign({}, transferOut), { rawValue: newRawValue, summary: `Transfer ${newValue} SOL`, usdPrice: newUsdPrice, value: newValue }),
+            ] });
+    }
+    return asset;
+})
+    .filter((asset) => asset !== null);
+
+exports.calculateAAFees = calculateAAFees;
+exports.calculateEVMFees = calculateEVMFees;
+exports.calculateFeeUsd = calculateFeeUsd;
+exports.calculateHumanReadableAmount = calculateHumanReadableAmount;
+exports.deductSVMFees = deductSVMFees;
+exports.estimateL1DataFee = estimateL1DataFee;
+exports.gasPriceOracleAbi = gasPriceOracleAbi;
+exports.generateAllFeeData = generateAllFeeData;
+exports.getFeeWithRetry = getFeeWithRetry;
+exports.getNativeTokenDecimals = getNativeTokenDecimals;
+exports.isEthereumWallet = isEthereumWallet;
+exports.isSVMTransactionSponsored = isSVMTransactionSponsored;
+exports.isZeroDevConnector = isZeroDevConnector;

package/src/lib/utils/hooks/useTransactionSimulation/utils/utils.d.ts

@@ -0,0 +1,52 @@
+import { NetworkConfigurationMap, ISolanaTransaction, IEVMTransaction } from '@dynamic-labs/types';
+import { ChainEnum, SimulateTransactionResponse, AssetDiff } from '@dynamic-labs/sdk-api-core';
+import { WalletConnector, Wallet, IPublicClient, ISolanaConnection } from '@dynamic-labs/wallet-connector-core';
+import { FeeData } from '../classes/useSVMTransactionSimulation';
+export declare const generateAllFeeData: (totalFee: bigint, nativeTokenDecimals: number, result: SimulateTransactionResponse) => {
+    feeData: {
+        humanReadableAmount: string | undefined;
+        nativeAmount: bigint;
+        usdAmount: string | undefined;
+    };
+    inAssets: AssetDiff[];
+    outAssets: AssetDiff[];
+    counterparties?: string[] | undefined;
+    priceData: import("@dynamic-labs/sdk-api-core").PriceData;
+    showTotalFiat: boolean;
+    validation?: import("@dynamic-labs/sdk-api-core").BlockaidValidation | undefined;
+    assetExposures?: import("@dynamic-labs/sdk-api-core").AssetExposure[] | undefined;
+};
+export declare const gasPriceOracleAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "_data";
+        readonly type: "bytes";
+    }];
+    readonly name: "getL1Fee";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export declare const estimateL1DataFee: (publicClient: IPublicClient, transaction: IEVMTransaction) => Promise<bigint>;
+export declare const calculateAAFees: (userOp: any) => bigint;
+export declare const isSVMTransactionSponsored: (transaction: ISolanaTransaction, from: string) => boolean;
+export declare const calculateHumanReadableAmount: (amount: bigint | undefined, decimals: number) => string | undefined;
+export declare const calculateFeeUsd: (fee: bigint | undefined, nativeTokenUsdPrice: number | undefined, decimals: number) => string | undefined;
+export declare const getFeeWithRetry: (connection: ISolanaConnection, message: any) => Promise<bigint>;
+export declare const getNativeTokenDecimals: (chain: ChainEnum | undefined, networkConfigurations: NetworkConfigurationMap | undefined) => number;
+export declare const isEthereumWallet: (wallet: Wallet) => boolean;
+export declare const isZeroDevConnector: (connector: WalletConnector) => boolean;
+export declare const calculateEVMFees: (publicClient: IPublicClient, transaction: {
+    data?: string;
+    to: string;
+    value: bigint;
+    from: string;
+    gas?: bigint;
+}) => Promise<bigint>;
+export declare const deductSVMFees: (resultWithFee: SimulateTransactionResponse & {
+    feeData: FeeData;
+}) => AssetDiff[];