@deserialize/multi-vm-wallet 1.2.441 → 1.3.0

package/utils/evm/smartWallet.types.ts

@@ -0,0 +1,33 @@
+/**
+ * Smart Wallet Types (Re-exports from aa-service)
+ *
+ * This file re-exports types from the AA service for backwards compatibility
+ * and cleaner imports in smartWallet.ts
+ */
+
+export type {
+    SmartWalletOptions,
+    SmartWalletTransactionResult,
+    Call,
+    SessionKeyApprovalOptions,
+    SessionKeyUsageOptions,
+    ModuleInstallOptions,
+    ModuleUninstallOptions,
+    MultiSigConfig,
+    RecoveryConfig,
+    PaymasterConfig,
+    SmartAccountInfo,
+    EntryPointVersion,
+    KernelVersion
+} from './aa-service/lib/type';
+
+// Export error classes (not as types, as actual classes)
+export {
+    SmartWalletError,
+    SessionKeyError,
+    ModuleError,
+    TransactionError
+} from './aa-service/lib/type';
+
+export type { ModuleType } from './aa-service/lib/kernel-modules';
+export type { SessionKeyPermissionRule, SessionKeyInfo } from './aa-service/lib/session-keys';

package/utils/evm/transaction.utils.ts

@@ -477,18 +477,22 @@ export async function getTokenStandard(
 ): Promise<TokenStandard> {
     // Try ERC165 supportsInterface for ERC721/ERC1155
     try {
-        const contract = getContract({
+        // Check ERC721
+        const isERC721 = await client.readContract({
             address,
             abi: parseAbi(['function supportsInterface(bytes4) view returns (bool)']),
-            client,
+            functionName: 'supportsInterface',
+            args: [INTERFACE_IDS.ERC721 as Hex],
         });
-
-        // Check ERC721
-        const isERC721 = await contract.read.supportsInterface([INTERFACE_IDS.ERC721 as Hex]);
         if (isERC721) return TokenStandard.ERC721;
 
         // Check ERC1155
-        const isERC1155 = await contract.read.supportsInterface([INTERFACE_IDS.ERC1155 as Hex]);
+        const isERC1155 = await client.readContract({
+            address,
+            abi: parseAbi(['function supportsInterface(bytes4) view returns (bool)']),
+            functionName: 'supportsInterface',
+            args: [INTERFACE_IDS.ERC1155 as Hex],
+        });
         if (isERC1155) return TokenStandard.ERC1155;
     } catch {
         // Not ERC721/ERC1155, try ERC20
@@ -496,13 +500,11 @@ export async function getTokenStandard(
 
     // Try ERC20 by checking for decimals function
     try {
-        const contract = getContract({
+        await client.readContract({
             address,
             abi: parseAbi(['function decimals() view returns (uint8)']),
-            client,
+            functionName: 'decimals',
         });
-
-        await contract.read.decimals();
         return TokenStandard.ERC20;
     } catch {
         // Not a recognized token standard

package/utils/evm/transactionParsing.ts

@@ -12,7 +12,27 @@ import {
     parseAbi
 } from 'viem';
 import { TRANSACTION_TYPE, TransactionType } from '../constant';
-import { HelperAPI } from '../helpers';
+import { HelperAPI, RouteScanAPI } from '../helpers';
+
+// Mapping of chainId to RouteScan network name
+const CHAIN_ID_TO_NETWORK: Record<number, string> = {
+    1: 'mainnet',           // Ethereum Mainnet
+    5: 'testnet',           // Goerli
+    11155111: 'testnet',    // Sepolia
+    137: 'mainnet',         // Polygon
+    80001: 'testnet',       // Polygon Mumbai
+    56: 'mainnet',          // BSC
+    97: 'testnet',          // BSC Testnet
+    43114: 'mainnet',       // Avalanche
+    43113: 'testnet',       // Avalanche Fuji
+    42161: 'mainnet',       // Arbitrum
+    421611: 'testnet',      // Arbitrum Testnet
+    10: 'mainnet',          // Optimism
+    420: 'testnet',         // Optimism Goerli
+    8453: 'mainnet',        // Base
+    84531: 'testnet',       // Base Goerli
+    16661: 'mainnet',       // 0G Newton Testnet (using mainnet for simplicity)
+};
 
 export interface EVMTransactionHistoryItem {
     hash: string;
@@ -153,7 +173,72 @@ export async function getEVMTransactionHistory(
     // }
     if (client.chain?.id === undefined) throw new Error("Chain Id is Undefined")
 
-    return await HelperAPI.getTransactionHistory(walletAddress, "EVM", client.chain?.id)
+    const chainId = client.chain.id;
+    const network = CHAIN_ID_TO_NETWORK[chainId];
+
+    // Try RouteScan first if network mapping exists
+    if (network) {
+        try {
+            console.log(`Fetching transaction history from RouteScan for chain ${chainId} (${network})`);
+            const routeScanResponse = await RouteScanAPI.getTxList(
+                network,
+                chainId,
+                walletAddress,
+                0,
+                99999999,
+                1,
+                20, // limit to 20 recent transactions
+                'desc' // newest first
+            );
+
+            if (routeScanResponse.status === '1' && routeScanResponse.result) {
+                console.log(`RouteScan returned ${routeScanResponse.result.length} transactions`);
+                // Convert RouteScan format to our EVMTransactionHistoryItem format
+                return routeScanResponse.result.map(tx => ({
+                    hash: tx.hash,
+                    timestamp: parseInt(tx.timeStamp),
+                    status: tx.txreceipt_status === '1' ? 'success' as const : 'failed' as const,
+                    fee: formatEther(BigInt(tx.gasUsed) * BigInt(tx.gasPrice)),
+                    type: determineTransactionTypeFromInput(tx.input, tx.value),
+                    from: tx.from,
+                    to: tx.to || null,
+                    blockNumber: BigInt(tx.blockNumber),
+                    gasUsed: BigInt(tx.gasUsed),
+                    gasPrice: formatUnits(BigInt(tx.gasPrice), 9), // gwei
+                    value: formatEther(BigInt(tx.value)),
+                    method: tx.methodId || undefined,
+                    // Token and NFT transfers would need additional API calls
+                    // We'll skip them for now to keep it simple
+                }));
+            }
+        } catch (error) {
+            console.warn('RouteScan failed, falling back to HelperAPI:', error);
+        }
+    }
+
+    // Fallback to HelperAPI
+    console.log(`Fetching transaction history from HelperAPI for chain ${chainId}`);
+    return await HelperAPI.getTransactionHistory(walletAddress, "EVM", chainId);
+}
+
+/**
+ * Determine transaction type from input data and value (simpler version for RouteScan data)
+ */
+function determineTransactionTypeFromInput(input: string, value: string): TransactionType {
+    if (input === '0x' || input === '') {
+        return BigInt(value) > 0n ? TRANSACTION_TYPE.NATIVE_TRANSFER : TRANSACTION_TYPE.CONTRACT_INTERACTION;
+    }
+
+    const methodSig = input.slice(0, 10);
+
+    if (methodSig === '0xa9059cbb') return TRANSACTION_TYPE.TOKEN_TRANSFER; // ERC20 transfer
+    if (methodSig === '0x23b872dd') return TRANSACTION_TYPE.TOKEN_TRANSFER; // ERC20 transferFrom
+    if (methodSig === '0x42842e0e') return TRANSACTION_TYPE.NFT_TRANSFER; // ERC721 safeTransferFrom
+    if (methodSig === '0xf242432a') return TRANSACTION_TYPE.NFT_TRANSFER; // ERC1155 safeTransferFrom
+
+    if (BigInt(value) > 0n) return TRANSACTION_TYPE.NATIVE_TRANSFER;
+
+    return TRANSACTION_TYPE.CONTRACT_INTERACTION;
 }
 
 /**
@@ -492,9 +577,9 @@ function determineTransactionType(tx: Transaction, receipt: TransactionReceipt):
     if (tx.value && tx.value > 0n) return TRANSACTION_TYPE.NATIVE_TRANSFER;
 
     // Check logs for common patterns
-    if (receipt.logs.some(log => log.topics[0]?.includes('Swap'))) return TRANSACTION_TYPE.SWAP;
-    if (receipt.logs.some(log => log.topics[0]?.includes('Deposit'))) return TRANSACTION_TYPE.DEPOSIT;
-    if (receipt.logs.some(log => log.topics[0]?.includes('Withdraw'))) return TRANSACTION_TYPE.WITHDRAWAL;
+    if (receipt.logs.some(log => (log as any).topics[0]?.includes('Swap'))) return TRANSACTION_TYPE.SWAP;
+    if (receipt.logs.some(log => (log as any).topics[0]?.includes('Deposit'))) return TRANSACTION_TYPE.DEPOSIT;
+    if (receipt.logs.some(log => (log as any).topics[0]?.includes('Withdraw'))) return TRANSACTION_TYPE.WITHDRAWAL;
 
     return TRANSACTION_TYPE.CONTRACT_INTERACTION;
 }
@@ -515,13 +600,13 @@ async function parseTransferLogs(
     for (const log of logs) {
         try {
             // Try ERC20 Transfer
-            if (includeTokenTransfers && log.topics.length === 3) {
+            if (includeTokenTransfers && (log as any).topics.length === 3) {
                 try {
                     const decoded = decodeEventLog({
                         abi: ERC20_TRANSFER_EVENT,
                         data: log.data,
-                        topics: log.topics,
-                    });
+                        topics: (log as any).topics,
+                    }) as any
 
                     if (decoded.eventName === 'Transfer') {
                         const { from, to, value } = decoded.args as any;
@@ -537,7 +622,8 @@ async function parseTransferLogs(
                                     address: log.address,
                                     abi: parseAbi(['function decimals() view returns (uint8)']),
                                     functionName: 'decimals',
-                                }) as number;
+                                    authorizationList: undefined
+                                })
                             } catch { }
 
                             tokens.push({
@@ -554,13 +640,13 @@ async function parseTransferLogs(
             }
 
             // Try ERC721 Transfer (has indexed tokenId)
-            if (includeNFTTransfers && log.topics.length === 4) {
+            if (includeNFTTransfers && (log as any).topics.length === 4) {
                 try {
                     const decoded = decodeEventLog({
                         abi: ERC721_TRANSFER_EVENT,
                         data: log.data,
-                        topics: log.topics,
-                    });
+                        topics: (log as any).topics,
+                    }) as any
 
                     if (decoded.eventName === 'Transfer') {
                         const { from, to, tokenId } = decoded.args as any;
@@ -585,8 +671,8 @@ async function parseTransferLogs(
                     const decoded = decodeEventLog({
                         abi: ERC1155_TRANSFER_SINGLE_EVENT,
                         data: log.data,
-                        topics: log.topics,
-                    });
+                        topics: (log as any).topics,
+                    }) as any
 
                     if (decoded.eventName === 'TransferSingle') {
                         const { from, to, id, value } = decoded.args as any;

package/utils/helpers/index.ts

@@ -1,3 +1,4 @@
+export * from './routeScan';
 import { vmTypes, EVMNFTResponse } from "../types";
 
 const BASE_URL = "https://helper.decane.app"

package/utils/helpers/routeScan.ts

@@ -0,0 +1,397 @@
+export interface RouteScanTx {
+    blockNumber: string;
+    blockHash: string;
+    timeStamp: string;
+    hash: string;
+    nonce: string;
+    transactionIndex: string;
+    from: string;
+    to: string;
+    value: string;
+    gas: string;
+    gasPrice: string;
+    input: string;
+    methodId: string;
+    functionName: string;
+    contractAddress: string;
+    cumulativeGasUsed: string;
+    txreceipt_status: string;
+    gasUsed: string;
+    confirmations: string;
+    isError: string;
+}
+
+export interface RouteScanBalanceMultiResult {
+    account: string;
+    balance: string;
+}
+
+export interface RouteScanTokenTx {
+    blockNumber: string;
+    timeStamp: string;
+    hash: string;
+    nonce: string;
+    blockHash: string;
+    from: string;
+    contractAddress: string;
+    to: string;
+    value: string;
+    tokenName: string;
+    tokenSymbol: string;
+    tokenDecimal: string;
+    transactionIndex: string;
+    gas: string;
+    gasPrice: string;
+    gasUsed: string;
+    cumulativeGasUsed: string;
+    input: string;
+    confirmations: string;
+}
+
+export interface RouteScanInternalTx {
+    blockNumber: string;
+    timeStamp: string;
+    hash: string;
+    from: string;
+    to: string;
+    value: string;
+    contractAddress: string;
+    input: string;
+    type: string;
+    gas: string;
+    gasUsed: string;
+    isError: string;
+    errCode: string;
+}
+
+export interface RouteScanNftTx {
+    blockNumber: string;
+    timeStamp: string;
+    hash: string;
+    nonce: string;
+    blockHash: string;
+    from: string;
+    contractAddress: string;
+    to: string;
+    tokenID: string;
+    tokenName: string;
+    tokenSymbol: string;
+    tokenDecimal: string;
+    transactionIndex: string;
+    gas: string;
+    gasPrice: string;
+    gasUsed: string;
+    cumulativeGasUsed: string;
+    input: string;
+    confirmations: string;
+}
+
+export interface RouteScanSourceCodeResult {
+    SourceCode: string;
+    ABI: string;
+    ContractName: string;
+    CompilerVersion: string;
+    OptimizationUsed: string;
+    Runs: string;
+    ConstructorArguments: string;
+    EVMVersion: string;
+    Library: string;
+    LicenseType: string;
+    Proxy: string;
+    Implementation: string;
+    SwarmSource: string;
+}
+
+export interface RouteScanTxReceiptStatus {
+    status: string;
+}
+
+export interface RouteScanBlockReward {
+    blockNumber: string;
+    timeStamp: string;
+    blockMiner: string;
+    blockReward: string;
+    uncles: {
+        miner: string;
+        unclePosition: string;
+        blockreward: string;
+    }[];
+    uncleInclusionReward: string;
+}
+
+export interface RouteScanBlockCountdown {
+    CurrentBlock: string;
+    CountdownBlock: string;
+    RemainingBlock: string;
+    EstimateTimeInSec: string;
+}
+
+export interface RouteScanLog {
+    address: string;
+    topics: string[];
+    data: string;
+    blockNumber: string;
+    timeStamp: string;
+    gasPrice: string;
+    gasUsed: string;
+    logIndex: string;
+    transactionHash: string;
+    transactionIndex: string;
+}
+
+export interface RouteScanProxyTx {
+    blockHash: string;
+    blockNumber: string;
+    from: string;
+    gas: string;
+    gasPrice: string;
+    hash: string;
+    input: string;
+    nonce: string;
+    to: string;
+    transactionIndex: string;
+    value: string;
+    v: string;
+    r: string;
+    s: string;
+}
+
+export interface RouteScanProxyBlock {
+    number: string;
+    hash: string;
+    parentHash: string;
+    nonce: string;
+    sha3Uncles: string;
+    logsBloom: string;
+    transactionsRoot: string;
+    stateRoot: string;
+    miner: string;
+    difficulty: string;
+    totalDifficulty: string;
+    extraData: string;
+    size: string;
+    gasLimit: string;
+    gasUsed: string;
+    timestamp: string;
+    transactions: RouteScanProxyTx[] | string[];
+    uncles: string[];
+}
+
+export interface RouteScanResponse<T> {
+    status: string;
+    message: string;
+    result: T;
+}
+const BASE_URL = "https://api.routescan.io/v2/network";
+type Sort = "asc" | "desc";
+
+export class RouteScanAPI {
+    static async getTxList(
+        network: string,
+        chainId: number,
+        address: string,
+        startblock: number = 0,
+        endblock: number = 99999999,
+        page: number = 1,
+        offset: number = 10,
+        sort: Sort = "asc"
+    ): Promise<RouteScanResponse<RouteScanTx[]>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=account&action=txlist&address=${address}&startblock=${startblock}&endblock=${endblock}&page=${page}&offset=${offset}&sort=${sort}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanTx[]>;
+        return data;
+    }
+
+    static async getBalance(
+        network: string,
+        chainId: number,
+        address: string
+    ): Promise<RouteScanResponse<string>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=account&action=balance&address=${address}&tag=latest`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<string>;
+        return data;
+    }
+
+    static async getBalanceMulti(
+        network: string,
+        chainId: number,
+        addresses: string[]
+    ): Promise<RouteScanResponse<RouteScanBalanceMultiResult[]>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=account&action=balancemulti&address=${addresses.join(',')}&tag=latest`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanBalanceMultiResult[]>;
+        return data;
+    }
+
+    static async getTokenTransfers(
+        network: string,
+        chainId: number,
+        address: string,
+        contractaddress?: string,
+        startblock: number = 0,
+        endblock: number = 99999999,
+        page: number = 1,
+        offset: number = 10,
+        sort: Sort = "asc"
+    ): Promise<RouteScanResponse<RouteScanTokenTx[]>> {
+        let url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=account&action=tokentx&address=${address}&startblock=${startblock}&endblock=${endblock}&page=${page}&offset=${offset}&sort=${sort}`;
+        if (contractaddress) {
+            url += `&contractaddress=${contractaddress}`;
+        }
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanTokenTx[]>;
+        return data;
+    }
+
+    static async getInternalTxListByAddress(
+        network: string,
+        chainId: number,
+        address: string,
+        startblock: number = 0,
+        endblock: number = 99999999,
+        page: number = 1,
+        offset: number = 10,
+        sort: Sort = "asc"
+    ): Promise<RouteScanResponse<RouteScanInternalTx[]>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=account&action=txlistinternal&address=${address}&startblock=${startblock}&endblock=${endblock}&page=${page}&offset=${offset}&sort=${sort}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanInternalTx[]>;
+        return data;
+    }
+
+    static async getNftTransfers(
+        network: string,
+        chainId: number,
+        address: string,
+        contractaddress?: string,
+        startblock: number = 0,
+        endblock: number = 99999999,
+        page: number = 1,
+        offset: number = 10,
+        sort: Sort = "asc"
+    ): Promise<RouteScanResponse<RouteScanNftTx[]>> {
+        let url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=account&action=tokennfttx&address=${address}&startblock=${startblock}&endblock=${endblock}&page=${page}&offset=${offset}&sort=${sort}`;
+        if (contractaddress) {
+            url += `&contractaddress=${contractaddress}`;
+        }
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanNftTx[]>;
+        return data;
+    }
+
+    static async getBalanceHistory(
+        network: string,
+        chainId: number,
+        address: string,
+        blockno: number
+    ): Promise<RouteScanResponse<string>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=account&action=balancehistory&address=${address}&blockno=${blockno}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<string>;
+        return data;
+    }
+
+    static async getAbi(
+        network: string,
+        chainId: number,
+        address: string
+    ): Promise<RouteScanResponse<string>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=contract&action=getabi&address=${address}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<string>;
+        return data;
+    }
+
+    static async getSourceCode(
+        network: string,
+        chainId: number,
+        address: string
+    ): Promise<RouteScanResponse<RouteScanSourceCodeResult[]>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=contract&action=getsourcecode&address=${address}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanSourceCodeResult[]>;
+        return data;
+    }
+
+    static async getTxReceiptStatus(
+        network: string,
+        chainId: number,
+        txhash: string
+    ): Promise<RouteScanResponse<RouteScanTxReceiptStatus>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=transaction&action=gettxreceiptstatus&txhash=${txhash}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanTxReceiptStatus>;
+        return data;
+    }
+
+    static async getBlockReward(
+        network: string,
+        chainId: number,
+        blockno: number
+    ): Promise<RouteScanResponse<RouteScanBlockReward>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=block&action=getblockreward&blockno=${blockno}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanBlockReward>;
+        return data;
+    }
+
+    static async getBlockCountdown(
+        network: string,
+        chainId: number,
+        blockno: number
+    ): Promise<RouteScanResponse<RouteScanBlockCountdown>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=block&action=getblockcountdown&blockno=${blockno}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanBlockCountdown>;
+        return data;
+    }
+
+    static async getLogs(
+        network: string,
+        chainId: number,
+        fromBlock: number | 'latest',
+        toBlock: number | 'latest',
+        address?: string,
+        topics?: (string | null)[],
+        page: number = 1,
+        offset: number = 1000
+    ): Promise<RouteScanResponse<RouteScanLog[]>> {
+        let url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=logs&action=getLogs&fromBlock=${fromBlock}&toBlock=${toBlock}&page=${page}&offset=${offset}`;
+        if (address) {
+            url += `&address=${address}`;
+        }
+        if (topics) {
+            for (let i = 0; i < topics.length; i++) {
+                if (topics[i]) {
+                    url += `&topic${i}=${topics[i]}`;
+                }
+            }
+        }
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanLog[]>;
+        return data;
+    }
+
+    static async ethBlockNumber(
+        network: string,
+        chainId: number
+    ): Promise<RouteScanResponse<string>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=proxy&action=eth_blockNumber`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<string>;
+        return data;
+    }
+
+    static async ethGetBlockByNumber(
+        network: string,
+        chainId: number,
+        blockNumber: string,
+        fullTransactions: boolean = false
+    ): Promise<RouteScanResponse<RouteScanProxyBlock>> {
+        const url = `${BASE_URL}/${network}/evm/${chainId}/etherscan/api?module=proxy&action=eth_getBlockByNumber&tag=${blockNumber}&boolean=${fullTransactions}`;
+        const res = await fetch(url);
+        const data = await res.json() as RouteScanResponse<RouteScanProxyBlock>;
+        return data;
+    }
+}

package/utils/index.ts

@@ -1,10 +1,8 @@
 export * from "./walletBip32"
-export * from "./evm/evm"
 export * from "./types"
 export * from "./vm"
 export * from "./evm"
 export * from "./svm"
-export * from "./types"
 export * from "./constant"
 export * from "bs58"
 export * from "@solana/web3.js"