@deserialize/multi-vm-wallet 1.3.3 → 1.4.0

package/utils/evm/utils.ts

@@ -4,8 +4,16 @@ import BN from 'bn.js'
 import { HelperAPI } from '../helpers';
 import BigNumber from 'bignumber.js';
 
-const KYBER_BASE_URL = 'https://aggregator-api.kyberswap.com';
-
+import type { TransactionReceipt as EthersTransactionReceipt } from 'ethers'
+import type { Chain, TransactionReceipt as ViemTransactionReceipt } from 'viem'
+import {
+    PublicClient,
+    WalletClient,
+    Hex,
+    encodeFunctionData,
+    parseEther,
+    formatEther,
+} from 'viem'
 export interface TransactionParams {
     to: string
     value?: string | bigint  // For native token transfers
@@ -19,7 +27,8 @@ export interface TransactionParams {
 
 interface TransactionResult {
     hash: string
-    receipt: TransactionReceipt | null
+    receipt: EthersTransactionReceipt | null
+    viemReceipt?: ViemTransactionReceipt
     success: boolean
     gasUsed?: bigint
     effectiveGasPrice?: bigint
@@ -137,508 +146,555 @@ interface KyberSwapParams {
 }
 
 // ERC-20 ABI
-const ERC20_ABI = [
-    "function balanceOf(address owner) view returns (uint256)",
-    "function decimals() view returns (uint8)",
-    "function symbol() view returns (string)",
-    "function name() view returns (string)",
-    "function transfer(address to, uint256 amount) returns (bool)",
-    "function transferFrom(address from, address to, uint256 amount) returns (bool)",
-    "function approve(address spender, uint256 amount) returns (bool)",
-    "function allowance(address owner, address spender) view returns (uint256)"
-]
-
-export const getNativeBalance = async (address: string, provider: JsonRpcProvider): Promise<Balance> => {
-    const balance = await provider.getBalance(address)
-    const final = ethers.formatEther(balance)
 
+export const ERC20_ABI = [
+    {
+        name: 'balanceOf',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'owner', type: 'address' }],
+        outputs: [{ type: 'uint256' }],
+    },
+    {
+        name: 'decimals',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'uint8' }],
+    },
+    {
+        name: 'symbol',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'string' }],
+    },
+    {
+        name: 'name',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'string' }],
+    },
+    {
+        name: 'transfer',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'to', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ type: 'bool' }],
+    },
+    {
+        name: 'approve',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'spender', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ type: 'bool' }],
+    },
+    {
+        name: 'allowance',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+        ],
+        outputs: [{ type: 'uint256' }],
+    },
+] as const
+
+
+export const fromChainToViemChain = (config: ChainWalletConfig): Chain => {
     return {
-        balance: new BN(balance),
-        formatted: Number(final),
-        decimal: 18
+        rpcUrls: {
+            default: {
+                http: [config.rpcUrl]
+            }
+        },
+        id: config.chainId,
+        name: config.name,
+        nativeCurrency: {
+            name: config.nativeToken.name,
+            symbol: config.nativeToken.symbol,
+            decimals: config.nativeToken.decimals
+        },
+        blockExplorers: {
+            default: {
+                name: config.name + " Explorer",
+                url: config.explorerUrl,
+                apiUrl: config.explorerUrl
+            },
+        },
+        testnet: config.testnet || false
+
     }
-}
 
