@deserialize/multi-vm-wallet 1.2.293 → 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,6 +12,27 @@ import {
     parseAbi
 } from 'viem';
 import { TRANSACTION_TYPE, TransactionType } from '../constant';
+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;
@@ -92,64 +113,132 @@ export async function getEVMTransactionHistory(
     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,
+    // 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;
+    // }
+    if (client.chain?.id === undefined) throw new Error("Chain Id is Undefined")
+
+    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,
-                includeTokenTransfers,
-                includeNFTTransfers
+                0,
+                99999999,
+                1,
+                20, // limit to 20 recent transactions
+                'desc' // newest first
             );
 
-            history.push(parsed);
+            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);
         }
+    }
 
-        // Sort by block number (newest first)
-        history.sort((a, b) => Number(b.blockNumber - a.blockNumber));
+    // Fallback to HelperAPI
+    console.log(`Fetching transaction history from HelperAPI for chain ${chainId}`);
+    return await HelperAPI.getTransactionHistory(walletAddress, "EVM", chainId);
+}
 
-        return history;
-    } catch (error) {
-        console.error('Error fetching EVM transaction history:', error);
-        throw error;
+/**
+ * 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;
 }
 
 /**
@@ -488,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;
 }
@@ -511,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;
@@ -533,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({
@@ -550,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;
@@ -581,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/evm/utils.ts

@@ -1,4 +1,4 @@
-import { Balance, ChainWalletConfig, SUPPORTED_VM, UserTokenBalance, TokenInfo } from '../types'
+import { Balance, ChainWalletConfig, SUPPORTED_VM, UserTokenBalance, TokenInfo, EVMNFT, NFT, NFTCollection } from '../types'
 import { JsonRpcProvider, Contract, Wallet, TransactionRequest, TransactionResponse, TransactionReceipt, parseUnits, formatUnits, ethers } from 'ethers'
 import BN from 'bn.js'
 import { HelperAPI } from '../helpers';
@@ -650,7 +650,8 @@ export const discoverTokens = async (wallet: string, chain: ChainWalletConfig):
             symbol: token.symbol,
             decimals: token.decimals,
             balance: token.balance,
-            owner: wallet
+            owner: wallet,
+            logoUrl: token.logo
         }
     })
     return formatBalances
@@ -954,4 +955,162 @@ export function prepareSwapParams(
 
 export function convertSlippageForDebonk(slippageBps: number): number {
     return slippageBps / 100;
+}
+
+export const transformEVMNFTToUnified = (nft: EVMNFT): NFT => {
+    // Extract image URL from various sources
+    const imageUrl = nft.image?.cachedUrl ||
+        nft.image?.thumbnailUrl ||
+        nft.image?.pngUrl ||
+        nft.image?.originalUrl ||
+        nft.openSeaMetadata?.imageUrl ||
+        nft.raw?.metadata?.image ||
+        undefined;
+
+    // Extract attributes
+    const attributes = nft.raw?.metadata?.attributes?.map(attr => ({
+        trait_type: attr.trait_type,
+        value: attr.value,
+        display_type: attr.display_type
+    }));
+
+    return {
+        id: `${nft.contract.address}:${nft.tokenId}`,
+        name: nft.name || nft.raw?.metadata?.name || 'Unknown',
+        symbol: nft.contract.symbol,
+        description: nft.description || nft.raw?.metadata?.description || '',
+        image: imageUrl,
+        uri: nft.raw?.tokenUri || '',
+        collection: {
+            address: nft.contract.address,
+            name: nft.openSeaMetadata?.collectionName || nft.contract.name,
+            verified: nft.openSeaMetadata?.safelistRequestStatus === 'verified'
+        },
+        chainType: 'EVM',
+        balance: nft.balance,
+        attributes,
+        tokenStandard: nft.tokenType,
+        isSpam: nft.contract.isSpam,
+        raw: {
+            evm: nft
+        }
+    };
+};
+
+export const discoverNFTs = async (wallet: string, chain: ChainWalletConfig): Promise<NFT[]> => {
+    console.log('discoverNFTs: Starting NFT discovery');
+    console.log('Wallet:', wallet);
+    console.log('Chain:', chain.name, 'ChainId:', chain.chainId);
+
+    try {
+        const response = await HelperAPI.getUserNFTs(wallet, chain.vmType ?? "EVM", chain.chainId);
+
+        console.log('discoverNFTs: Successfully fetched', response.data.length, 'NFTs');
+
+        // Filter out spam NFTs if desired (optional)
+        const evmNfts = response.data.filter(nft => !nft.contract.isSpam);
+
+        console.log('discoverNFTs: After spam filtering:', evmNfts.length, 'NFTs');
+
+        // Transform to unified NFT format
+        const nfts = evmNfts.map(transformEVMNFTToUnified);
+
+        return nfts;
+    } catch (error) {
+        console.error('discoverNFTs: Error fetching NFTs:', error);
+        console.error('Error details:', error instanceof Error ? error.message : 'Unknown error');
+        throw error;
+    }
+}
+
+export const discoverAllNFTs = async (wallet: string, chain: ChainWalletConfig): Promise<NFT[]> => {
+    console.log('discoverAllNFTs: Starting NFT discovery (including spam)');
+    console.log('Wallet:', wallet);
+    console.log('Chain:', chain.name, 'ChainId:', chain.chainId);
+
+    try {
+        const response = await HelperAPI.getUserNFTs(wallet, chain.vmType ?? "EVM", chain.chainId);
+
+        console.log('discoverAllNFTs: Successfully fetched', response.data.length, 'NFTs (including spam)');
+
+        // Transform to unified NFT format
+        const nfts = response.data.map(transformEVMNFTToUnified);
+
+        return nfts;
+    } catch (error) {
+        console.error('discoverAllNFTs: Error fetching NFTs:', error);
+        console.error('Error details:', error instanceof Error ? error.message : 'Unknown error');
+        throw error;
+    }
+}
+
+/**
+ * Get NFT collection details for a specific collection
+ * @param wallet - User's wallet address
+ * @param collectionAddress - The NFT collection contract address
+ * @param chain - Chain configuration
+ * @returns NFTCollection object with collection details and user's NFTs in that collection
+ */
+export const getNFTCollection = async (
+    wallet: string,
+    collectionAddress: string,
+    chain: ChainWalletConfig
+): Promise<NFTCollection | null> => {
+    console.log('getNFTCollection: Starting collection fetch');
+    console.log('Wallet:', wallet);
+    console.log('Collection Address:', collectionAddress);
+    console.log('Chain:', chain.name, 'ChainId:', chain.chainId);
+
+    try {
+        // Fetch all NFTs for the user
+        const allNfts = await discoverAllNFTs(wallet, chain);
+
+        console.log('getNFTCollection: Fetched', allNfts.length, 'total NFTs');
+
+        // Filter NFTs by collection address (case-insensitive comparison)
+        const collectionNfts = allNfts.filter(
+            nft => nft.collection.address.toLowerCase() === collectionAddress.toLowerCase()
+        );
+
+        console.log('getNFTCollection: Found', collectionNfts.length, 'NFTs in collection');
+
+        if (collectionNfts.length === 0) {
+            console.log('getNFTCollection: No NFTs found in this collection');
+            return null;
+        }
+
+        // Extract collection metadata from the first NFT
+        const firstNft = collectionNfts[0];
+        const rawEvmNft = firstNft.raw?.evm;
+
+        const collection: NFTCollection = {
+            address: collectionAddress,
+            name: firstNft.collection.name,
+            symbol: firstNft.symbol,
+            description: undefined,
+            image: rawEvmNft?.openSeaMetadata?.imageUrl,
+            verified: firstNft.collection.verified,
+            chainType: 'EVM',
+            nfts: collectionNfts,
+            totalOwned: collectionNfts.length,
+            contractMetadata: rawEvmNft ? {
+                tokenType: rawEvmNft.contract.tokenType,
+                totalSupply: rawEvmNft.contract.totalSupply,
+                contractDeployer: rawEvmNft.contract.contractDeployer,
+                deployedBlockNumber: rawEvmNft.contract.deployedBlockNumber,
+            } : undefined,
+            openSeaMetadata: rawEvmNft?.openSeaMetadata ? {
+                collectionSlug: rawEvmNft.openSeaMetadata.collectionSlug,
+                floorPrice: rawEvmNft.openSeaMetadata.floorPrice,
+                safelistRequestStatus: rawEvmNft.openSeaMetadata.safelistRequestStatus,
+            } : undefined,
+        };
+
+        console.log('getNFTCollection: Successfully created collection object');
+        return collection;
+    } catch (error) {
+        console.error('getNFTCollection: Error fetching collection:', error);
+        console.error('Error details:', error instanceof Error ? error.message : 'Unknown error');
+        throw error;
+    }
 }

package/utils/helpers/index.ts

@@ -1,4 +1,5 @@
-import { vmTypes } from "../types";
+export * from './routeScan';
+import { vmTypes, EVMNFTResponse } from "../types";
 
 const BASE_URL = "https://helper.decane.app"
 
@@ -8,4 +9,15 @@ export class HelperAPI {
         const data = await res.json();
         return data;
     }
+
+    static async getUserNFTs(wallet: string, vm: vmTypes, chainId: number): Promise<EVMNFTResponse> {
+        const res = await fetch("" + BASE_URL + `/${vm}/nfts/discover?wallet=${wallet}&chainId=${chainId}`);
+        const data = await res.json();
+        return data;
+    }
+    static async getTransactionHistory(wallet: string, vm: vmTypes, chainId: number, limit: number = 20) {
+        const res = await fetch("" + BASE_URL + `/${vm}/transactions/history?wallet=${wallet}&chainId=${chainId}&limit=${limit}`);
+        const data = await res.json();
+        return data;
+    }
 }