@deserialize/multi-vm-wallet 1.2.10 → 1.2.21

package/utils/evm/transactionParsing.ts

@@ -0,0 +1,639 @@
+import {
+    createPublicClient,
+    http,
+    type PublicClient,
+    type Address,
+    type Hash,
+    type Transaction,
+    type TransactionReceipt,
+    formatEther,
+    formatUnits,
+    decodeEventLog,
+    parseAbi
+} from 'viem';
+import { TRANSACTION_TYPE, TransactionType } from '../constant';
+
+export interface EVMTransactionHistoryItem {
+    hash: string;
+    timestamp: number | null;
+    status: 'success' | 'failed' | 'pending';
+    fee: string; // in ETH
+    type: TransactionType;
+    from: string;
+    to: string | null;
+
+
+
+    blockNumber: bigint;
+    gasUsed: bigint;
+    gasPrice: string; // in gwei
+    value: string; // in ETH
+    method?: string;
+    tokenTransfers?: TokenTransfer[];
+    nftTransfers?: NFTTransfer[];
+}
+
+export interface TokenTransfer {
+    type: 'ERC20';
+    from: string;
+    to: string;
+    amount: string;
+    tokenAddress: string;
+    tokenSymbol?: string;
+    tokenDecimals?: number;
+}
+
+export interface NFTTransfer {
+    type: 'ERC721' | 'ERC1155';
+    from: string;
+    to: string;
+    tokenId: string;
+    amount?: string; // for ERC1155
+    tokenAddress: string;
+    collectionName?: string;
+}
+
+export interface TransactionHistoryOptions {
+    startBlock?: bigint;
+    endBlock?: bigint;
+    includeTokenTransfers?: boolean;
+    includeNFTTransfers?: boolean;
+}
+
+// ERC20 Transfer event signature
+const ERC20_TRANSFER_EVENT = parseAbi([
+    'event Transfer(address indexed from, address indexed to, uint256 value)'
+]);
+
+// ERC721 Transfer event signature
+const ERC721_TRANSFER_EVENT = parseAbi([
+    'event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)'
+]);
+
+// ERC1155 TransferSingle event signature
+const ERC1155_TRANSFER_SINGLE_EVENT = parseAbi([
+    'event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value)'
+]);
+
+// ERC1155 TransferBatch event signature
+const ERC1155_TRANSFER_BATCH_EVENT = parseAbi([
+    'event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values)'
+]);
+
+/**
+ * Fetches and parses transaction history for an EVM wallet address
+ * @param client - Viem public client
+ * @param walletAddress - Ethereum address
+ * @param options - Optional parameters for filtering and features
+ * @returns Array of parsed transaction history items
+ */
+export async function getEVMTransactionHistory(
+    client: PublicClient,
+    walletAddress: Address,
+    options: TransactionHistoryOptions = {}
+): Promise<EVMTransactionHistoryItem[]> {
+    const {
+        startBlock = 0n,
+        endBlock,
+        includeTokenTransfers = true,
+        includeNFTTransfers = true,
+    } = options;
+
+    try {
+        const currentBlock = await client.getBlockNumber();
+        const toBlock = endBlock || currentBlock;
+
+        // For wallet UI, we typically want recent transactions
+        // Start scanning from current block backwards
+        const scanStartBlock = startBlock > 0n ? startBlock : (currentBlock > 5000n ? currentBlock - 5000n : 0n);
+
+        console.log(`Fetching recent transactions from block ${scanStartBlock} to ${toBlock}`);
+
+        // Get transaction hashes for the address (max 15 transactions)
+        const txHashes = await getRecentTransactionHashes(
+            client,
+            walletAddress,
+            scanStartBlock,
+            toBlock,
+            15 // max transactions to fetch
+        );
+
+        console.log(`Found ${txHashes.length} unique transactions`);
+
+        // Fetch full transaction details in batches
+        const transactions = await fetchTransactionsInBatches(client, txHashes, 10);
+
+        // Parse each transaction
+        const history: EVMTransactionHistoryItem[] = [];
+
+        for (const { tx, receipt, block } of transactions) {
+            if (!tx || !receipt) continue;
+
+            const parsed = await parseEVMTransaction(
+                client,
+                tx,
+                receipt,
+                block?.timestamp || null,
+                walletAddress,
+                includeTokenTransfers,
+                includeNFTTransfers
+            );
+
+            history.push(parsed);
+        }
+
+        // Sort by block number (newest first)
+        history.sort((a, b) => Number(b.blockNumber - a.blockNumber));
+
+        return history;
+    } catch (error) {
+        console.error('Error fetching EVM transaction history:', error);
+        throw error;
+    }
+}
+
+/**
+ * Gets recent transaction hashes by scanning blocks backwards
+ * Uses batched parallel requests for better performance
+ */
+async function getRecentTransactionHashes(
+    client: PublicClient,
+    address: Address,
+    startBlock: bigint,
+    endBlock: bigint,
+    maxTransactions: number = 15,
+    batchSize: number = 9
+): Promise<Hash[]> {
+    const txHashes: Hash[] = [];
+    const seenHashes = new Map<Hash, boolean>();
+    const addressLower = address.toLowerCase();
+    let currentBlock = endBlock;
+    let blocksScanned = 0n;
+
+    console.log(`Scanning blocks backwards from ${endBlock}...`);
+
+    // Iterate backwards in batches
+    while (currentBlock >= startBlock && txHashes.length < maxTransactions) {
+        // Create batch of block numbers to fetch
+        const blockNumbers: bigint[] = [];
+        for (let i = 0; i < batchSize && currentBlock >= startBlock; i++) {
+            blockNumbers.push(currentBlock);
+            currentBlock--;
+        }
+
+        try {
+            // Fetch all blocks in parallel
+            const blocks = await Promise.all(
+                blockNumbers.map(blockNumber =>
+                    client.getBlock({
+                        blockNumber,
+                        includeTransactions: true,
+                    }).catch(error => {
+                        console.error(`Error fetching block ${blockNumber}:`, error);
+                        return null;
+                    })
+                )
+            );
+            blocks.length
+            console.log('blocks.length: ', blocks.length);
+            // Process blocks in order (newest to oldest)
+            for (const block of blocks) {
+                if (!block || !block.transactions) continue;
+
+                for (let i = 0; i < block.transactions.length && txHashes.length < maxTransactions; i++) {
+                    const tx = block.transactions[i];
+
+                    if (typeof tx === 'object') {
+                        // Check if wallet is sender or receiver
+                        const isSender = tx.from.toLowerCase() === addressLower;
+                        const isReceiver = tx.to?.toLowerCase() === addressLower;
+
+                        if ((isSender || isReceiver) && !seenHashes.has(tx.hash)) {
+                            seenHashes.set(tx.hash, true);
+                            txHashes.push(tx.hash);
+                        }
+                    } else {
+                        console.log("Transaction is not an object: ", tx);
+                    }
+                }
+
+                // Early exit if we found enough transactions
+                if (txHashes.length >= maxTransactions) break;
+            }
+
+            blocksScanned += BigInt(blockNumbers.length);
+
+            // Log progress
+            if (blocksScanned % 50n === 0n || blocksScanned < 50n) {
+                console.log(`Scanned ${blocksScanned} blocks, found ${txHashes.length} transactions`);
+            }
+
+        } catch (error) {
+            console.error(`Error fetching block batch:`, error);
+            continue;
+        }
+    }
+
+    console.log(`Found ${txHashes.length} transactions after scanning ${blocksScanned} blocks`);
+    return txHashes;
+}
+
+/**
+ * Alternative function that uses Etherscan-like API
+ * This is the recommended approach for production use
+ */
+export async function getEVMTransactionHistoryWithAPI(
+    client: PublicClient,
+    walletAddress: Address,
+    apiEndpoint: string,
+    apiKey: string,
+    options: TransactionHistoryOptions = {}
+): Promise<EVMTransactionHistoryItem[]> {
+    const { includeTokenTransfers = true, includeNFTTransfers = true } = options;
+
+    try {
+        // Fetch normal transactions
+        const normalTxResponse = await fetch(
+            `${apiEndpoint}?module=account&action=txlist&address=${walletAddress}&startblock=0&endblock=99999999&sort=desc&apikey=${apiKey}`
+        );
+        const normalTxData = await normalTxResponse.json();
+
+        const history: EVMTransactionHistoryItem[] = [];
+
+        if (normalTxData.status === '1' && normalTxData.result) {
+            for (const tx of normalTxData.result.slice(0, 50)) { // Limit to 50 most recent
+                const receipt = await client.getTransactionReceipt({ hash: tx.hash as Hash });
+
+                const parsed = await parseEVMTransaction(
+                    client,
+                    {
+                        hash: tx.hash as Hash,
+                        from: tx.from as Address,
+                        to: tx.to as Address | null,
+                        value: BigInt(tx.value),
+                        blockNumber: BigInt(tx.blockNumber),
+                        input: tx.input as Hash,
+                        nonce: parseInt(tx.nonce),
+                        gas: BigInt(tx.gas),
+                        gasPrice: tx.gasPrice ? BigInt(tx.gasPrice) : undefined,
+                    } as Transaction,
+                    receipt,
+                    BigInt(tx.timeStamp),
+                    walletAddress,
+                    includeTokenTransfers,
+                    includeNFTTransfers
+                );
+
+                history.push(parsed);
+            }
+        }
+
+        return history;
+    } catch (error) {
+        console.error('Error fetching EVM transaction history with API:', error);
+        throw error;
+    }
+}
+
+/**
+ * Fetches transaction hashes for an address by iterating through blocks
+ * Efficient for recent transactions (last 10-15 txs)
+ */
+async function getTransactionHashesByAddress(
+    client: PublicClient,
+    address: Address,
+    startBlock: bigint,
+    endBlock: bigint,
+    direction: 'from' | 'to',
+    maxTransactions: number = 15
+): Promise<Hash[]> {
+    const txHashes: Hash[] = [];
+    const addressLower = address.toLowerCase();
+    let currentBlock = endBlock;
+
+    console.log(`Scanning blocks backwards from ${endBlock} to ${startBlock}...`);
+
+    // Iterate backwards from most recent block
+    while (currentBlock >= startBlock && txHashes.length < maxTransactions) {
+        try {
+            const block = await client.getBlock({
+                blockNumber: currentBlock,
+                includeTransactions: true,
+            });
+
+            if (block.transactions) {
+                for (const tx of block.transactions) {
+                    // Check if transaction matches the direction filter
+                    if (typeof tx === 'object') {
+                        const matchesDirection =
+                            (direction === 'from' && tx.from.toLowerCase() === addressLower) ||
+                            (direction === 'to' && tx.to?.toLowerCase() === addressLower) ||
+                            (direction === 'from' && tx.from.toLowerCase() === addressLower) ||
+                            (direction === 'to' && tx.to?.toLowerCase() === addressLower);
+
+                        if (matchesDirection) {
+                            txHashes.push(tx.hash);
+
+                            // Stop if we've found enough transactions
+                            if (txHashes.length >= maxTransactions) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            currentBlock--;
+
+            // Log progress every 100 blocks
+            if ((endBlock - currentBlock) % 100n === 0n) {
+                console.log(`Scanned ${endBlock - currentBlock} blocks, found ${txHashes.length} transactions`);
+            }
+
+        } catch (error) {
+            console.error(`Error fetching block ${currentBlock}:`, error);
+            currentBlock--;
+            continue;
+        }
+    }
+
+    console.log(`Found ${txHashes.length} transactions after scanning ${endBlock - currentBlock} blocks`);
+    return txHashes;
+}
+
+/**
+ * Fetches full transaction details in batches
+ */
+async function fetchTransactionsInBatches(
+    client: PublicClient,
+    hashes: Hash[],
+    batchSize: number
+): Promise<Array<{
+    tx: Transaction | null;
+    receipt: TransactionReceipt | null;
+    block: { timestamp: bigint } | null;
+}>> {
+    const results = [];
+
+    for (let i = 0; i < hashes.length; i += batchSize) {
+        const batch = hashes.slice(i, i + batchSize);
+
+        const batchResults = await Promise.all(
+            batch.map(async (hash) => {
+                try {
+                    const [tx, receipt] = await Promise.all([
+                        client.getTransaction({ hash }),
+                        client.getTransactionReceipt({ hash }),
+                    ]);
+
+                    let block = null;
+                    if (tx?.blockNumber) {
+                        block = await client.getBlock({ blockNumber: tx.blockNumber });
+                    }
+
+                    return { tx, receipt, block };
+                } catch (error) {
+                    console.error(`Error fetching transaction ${hash}:`, error);
+                    return { tx: null, receipt: null, block: null };
+                }
+            })
+        );
+
+        results.push(...batchResults);
+
+        // Small delay to avoid rate limiting
+        if (i + batchSize < hashes.length) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+
+    return results;
+}
+
+/**
+ * Parses a single EVM transaction
+ */
+async function parseEVMTransaction(
+    client: PublicClient,
+    tx: Transaction,
+    receipt: TransactionReceipt,
+    timestamp: bigint | null,
+    walletAddress: Address,
+    includeTokenTransfers: boolean,
+    includeNFTTransfers: boolean
+): Promise<EVMTransactionHistoryItem> {
+    const gasUsed = receipt.gasUsed;
+    const effectiveGasPrice = receipt.effectiveGasPrice || tx.gasPrice || 0n;
+    const fee = formatEther(gasUsed * effectiveGasPrice);
+    const gasPrice = formatUnits(effectiveGasPrice, 9); // gwei
+
+    // Determine transaction type
+    const type = determineTransactionType(tx, receipt);
+
+    // Extract method signature
+    const method = tx.input && tx.input.length >= 10
+        ? tx.input.slice(0, 10)
+        : undefined;
+
+    // Parse token transfers from logs
+    let tokenTransfers: TokenTransfer[] = [];
+    let nftTransfers: NFTTransfer[] = [];
+
+    if (includeTokenTransfers || includeNFTTransfers) {
+        const transfers = await parseTransferLogs(
+            client,
+            receipt.logs,
+            walletAddress,
+            includeTokenTransfers,
+            includeNFTTransfers
+        );
+        tokenTransfers = transfers.tokens;
+        nftTransfers = transfers.nfts;
+    }
+
+    return {
+        hash: tx.hash,
+        timestamp: timestamp ? Number(timestamp) : null,
+        blockNumber: tx.blockNumber || 0n,
+        status: receipt.status === 'success' ? 'success' : 'failed',
+        fee,
+        gasUsed,
+        gasPrice,
+        type,
+        from: tx.from,
+        to: tx.to || null,
+        value: formatEther(tx.value || 0n),
+        method,
+        tokenTransfers: tokenTransfers.length > 0 ? tokenTransfers : undefined,
+        nftTransfers: nftTransfers.length > 0 ? nftTransfers : undefined,
+    };
+}
+
+/**
+ * Determines the transaction type
+ */
+function determineTransactionType(tx: Transaction, receipt: TransactionReceipt): TransactionType {
+    // Contract creation
+    if (!tx.to) return TRANSACTION_TYPE.CONTRACT_CREATION;
+
+    // Check if it's a token/NFT transfer based on method signature
+    const methodSig = tx.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
+
+    // Check value
+    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;
+
+    return TRANSACTION_TYPE.CONTRACT_INTERACTION;
+}
+
+/**
+ * Parses transfer events from transaction logs
+ */
+async function parseTransferLogs(
+    client: PublicClient,
+    logs: TransactionReceipt['logs'],
+    walletAddress: Address,
+    includeTokenTransfers: boolean,
+    includeNFTTransfers: boolean
+): Promise<{ tokens: TokenTransfer[]; nfts: NFTTransfer[] }> {
+    const tokens: TokenTransfer[] = [];
+    const nfts: NFTTransfer[] = [];
+
+    for (const log of logs) {
+        try {
+            // Try ERC20 Transfer
+            if (includeTokenTransfers && log.topics.length === 3) {
+                try {
+                    const decoded = decodeEventLog({
+                        abi: ERC20_TRANSFER_EVENT,
+                        data: log.data,
+                        topics: log.topics,
+                    });
+
+                    if (decoded.eventName === 'Transfer') {
+                        const { from, to, value } = decoded.args as any;
+
+                        // Only include if wallet is involved
+                        if (from.toLowerCase() === walletAddress.toLowerCase() ||
+                            to.toLowerCase() === walletAddress.toLowerCase()) {
+
+                            // Try to get token info (this might fail for non-standard tokens)
+                            let decimals = 18;
+                            try {
+                                decimals = await client.readContract({
+                                    address: log.address,
+                                    abi: parseAbi(['function decimals() view returns (uint8)']),
+                                    functionName: 'decimals',
+                                }) as number;
+                            } catch { }
+
+                            tokens.push({
+                                type: 'ERC20',
+                                from,
+                                to,
+                                amount: formatUnits(value, decimals),
+                                tokenAddress: log.address,
+                                tokenDecimals: decimals,
+                            });
+                        }
+                    }
+                } catch { }
+            }
+
+            // Try ERC721 Transfer (has indexed tokenId)
+            if (includeNFTTransfers && log.topics.length === 4) {
+                try {
+                    const decoded = decodeEventLog({
+                        abi: ERC721_TRANSFER_EVENT,
+                        data: log.data,
+                        topics: log.topics,
+                    });
+
+                    if (decoded.eventName === 'Transfer') {
+                        const { from, to, tokenId } = decoded.args as any;
+
+                        if (from.toLowerCase() === walletAddress.toLowerCase() ||
+                            to.toLowerCase() === walletAddress.toLowerCase()) {
+                            nfts.push({
+                                type: 'ERC721',
+                                from,
+                                to,
+                                tokenId: tokenId.toString(),
+                                tokenAddress: log.address,
+                            });
+                        }
+                    }
+                } catch { }
+            }
+
+            // Try ERC1155 TransferSingle
+            if (includeNFTTransfers) {
+                try {
+                    const decoded = decodeEventLog({
+                        abi: ERC1155_TRANSFER_SINGLE_EVENT,
+                        data: log.data,
+                        topics: log.topics,
+                    });
+
+                    if (decoded.eventName === 'TransferSingle') {
+                        const { from, to, id, value } = decoded.args as any;
+
+                        if (from.toLowerCase() === walletAddress.toLowerCase() ||
+                            to.toLowerCase() === walletAddress.toLowerCase()) {
+                            nfts.push({
+                                type: 'ERC1155',
+                                from,
+                                to,
+                                tokenId: id.toString(),
+                                amount: value.toString(),
+                                tokenAddress: log.address,
+                            });
+                        }
+                    }
+                } catch { }
+            }
+        } catch (error) {
+            // Skip logs that don't match our patterns
+            continue;
+        }
+    }
+
+    return { tokens, nfts };
+}
+
+/**
+ * Helper function to create a client
+ */
+export function createEVMClient(rpcUrl: string) {
+    return createPublicClient({
+        transport: http(rpcUrl),
+    });
+}
+
+// Example usage:
+/*
+import { mainnet } from 'viem/chains';
+
+const client = createPublicClient({
+  chain: mainnet,
+  transport: http('https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY'),
+});
+
+const history = await getEVMTransactionHistoryWithAPI(
+  client,
+  '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb' as Address,
+  'https://api.etherscan.io/api',
+  'YOUR_ETHERSCAN_API_KEY'
+);
+
+console.log(history);
+*/