-export const getTokenInfo = async (
-    tokenAddress: string,
-    provider: JsonRpcProvider
-): Promise<TokenInfo> => {
-    try {
-        // Create contract instance
-        const tokenContract = new Contract(tokenAddress, ERC20_ABI, provider)
 
+}
+export function viemReceiptToEthersReceipt(
+    receipt: ViemTransactionReceipt,
+): EthersTransactionReceipt {
+    return {
+        to: receipt.to ?? null,
+        from: receipt.from,
+        contractAddress: receipt.contractAddress ?? null,
+
+        transactionIndex: Number(receipt.transactionIndex),
+        gasUsed: receipt.gasUsed,
+        logsBloom: receipt.logsBloom,
+        blockHash: receipt.blockHash,
+        transactionHash: receipt.transactionHash,
+
+        logs: receipt.logs.map((log) => ({
+            address: log.address,
+            topics: log.topics,
+            data: log.data,
+            blockNumber: Number(log.blockNumber),
+            transactionHash: log.transactionHash,
+            transactionIndex: Number(log.transactionIndex),
+            blockHash: log.blockHash,
+            logIndex: Number(log.logIndex),
+            removed: false,
+        })),
+
+        blockNumber: Number(receipt.blockNumber),
+        confirmations: 0, // ethers usually fills this lazily
+        cumulativeGasUsed: receipt.cumulativeGasUsed,
+        effectiveGasPrice: receipt.effectiveGasPrice,
+
+        status: receipt.status === 'success' ? 1 : 0,
+        type: receipt.type,
+    } as unknown as EthersTransactionReceipt
+}
+
+
+export const getNativeBalance = async (
+    address: Hex,
+    client: PublicClient
+): Promise<Balance> => {
+    const balance = await client.getBalance({ address })
 
-        // Get decimals to format the balance properly
-        const [decimals, name, symbol] = await Promise.all([
-            await tokenContract.decimals(),
-            await tokenContract.name(),
-            await tokenContract.symbol(),
+    return {
+        balance: new BN(balance.toString()),
+        formatted: Number(formatEther(balance)),
+        decimal: 18,
+    }
+}
 
-        ])
 
-        return {
-            name: name,
-            symbol: symbol,
+export const getTokenInfo = async (
+    tokenAddress: Hex,
+    client: PublicClient
+): Promise<TokenInfo> => {
+    const [decimals, name, symbol] = await Promise.all([
+        client.readContract({
             address: tokenAddress,
-            decimals: decimals
-        }
-    } catch (error) {
-        console.error('Error fetching token balance:', error)
-        throw error
+            abi: ERC20_ABI,
+            functionName: 'decimals',
+        }),
+        client.readContract({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            functionName: 'name',
+        }),
+        client.readContract({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            functionName: 'symbol',
+        }),
+    ])
+
+    return {
+        name,
+        symbol,
+        address: tokenAddress,
+        decimals,
     }
 }
+
 export const getTokenBalance = async (
-    tokenAddress: string,
-    walletAddress: string,
-    provider: JsonRpcProvider
+    tokenAddress: Hex,
+    walletAddress: Hex,
+    client: PublicClient
 ): Promise<Balance> => {
-    try {
-        // Create contract instance
-        const tokenContract = new Contract(tokenAddress, ERC20_ABI, provider)
-
-        // Get balance (returns BigNumber)
-        const balance: bigint = await tokenContract.balanceOf(walletAddress)
+    const [balance, decimals] = await Promise.all([
+        client.readContract({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            functionName: 'balanceOf',
+            args: [walletAddress],
+        }),
+        client.readContract({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            functionName: 'decimals',
+        }),
+    ])
 
-        // Get decimals to format the balance properly
-        const decimals = await tokenContract.decimals()
-        // Format balance by dividing by 10^decimals
-        const formattedBalance = balance / (10n ** BigInt(decimals))
+    const formatted = balance / 10n ** BigInt(decimals)
 
-        return {
-            balance: new BN(balance.toString()), // Raw balance as BigNumber
-            formatted: Number(formattedBalance.toString()),
-            decimal: decimals
-        }
-    } catch (error) {
-        console.error('Error fetching token balance:', error)
-        throw error
+    return {
+        balance: new BN(balance.toString()),
+        formatted: Number(formatted),
+        decimal: decimals,
     }
 }
 
+
 /**
  * Sign, send, and confirm any EVM transaction
  */
 export const signSendAndConfirm = async (
-    wallet: Wallet, // Connected wallet (private key + provider)
-    transactionParams: TransactionParams,
-    confirmations: number = 1, // Number of confirmations to wait for
-    timeout: number = 300000 // 5 minutes timeout
+    walletClient: WalletClient,
+    publicClient: PublicClient,
+    params: {
+        to: Hex
+        data?: Hex
+        value?: bigint
+        gas?: bigint
+        nonce?: number
+        maxFeePerGas?: bigint
+        maxPriorityFeePerGas?: bigint
+    },
+    confirmations = 1
 ): Promise<TransactionResult> => {
-    try {
-        // Prepare transaction object
-        const tx: TransactionRequest = {
-            to: transactionParams.to,
-            value: transactionParams.value || 0,
-            data: transactionParams.data || '0x',
-        }
-
-        // Set gas parameters
-        if (transactionParams.gasLimit) {
-            tx.gasLimit = transactionParams.gasLimit
-        }
-
-        // Handle gas pricing (EIP-1559 vs legacy)
-        if (transactionParams.maxFeePerGas && transactionParams.maxPriorityFeePerGas) {
-            // EIP-1559 transaction
-            tx.maxFeePerGas = transactionParams.maxFeePerGas
-            tx.maxPriorityFeePerGas = transactionParams.maxPriorityFeePerGas
-        } else if (transactionParams.gasPrice) {
-            // Legacy transaction
-            tx.gasPrice = transactionParams.gasPrice
-        }
-
-        // Set nonce if provided
-        if (transactionParams.nonce !== undefined) {
-            tx.nonce = transactionParams.nonce
-        }
-
-        // Estimate gas if not provided
-        if (!tx.gasLimit) {
-            tx.gasLimit = await wallet.estimateGas(tx)
-        }
 
-        console.log('Sending transaction:', tx)
-
-        // Sign and send transaction
-        const txResponse: TransactionResponse = await wallet.sendTransaction(tx)
-
-        console.log(`Transaction sent with hash: ${txResponse.hash}`)
-
-        // Wait for confirmation with timeout
-        const receipt = await Promise.race([
-            txResponse.wait(confirmations),
-            new Promise<null>((_, reject) =>
-                setTimeout(() => reject(new Error('Transaction confirmation timeout')), timeout)
-            )
-        ])
-
-        const result: TransactionResult = {
-            hash: txResponse.hash,
-            receipt: receipt,
-            success: receipt?.status === 1,
-            gasUsed: receipt?.gasUsed,
-            effectiveGasPrice: receipt?.gasPrice,
-            blockNumber: receipt?.blockNumber,
-            confirmations: confirmations
-        }
+    if (walletClient.account === undefined) {
+        throw new Error("wallet Client is not Initialized with an Account")
+    }
+    const hash = await walletClient.sendTransaction({
+        to: params.to,
+        data: params.data,
+        value: params.value,
+        gas: params.gas,
+        nonce: params.nonce,
+        maxFeePerGas: params.maxFeePerGas,
+        maxPriorityFeePerGas: params.maxPriorityFeePerGas,
+        account: walletClient.account,
+        chain: publicClient.chain
 
-        console.log(`Transaction ${result.success ? 'successful' : 'failed'}:`, result)
+    })
 
-        return result
+    const receipt = await publicClient.waitForTransactionReceipt({
+        hash,
+        confirmations,
+    })
 
-    } catch (error) {
-        console.error('Transaction failed:', error)
-        throw error
+    return {
+        hash,
+        receipt: viemReceiptToEthersReceipt(receipt),
+        viemReceipt: receipt,
+        success: receipt.status === 'success',
+        gasUsed: receipt.gasUsed,
+        effectiveGasPrice: receipt.effectiveGasPrice,
+        blockNumber: Number(receipt.blockNumber.toString()),
+        confirmations,
     }
 }
 
+
 /**
  * Send native token (ETH, BNB, MATIC, etc.)
  */
 export const sendNativeToken = async (
-    wallet: Wallet,
-    to: string,
-    amount: string | bigint, // Amount in wei
-    gasLimit?: string | bigint,
-    confirmations: number = 1
-): Promise<TransactionResult> => {
-    return await signSendAndConfirm(
-        wallet,
-        {
-            to,
-            value: (Number(amount) * 10 ** 18).toString(),
-            gasLimit
-        },
+    walletClient: WalletClient,
+    publicClient: PublicClient,
+    to: Hex,
+    amount: string | bigint,
+    confirmations = 1
+) => {
+    const value =
+        typeof amount === 'string' ? parseEther(amount) : amount
+
+    return signSendAndConfirm(
+        walletClient,
+        publicClient,
+        { to, value },
         confirmations
     )
 }
 
+
 /**
  * Send ERC-20 token
  */
 export const sendERC20Token = async (
-    wallet: Wallet,
-    tokenAddress: string,
-    to: string,
-    amount: string | bigint, // Amount in token's smallest unit
-    gasLimit?: string | bigint,
-    confirmations: number = 1
-): Promise<TransactionResult> => {
-    try {
-        // Create contract instance
-        const tokenContract = new Contract(tokenAddress, ERC20_ABI, wallet)
-
-        // Encode transfer function call
-        const data = tokenContract.interface.encodeFunctionData('transfer', [to, amount])
-
-        return await signSendAndConfirm(
-            wallet,
-            {
-                to: tokenAddress,
-                data,
-                gasLimit
-            },
-            confirmations
-        )
-    } catch (error) {
-        console.error('ERC-20 transfer failed:', error)
-        throw error
-    }
-}
+    walletClient: WalletClient,
+    publicClient: PublicClient,
+    tokenAddress: Hex,
+    to: Hex,
+    amount: bigint,
+    confirmations = 1
+) => {
+    const data = encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: 'transfer',
+        args: [to, amount],
+    })
 
-/**
- * Execute any contract method
- */
-export const executeContractMethod = async (
-    wallet: Wallet,
-    contractAddress: string,
-    abi: any[],
-    methodName: string,
-    methodParams: any[] = [],
-    value?: string | bigint, // For payable methods
-    gasLimit?: string | bigint,
-    confirmations: number = 1
-): Promise<TransactionResult> => {
-    try {
-        // Create contract instance
-        const contract = new Contract(contractAddress, abi, wallet)
-
-        // Encode method call
-        const data = contract.interface.encodeFunctionData(methodName, methodParams)
-
-        return await signSendAndConfirm(
-            wallet,
-            {
-                to: contractAddress,
-                data,
-                value,
-                gasLimit
-            },
-            confirmations
-        )
-    } catch (error) {
-        console.error('Contract method execution failed:', error)
-        throw error
-    }
+    return signSendAndConfirm(
+        walletClient,
+        publicClient,
+        { to: tokenAddress, data },
+        confirmations
+    )
 }
 
+
+
+
 /**
  * Get current gas prices (both legacy and EIP-1559)
  */
-export const getGasPrices = async (provider: JsonRpcProvider) => {
-    try {
-        const feeData = await provider.getFeeData()
-
-        return {
-            // Legacy
-            gasPrice: feeData.gasPrice,
-            // EIP-1559
-            maxFeePerGas: feeData.maxFeePerGas,
-            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
-        }
-    } catch (error) {
-        console.error('Error fetching gas prices:', error)
-        throw error
+export const getGasPrices = async (client: PublicClient) => {
+    const fees = await client.estimateFeesPerGas()
+    return {
+        gasPrice: fees.gasPrice,
+        maxFeePerGas: fees.maxFeePerGas,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
     }
 }
 
+
 /**
  * Estimate gas for a transaction
  */
 export const estimateGas = async (
-    provider: JsonRpcProvider,
-    transactionParams: TransactionParams
-): Promise<bigint> => {
-    try {
-        const tx: TransactionRequest = {
-            to: transactionParams.to,
-            value: transactionParams.value || 0,
-            data: transactionParams.data || '0x'
-        }
-
-        return await provider.estimateGas(tx)
-    } catch (error) {
-        console.error('Gas estimation failed:', error)
-        throw error
+    client: PublicClient,
+    params: {
+        to: Hex
+        data?: Hex
+        value?: bigint
     }
+) => {
+    return client.estimateGas(params)
 }
 
 
-/**
- * Check ERC-20 token allowance
- */
 export const checkAllowance = async (
-    tokenAddress: string,
-    owner: string,
-    spender: string,
-    provider: JsonRpcProvider
-): Promise<{
-    allowance: bigint,
-    formatted: string,
-    decimals: number
-}> => {
-    try {
-        const tokenContract = new Contract(tokenAddress, ERC20_ABI, provider)
-
-        // Get allowance and decimals
-        const [allowance, decimals] = await Promise.all([
-            tokenContract.allowance(owner, spender),
-            tokenContract.decimals()
-        ])
-
-        // Format allowance for display
-        const formattedAllowance = allowance / (10n ** BigInt(decimals))
+    client: PublicClient,
+    tokenAddress: Hex,
+    owner: Hex,
+    spender: Hex,
+) => {
+    const [allowance, decimals] = await Promise.all([
+        client.readContract({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            functionName: 'allowance',
+            args: [owner, spender],
+        }),
+        client.readContract({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            functionName: 'decimals',
+        }),
+    ])
 
-        return {
-            allowance,
-            formatted: formattedAllowance.toString(),
-            decimals
-        }
-    } catch (error) {
-        console.error('Error checking allowance:', error)
-        throw error
+    return {
+        allowance,
+        formatted: (allowance / 10n ** BigInt(decimals)).toString(),
+        decimals,
     }
 }
 
+
 /**
  * Check if allowance is sufficient for a transaction
  */
 export const isAllowanceSufficient = async (
-    tokenAddress: string,
-    owner: string,
-    spender: string,
+    publicClient: PublicClient,
+    tokenAddress: `0x${string}`,
+    owner: `0x${string}`,
+    spender: `0x${string}`,
     requiredAmount: string | bigint,
-    provider: JsonRpcProvider
-): Promise<boolean> => {
-    try {
-        const { allowance } = await checkAllowance(tokenAddress, owner, spender, provider)
-        const required = typeof requiredAmount === 'string' ? BigInt(requiredAmount) : requiredAmount
+) => {
+    const { allowance } = await checkAllowance(
+        publicClient,
+        tokenAddress,
+        owner,
+        spender,
+    )
 
-        return allowance >= required
-    } catch (error) {
-        console.error('Error checking allowance sufficiency:', error)
-        throw error
-    }
+    return allowance >= BigInt(requiredAmount)
 }
 
+
 /**
  * Approve ERC-20 token spending
  */
 export const approveToken = async (
-    wallet: Wallet,
-    tokenAddress: string,
-    spender: string,
-    amount: string | bigint, // Amount to approve, use MaxUint256 for unlimited
-    gasLimit?: string | bigint,
-    confirmations: number = 1
-): Promise<TransactionResult> => {
-    try {
-        const tokenContract = new Contract(tokenAddress, ERC20_ABI, wallet)
-
-        // Encode approve function call
-        const data = tokenContract.interface.encodeFunctionData('approve', [spender, amount])
+    walletClient: WalletClient,
+    publicClient: PublicClient,
+    tokenAddress: Hex,
+    spender: Hex,
+    amount: bigint,
+    confirmations = 1
+) => {
+    const data = encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: 'approve',
+        args: [spender, amount],
+    })
 
-        return await signSendAndConfirm(
-            wallet,
-            {
-                to: tokenAddress,
-                data,
-                gasLimit
-            },
-            confirmations
-        )
-    } catch (error) {
-        console.error('Token approval failed:', error)
-        throw error
-    }
+    return signSendAndConfirm(
+        walletClient,
+        publicClient,
+        { to: tokenAddress, data },
+        confirmations
+    )
 }
 
+const MAX_UINT256 =
+    2n ** 256n - 1n
+
 /**
  * Approve unlimited token spending (MaxUint256)
  */
 export const approveTokenUnlimited = async (
-    wallet: Wallet,
-    tokenAddress: string,
-    spender: string,
-    gasLimit?: string | bigint,
-    confirmations: number = 1
-): Promise<TransactionResult> => {
-    // MaxUint256 = 2^256 - 1
-    const MAX_UINT256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935"
-
-    return await approveToken(wallet, tokenAddress, spender, MAX_UINT256, gasLimit, confirmations)
+    walletClient: WalletClient,
+    publicClient: PublicClient,
+    tokenAddress: `0x${string}`,
+    spender: `0x${string}`,
+    gas?: bigint,
+    confirmations = 1,
+) => {
+    return approveToken(
+        walletClient,
+        publicClient,
+        tokenAddress,
+        spender,
+        MAX_UINT256,
+        confirmations,
+    )
 }
 
 /**
  * Check allowance and approve if necessary
  */
 export const checkAndApprove = async (
-    wallet: Wallet,
-    tokenAddress: string,
-    spender: string,
-    requiredAmount: string | bigint,
-    approvalAmount?: string | bigint, // If not provided, will approve exactly the required amount
-    gasLimit?: string | bigint,
-    confirmations: number = 1
+    walletClient: WalletClient,
+    publicClient: PublicClient,
+    tokenAddress: `0x${string}`,
+    spender: `0x${string}`,
+    requiredAmount: bigint,
+    approvalAmount?: bigint,
+    gas?: bigint,
+    confirmations = 1,
 ): Promise<{
-    approvalNeeded: boolean,
-    currentAllowance: bigint,
+    approvalNeeded: boolean
+    currentAllowance: bigint
     approvalResult?: TransactionResult
 }> => {
-    try {
-        const owner = await wallet.getAddress()
-        const provider = wallet.provider as JsonRpcProvider
-
-        // Check current allowance
-        const { allowance } = await checkAllowance(tokenAddress, owner, spender, provider)
-        const required = typeof requiredAmount === 'string' ? BigInt(requiredAmount) : requiredAmount
+    const owner = walletClient.account!.address
 
-        const approvalNeeded = allowance < required
+    const allowance = await publicClient.readContract({
+        address: tokenAddress,
+        abi: ERC20_ABI,
+        functionName: 'allowance',
+        args: [owner, spender],
+    })
 
-        if (!approvalNeeded) {
-            return {
-                approvalNeeded: false,
-                currentAllowance: allowance
-            }
+    if (allowance >= requiredAmount) {
+        return {
+            approvalNeeded: false,
+            currentAllowance: allowance,
         }
+    }
 
-        console.log(`Approval needed. Current: ${allowance}, Required: ${required}`)
+    const amountToApprove = approvalAmount ?? requiredAmount
 
-        // Determine approval amount
-        const amountToApprove = approvalAmount || required
+    const approvalResult = await approveToken(
+        walletClient,
+        publicClient,
+        tokenAddress,
+        spender,
+        amountToApprove,
 
-        // Execute approval
-        const approvalResult = await approveToken(
-            wallet,
-            tokenAddress,
-            spender,
-            amountToApprove,
-            gasLimit,
-            confirmations
-        )
+        confirmations,
+    )
 
-        return {
-            approvalNeeded: true,
-            currentAllowance: allowance,
-            approvalResult
-        }
-    } catch (error) {
-        console.error('Check and approve failed:', error)
-        throw error
+    return {
+        approvalNeeded: true,
+        currentAllowance: allowance,
+        approvalResult,
     }
 }
 
+
 /**
  * Reset token allowance to zero (security best practice before setting new allowance)
  */
 export const resetAllowance = async (
-    wallet: Wallet,
-    tokenAddress: string,
-    spender: string,
-    gasLimit?: string | bigint,
-    confirmations: number = 1
-): Promise<TransactionResult> => {
-    return await approveToken(wallet, tokenAddress, spender, "0", gasLimit, confirmations)
+    walletClient: WalletClient,
+    publicClient: PublicClient,
+    tokenAddress: `0x${string}`,
+    spender: `0x${string}`,
+    gas?: bigint,
+    confirmations = 1,
+) => {
+    return approveToken(
+        walletClient,
+        publicClient,
+        tokenAddress,
+        spender,
+        0n,
+        confirmations,
+    )
 }
 
+
 /**
  * Safe approve: Reset to zero first, then approve the desired amount
  * (Some tokens like USDT require this)
  */
 export const safeApprove = async (
-    wallet: Wallet,
-    tokenAddress: string,
-    spender: string,
-    amount: string | bigint,
-    gasLimit?: string | bigint,
-    confirmations: number = 1
+    walletClient: WalletClient,
+    publicClient: PublicClient,
+    tokenAddress: `0x${string}`,
+    spender: `0x${string}`,
+    amount: bigint,
+    gas?: bigint,
+    confirmations = 1,
 ): Promise<{
-    resetResult: TransactionResult,
+    resetResult: TransactionResult
     approveResult: TransactionResult
 }> => {
-    try {
-        console.log('Performing safe approve: reset then approve')
+    const resetResult = await resetAllowance(
+        walletClient,
+        publicClient,
+        tokenAddress,
+        spender,
+        gas,
+        confirmations,
+    )
 
-        // First reset to zero
-        const resetResult = await resetAllowance(wallet, tokenAddress, spender, gasLimit, confirmations)
+    if (!resetResult.success) {
+        throw new Error('Failed to reset allowance')
+    }
 
-        if (!resetResult.success) {
-            throw new Error('Failed to reset allowance to zero')
-        }
+    const approveResult = await approveToken(
+        walletClient,
+        publicClient,
+        tokenAddress,
+        spender,
+        amount,
 
-        // Then approve the desired amount
-        const approveResult = await approveToken(wallet, tokenAddress, spender, amount, gasLimit, confirmations)
+        confirmations,
+    )
 
-        return {
-            resetResult,
-            approveResult
-        }
-    } catch (error) {
-        console.error('Safe approve failed:', error)
-        throw error
+    return {
+        resetResult,
+        approveResult,
     }
 }
 
+
 export const discoverTokens = async (wallet: string, chain: ChainWalletConfig): Promise<UserTokenBalance<string>[]> => {
     const balances = await HelperAPI.getUserToken(wallet, chain.vmType ?? "EVM", chain.chainId)
 
@@ -676,287 +732,7 @@ export function calcTokenAmount(value: number | string | BigNumber, decimals?: n
     const divisor = new BigNumber(10).pow(decimals ?? 0);
     return new BigNumber(String(value)).div(divisor);
 }
-//swaps
-
-
-
-//kyber swap here
-//docs -. https://docs.kyberswap.com/kyberswap-solutions/kyberswap-aggregator/developer-guides/execute-a-swap-with-the-aggregator-api
-// the major constrain is that each function should return a transaction to sign, do not sign transaction or send transaction within util functions
-// let the ChainWalletClass be the one to sign and send,
-//so in you chainWallet.swap, you can have the futil swap function to get the transaction then another function to sign and send and confirm the transaction
-
-
-
-export async function getKyberSwapRoute(params: KyberSwapParams): Promise<KyberSwapResponse> {
-    const chainName = KYBER_SUPPORTED_CHAINS[params.chainId];
-    if (!chainName) {
-        throw new Error(`Unsupported chain ID: ${params.chainId}`);
-    }
-
-    const queryParams = new URLSearchParams({
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        amountIn: params.amountIn,
-    });
-
-    if (params.feeAmount) queryParams.append('feeAmount', params.feeAmount);
-    if (params.feeReceiver) queryParams.append('feeReceiver', params.feeReceiver);
-    if (params.isInBps !== undefined) queryParams.append('isInBps', params.isInBps.toString());
-    if (params.chargeFeeBy) queryParams.append('chargeFeeBy', params.chargeFeeBy);
-
-    const url = `${KYBER_BASE_URL}/${chainName}/api/v1/routes?${queryParams}`;
-
-    const headers: { [key: string]: string } = {};
-    if (params.clientId) {
-        headers['x-client-id'] = params.clientId;
-    }
-
-    try {
-        const response = await fetch(url, { headers });
-        const data = await response.json();
-
-        if (!response.ok) {
-            throw new Error(`KyberSwap API error: ${data.message || response.statusText}`);
-        }
-
-        return data;
-    } catch (error) {
-        console.error('Error fetching KyberSwap route:', error);
-        throw error;
-    }
-}
-
-
-export async function buildKyberSwapTransaction(
-    chainId: string,
-    routeSummary: KyberRoute,
-    sender: string,
-    recipient: string,
-    slippageTolerance: number = 50,
-    deadline?: number,
-    clientId?: string
-): Promise<KyberBuildResponse> {
-    const chainName = KYBER_SUPPORTED_CHAINS[chainId];
-    if (!chainName) {
-        throw new Error(`Unsupported chain ID: ${chainId}`);
-    }
-
-    const url = `${KYBER_BASE_URL}/${chainName}/api/v1/route/build`;
-
-    const txDeadline = deadline || Math.floor(Date.now() / 1000) + 1200;
-
-    const body = {
-        routeSummary,
-        sender,
-        recipient,
-        slippageTolerance,
-        deadline: txDeadline,
-        source: clientId || 'MyWalletApp'
-    };
-
-    const headers: { [key: string]: string } = {
-        'Content-Type': 'application/json',
-    };
-
-    if (clientId) {
-        headers['x-client-id'] = clientId;
-    }
 
-    try {
-        const response = await fetch(url, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(body)
-        });
-
-        const data = await response.json();
-
-        if (!response.ok) {
-            throw new Error(`KyberSwap build API error: ${data.message || response.statusText}`);
-        }
-
-        return data;
-    } catch (error) {
-        console.error('Error building KyberSwap transaction:', error);
-        throw error;
-    }
-}
-
-export async function performSwap(params: {
-    chainId: string;
-    tokenIn: string;
-    tokenOut: string;
-    amountIn: string;
-    sender: string;
-    recipient?: string;
-    slippageTolerance?: number;
-    deadline?: number;
-    feeAmount?: string;
-    feeReceiver?: string;
-    isInBps?: boolean;
-    chargeFeeBy?: 'currency_in' | 'currency_out';
-    clientId?: string;
-}): Promise<TransactionParams> {
-    if (!KYBER_SUPPORTED_CHAINS[params.chainId]) {
-        throw new Error(`KyberSwap does not support chain ID: ${params.chainId}`);
-    }
-    try {
-        console.log('Starting KyberSwap aggregation...', {
-            tokenIn: params.tokenIn,
-            tokenOut: params.tokenOut,
-            amountIn: params.amountIn,
-            chainId: params.chainId
-        });
-
-        console.log('Fetching best swap route across all DEXs...');
-
-        const routeResponse = await getKyberSwapRoute({
-            chainId: params.chainId,
-            tokenIn: params.tokenIn,
-            tokenOut: params.tokenOut,
-            amountIn: params.amountIn,
-            feeAmount: params.feeAmount,
-            feeReceiver: params.feeReceiver,
-            isInBps: params.isInBps,
-            chargeFeeBy: params.chargeFeeBy,
-            clientId: params.clientId || 'MyWalletApp'
-        });
-
-        // Debug: Log the full response to understand structure
-        console.log('Full KyberSwap route response:', JSON.stringify(routeResponse, null, 2));
-
-        if (!routeResponse.data || !routeResponse.data.routeSummary) {
-            throw new Error('No valid route found for the swap');
-        }
-
-        const { routeSummary, routerAddress } = routeResponse.data;
-
-        // Debug: Log what we actually received
-        console.log('routeSummary keys:', Object.keys(routeSummary));
-        console.log('routeSummary.swaps exists:', !!routeSummary.swaps);
-
-        // Safe logging that handles undefined swaps
-        console.log('✅ Best route found:', {
-            tokenIn: routeSummary.tokenIn,
-            tokenOut: routeSummary.tokenOut,
-            amountIn: routeSummary.amountIn,
-            amountOut: routeSummary.amountOut,
-            gasEstimate: routeSummary.gas,
-            routerAddress,
-            // Only try to access swaps if it exists
-            swapsCount: routeSummary.swaps ? routeSummary.swaps.length : 0,
-            // Only extract exchange names if swaps exists and has the expected structure
-            dexSources: routeSummary.swaps && Array.isArray(routeSummary.swaps)
-                ? routeSummary.swaps.map(swap => swap?.exchange || 'unknown').filter(Boolean)
-                : ['unknown']
-        });
-
-        console.log('Building executable transaction...');
-
-        const buildResponse = await buildKyberSwapTransaction(
-            params.chainId,
-            routeSummary,
-            params.sender,
-            params.recipient || params.sender,
-            params.slippageTolerance || 50,
-            params.deadline,
-            params.clientId || 'MyWalletApp'
-        );
-
-        // Debug: Log build response
-        console.log('Build response:', JSON.stringify(buildResponse, null, 2));
-
-        if (!buildResponse.data || !buildResponse.data.data) {
-            throw new Error('Failed to build transaction data');
-        }
-
-        const { data: encodedData, gas, routerAddress: finalRouterAddress } = buildResponse.data;
-
-        console.log('✅ Transaction built successfully:', {
-            to: finalRouterAddress,
-            dataLength: encodedData.length,
-            gasEstimate: gas,
-            expectedOutput: buildResponse.data.amountOut
-        });
-
-        return {
-            to: finalRouterAddress,
-            data: encodedData,
-            gasLimit: gas,
-            value: params.tokenIn.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
-                ? params.amountIn
-                : '0'
-        };
-
-    } catch (error) {
-        console.error('❌ KyberSwap aggregation failed:', error);
-
-        // More detailed error logging
-        if (error instanceof Error) {
-            console.error('Error details:', {
-                message: error.message,
-                stack: error.stack,
-                name: error.name
-            });
-        }
-
-        throw new Error(`Swap preparation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-
-export function getKyberSupportedChains(): { [key: string]: string } {
-    return { ...KYBER_SUPPORTED_CHAINS };
-}
-
-export function isChainSupportedByKyber(chainId: string): boolean {
-    return chainId in KYBER_SUPPORTED_CHAINS;
-}
-
-export function isChainSupportedByDebonk(chainId: string): boolean {
-    return chainId in DESERIALIZED_SUPPORTED_CHAINS;
-}
-
-export function getNativeTokenAddress(): string {
-    return '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
-}
-
-export function formatAmountToWei(amount: string, decimals: number): string {
-    return parseUnits(amount, decimals).toString();
-}
-export function formatAmountFromWei(amountWei: string, decimals: number): string {
-    return formatUnits(amountWei, decimals);
-}
-
-export function prepareSwapParams(
-    tokenIn: string,
-    tokenOut: string,
-    amountIn: string,
-    tokenInDecimals: number,
-    isNativeIn: boolean = false,
-    isNativeOut: boolean = false
-): {
-    tokenInAddress: string;
-    tokenOutAddress: string;
-    formattedAmountIn: string;
-} {
-    const tokenInAddress = isNativeIn ? getNativeTokenAddress() : tokenIn;
-    const tokenOutAddress = isNativeOut ? getNativeTokenAddress() : tokenOut;
-
-    const formattedAmountIn = amountIn.includes('.')
-        ? formatAmountToWei(amountIn, tokenInDecimals)
-        : amountIn;
-
-    return {
-        tokenInAddress,
-        tokenOutAddress,
-        formattedAmountIn
-    };
-}
-
-export function convertSlippageForDebonk(slippageBps: number): number {
-    return slippageBps / 100;
-}
 
 export const transformEVMNFTToUnified = (nft: EVMNFT): NFT => {
     // Extract image URL from various sources