ethnotary 1.0.0

package/data/scanWorker.js

@@ -0,0 +1,169 @@
+const { parentPort, workerData } = require('worker_threads');
+const { ethers } = require('ethers');
+
+async function scanNetwork(networkConfig, contractAddress, includeHistorical) {
+    const { networkKey, network, erc20ABI, erc721ABI } = networkConfig;
+    
+    try {
+        const provider = new ethers.JsonRpcProvider(network.rpcUrl);
+        const discoveredTokens = [];
+        const tokenAddresses = new Set();
+
+        // Get current block
+        const currentBlock = await provider.getBlockNumber();
+        const fromBlock = includeHistorical ? 0 : Math.max(0, currentBlock - 900000);
+        
+        // Transfer event topics
+        const transferTopic = ethers.id("Transfer(address,address,uint256)");
+
+        // Scan for transfers TO and FROM the contract
+        const [incomingLogs, outgoingLogs] = await Promise.all([
+            provider.getLogs({
+                fromBlock,
+                toBlock: currentBlock,
+                topics: [
+                    transferTopic,
+                    null,
+                    ethers.zeroPadValue(contractAddress, 32)
+                ]
+            }),
+            provider.getLogs({
+                fromBlock,
+                toBlock: currentBlock,
+                topics: [
+                    transferTopic,
+                    ethers.zeroPadValue(contractAddress, 32),
+                    null
+                ]
+            })
+        ]);
+
+        // Extract unique token addresses
+        [...incomingLogs, ...outgoingLogs].forEach(log => {
+            tokenAddresses.add(log.address.toLowerCase());
+        });
+
+        // Check each token contract
+        const tokenChecks = Array.from(tokenAddresses).map(async (tokenAddress) => {
+            try {
+                // Try ERC20
+                try {
+                    const erc20Contract = new ethers.Contract(tokenAddress, erc20ABI, provider);
+                    const [balance, decimals, symbol, name] = await Promise.all([
+                        erc20Contract.balanceOf(contractAddress),
+                        erc20Contract.decimals(),
+                        erc20Contract.symbol(),
+                        erc20Contract.name()
+                    ]);
+
+                    if (balance > 0n) {
+                        const formattedBalance = ethers.formatUnits(balance, decimals);
+                        return {
+                            type: 'ERC20',
+                            address: tokenAddress,
+                            symbol: symbol,
+                            name: name,
+                            balance: formattedBalance,
+                            rawBalance: balance.toString(),
+                            decimals: decimals,
+                            network: networkKey,
+                            source: 'events'
+                        };
+                    }
+                } catch (erc20Error) {
+                    // Try ERC721
+                    try {
+                        const erc721Contract = new ethers.Contract(tokenAddress, erc721ABI, provider);
+                        const [balance, symbol, name] = await Promise.all([
+                            erc721Contract.balanceOf(contractAddress),
+                            erc721Contract.symbol(),
+                            erc721Contract.name()
+                        ]);
+
+                        if (balance > 0n) {
+                            // Try walletOfOwner first, fallback to tokenOfOwnerByIndex
+                            let tokenIds = [];
+                            try {
+                                // Try walletOfOwner
+                                const walletTokens = await erc721Contract.walletOfOwner(contractAddress);
+                                tokenIds = walletTokens.map(id => id.toString());
+                                console.log(`Found ${tokenIds.length} tokens using walletOfOwner`);
+                            } catch (walletError) {
+                                // Fallback to tokenOfOwnerByIndex
+                                const promises = [];
+                                for (let i = 0; i < Math.min(Number(balance), 50); i++) {
+                                    promises.push(erc721Contract.tokenOfOwnerByIndex(contractAddress, i)
+                                        .then(tokenId => tokenIds.push(tokenId.toString()))
+                                        .catch(() => {}));
+                                }
+                                await Promise.allSettled(promises);
+                                console.log(`Found ${tokenIds.length} tokens using tokenOfOwnerByIndex`);
+                            }
+
+                            // Try to get token URIs
+                            const tokenDetails = await Promise.all(
+                                tokenIds.map(async (tokenId) => {
+                                    try {
+                                        const uri = await erc721Contract.tokenURI(tokenId);
+                                        return { id: tokenId, uri };
+                                    } catch (error) {
+                                        return { id: tokenId };
+                                    }
+                                })
+                            );
+
+                            return {
+                                type: 'ERC721',
+                                address: tokenAddress,
+                                symbol: symbol,
+                                name: name,
+                                balance: balance.toString(),
+                                tokenIds: tokenIds,
+                                tokenDetails: tokenDetails,
+                                network: networkKey,
+                                source: 'events'
+                            };
+                        }
+                    } catch (erc721Error) {
+                        // Not a valid token contract
+                    }
+                }
+            } catch (error) {
+                // Log error but continue with other tokens
+                console.error(`Error checking token ${tokenAddress}: ${error.message}`);
+            }
+            return null;
+        });
+
+        const results = await Promise.allSettled(tokenChecks);
+        results.forEach(result => {
+            if (result.status === 'fulfilled' && result.value) {
+                discoveredTokens.push(result.value);
+            }
+        });
+
+        return {
+            networkKey,
+            networkName: network.name,
+            tokens: discoveredTokens
+        };
+
+    } catch (error) {
+        return {
+            networkKey,
+            networkName: network.name,
+            error: error.message,
+            tokens: []
+        };
+    }
+}
+
+// Handle messages from parent
+parentPort.on('message', async ({ networkConfig, contractAddress, includeHistorical }) => {
+    try {
+        const result = await scanNetwork(networkConfig, contractAddress, includeHistorical);
+        parentPort.postMessage({ type: 'success', data: result });
+    } catch (error) {
+        parentPort.postMessage({ type: 'error', error: error.message });
+    }
+});

package/data/token_cache.json

@@ -0,0 +1,54 @@
+{
+  "0xe4F717Fbe2901efF97d3fD48593Ef2c6453b4Eee_scan": {
+    "data": [
+      {
+        "type": "ERC721",
+        "address": "0xe29f8038d1a3445ab22ad1373c65ec0a6e1161a4",
+        "symbol": "BAYC",
+        "name": "BoredApeYachtClub",
+        "balance": "1",
+        "tokenIds": [
+          "340"
+        ],
+        "tokenDetails": [
+          {
+            "id": "340",
+            "uri": "ipfs://QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq/340"
+          }
+        ],
+        "network": "sepolia",
+        "source": "events"
+      },
+      {
+        "type": "ERC20",
+        "address": "0x399ab04277063386023c41d0f77d15b79cb2d3be",
+        "symbol": "MT",
+        "name": "MyToken",
+        "balance": "10000.0",
+        "rawBalance": "10000000000000000000000",
+        "decimals": "18",
+        "network": "sepolia",
+        "source": "events"
+      },
+      {
+        "type": "ERC721",
+        "address": "0xe6c1ee6624c6819262f29199df25a70b2648b818",
+        "symbol": "DOODLE",
+        "name": "Doodles",
+        "balance": "1",
+        "tokenIds": [
+          "233"
+        ],
+        "tokenDetails": [
+          {
+            "id": "233",
+            "uri": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/233"
+          }
+        ],
+        "network": "sepolia",
+        "source": "events"
+      }
+    ],
+    "timestamp": 1761750128412
+  }
+}

package/data/token_database.json

@@ -0,0 +1,92 @@
+{
+    "metadata": {
+        "version": "1.0.0",
+        "description": "Token database for MultiSig dashboard",
+        "lastUpdated": "2025-10-27",
+        "totalTokens": 0,
+        "networks": ["sepolia", "base-sepolia", "arbitrum-sepolia"]
+    },
+    "networks": {
+        "sepolia": {
+            "chainId": 11155111,
+            "name": "Sepolia Testnet",
+            "tokens": {
+                "erc20": {
+                    "testTokens": {
+                        "WETH": {
+                            "address": "0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9",
+                            "name": "Wrapped Ether",
+                            "symbol": "WETH",
+                            "decimals": 18,
+                            "type": "wrapped"
+                        },
+                        "USDC": {
+                            "address": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+                            "name": "USD Coin",
+                            "symbol": "USDC",
+                            "decimals": 6,
+                            "type": "stablecoin"
+                        },
+                        "DAI": {
+                            "address": "0x3e622317f8C93f7328350cF0B56d9eD4C620C5d6",
+                            "name": "Dai Stablecoin",
+                            "symbol": "DAI",
+                            "decimals": 18,
+                            "type": "stablecoin"
+                        }
+                    }
+                },
+                "erc721": {
+                    "testNFTs": {
+                        "MBAYC": {
+                            "address": "0xE29F8038d1A3445Ab22AD1373c65eC0a6E1161a4",
+                            "name": "Bored Ape Yacht Club",
+                            "symbol": "MBAYC",
+                            "type": "pfp"
+                        }
+                    }
+                }
+            }
+        },
+        "base-sepolia": {
+            "chainId": 84532,
+            "name": "Base Sepolia",
+            "tokens": {
+                "erc20": {
+                    "testTokens": {
+                        "WETH": {
+                            "address": "0x4200000000000000000000000000000000000006",
+                            "name": "Wrapped Ether",
+                            "symbol": "WETH",
+                            "decimals": 18,
+                            "type": "wrapped"
+                        }
+                    }
+                },
+                "erc721": {
+                    "testNFTs": {}
+                }
+            }
+        },
+        "arbitrum-sepolia": {
+            "chainId": 421614,
+            "name": "Arbitrum Sepolia",
+            "tokens": {
+                "erc20": {
+                    "testTokens": {
+                        "WETH": {
+                            "address": "0x980B62Da83eFf3D4576C647993b0c1D7faf17c73",
+                            "name": "Wrapped Ether",
+                            "symbol": "WETH",
+                            "decimals": 18,
+                            "type": "wrapped"
+                        }
+                    }
+                },
+                "erc721": {
+                    "testNFTs": {}
+                }
+            }
+        }
+    }
+}

package/data/tokens.js

@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const { ethers } = require('ethers');
+const { Worker } = require('worker_threads');
+
+class TokenScanner {
+    constructor() {
+        this.networks = {
+            sepolia: {
+                name: 'Sepolia Testnet',
+                chainId: 11155111,
+                isTestnet: true
+            },
+            'base-sepolia': {
+                name: 'Base Sepolia',
+                chainId: 84532,
+                isTestnet: true
+            },
+            'arbitrum-sepolia': {
+                name: 'Arbitrum Sepolia',
+                chainId: 421614,
+                isTestnet: true
+            }
+        };
+
+        this.erc20ABI = [
+            "function balanceOf(address owner) view returns (uint256)",
+            "function decimals() view returns (uint8)",
+            "function symbol() view returns (string)",
+            "function name() view returns (string)"
+        ];
+        
+        this.erc721ABI = [
+            "function balanceOf(address owner) view returns (uint256)",
+            "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)",
+            "function ownerOf(uint256 tokenId) view returns (address)",
+            "function name() view returns (string)",
+            "function symbol() view returns (string)",
+            "function walletOfOwner(address owner) view returns (uint256[])",
+            "function tokenURI(uint256 tokenId) view returns (string)"
+        ];
+
+        this.tokenDatabase = null;
+        this.cache = new Map();
+        this.cacheFile = path.join(__dirname, 'token_cache.json');
+    }
+
+    async loadConfig() {
+        try {
+            const envPath = path.join(__dirname, '..', '.env');
+            const envContent = await fs.readFile(envPath, 'utf8');
+            
+            const envVars = {};
+            envContent.split('\n').forEach(line => {
+                const [key, value] = line.split('=');
+                if (key && value) {
+                    envVars[key.trim()] = value.trim().replace(/['"]/g, '');
+                }
+            });
+
+            this.networks.sepolia.rpcUrl = envVars.SEPOLIA_RPC_URL;
+            this.networks['base-sepolia'].rpcUrl = envVars.BASE_SEPOLIA_RPC_URL;
+            this.networks['arbitrum-sepolia'].rpcUrl = envVars.ARBITRUM_SEPOLIA_RPC_URL;
+
+            console.log('✅ Configuration loaded');
+            return true;
+        } catch (error) {
+            console.error('❌ Failed to load configuration:', error.message);
+            return false;
+        }
+    }
+
+    async loadTokenDatabase() {
+        if (this.tokenDatabase) return this.tokenDatabase;
+
+        try {
+            const dbPath = path.join(__dirname, '..', 'token_database.json');
+            const dbContent = await fs.readFile(dbPath, 'utf8');
+            this.tokenDatabase = JSON.parse(dbContent);
+            console.log('✅ Token database loaded');
+            return this.tokenDatabase;
+        } catch (error) {
+            console.error('❌ Failed to load token database:', error.message);
+            return null;
+        }
+    }
+
+    async loadCache() {
+        try {
+            const cacheContent = await fs.readFile(this.cacheFile, 'utf8');
+            const cacheData = JSON.parse(cacheContent);
+            
+            Object.entries(cacheData).forEach(([key, value]) => {
+                if (Date.now() - value.timestamp < 300000) { // 5 minutes
+                    this.cache.set(key, value);
+                }
+            });
+            
+            console.log(`✅ Cache loaded: ${this.cache.size} entries`);
+        } catch (error) {
+            console.log('ℹ️ No existing cache found, starting fresh');
+        }
+    }
+
+    async saveCache() {
+        try {
+            const cacheObj = Object.fromEntries(this.cache);
+            await fs.writeFile(this.cacheFile, JSON.stringify(cacheObj, (key, value) =>
+                typeof value === 'bigint' ? value.toString() : value
+            , 2));
+            console.log('✅ Cache saved');
+        } catch (error) {
+            console.error('⚠️ Failed to save cache:', error.message);
+        }
+    }
+
+    async updateTokenDatabase(newTokens) {
+        try {
+            const tokenDb = await this.loadTokenDatabase();
+            let addedCount = 0;
+
+            for (const token of newTokens) {
+                const networkKey = token.network;
+                const tokenType = token.type.toLowerCase();
+
+                if (!tokenDb.networks[networkKey]) continue;
+                if (!['erc20', 'erc721'].includes(tokenType)) continue;
+
+                const networkTokens = tokenDb.networks[networkKey].tokens[tokenType];
+                
+                // Check discovered section
+                if (!networkTokens.discovered) {
+                    networkTokens.discovered = {};
+                }
+
+                // Check if token already exists in any category
+                const tokenExists = Object.values(networkTokens).some(category =>
+                    Object.values(category).some(t =>
+                        t.address.toLowerCase() === token.address.toLowerCase()
+                    )
+                );
+
+                if (!tokenExists) {
+                    const tokenKey = `${token.symbol}_${token.address.substring(2, 6)}`;
+                    networkTokens.discovered[tokenKey] = {
+                        address: token.address,
+                        name: token.name,
+                        symbol: token.symbol,
+                        type: 'discovered',
+                        decimals: token.decimals,
+                        discoveryMethod: token.source,
+                        discoveredAt: new Date().toISOString(),
+                        lastVerified: new Date().toISOString()
+                    };
+                    addedCount++;
+                }
+            }
+
+            if (addedCount > 0) {
+                // Update metadata
+                tokenDb.metadata.totalTokens += addedCount;
+                tokenDb.metadata.lastUpdated = new Date().toISOString();
+
+                // Save to file
+                await fs.writeFile(
+                    path.join(__dirname, '..', 'token_database.json'),
+                    JSON.stringify(tokenDb, (key, value) =>
+                        typeof value === 'bigint' ? value.toString() : value
+                    , 2)
+                );
+                console.log(`✅ Added ${addedCount} new tokens to database`);
+            }
+
+            return addedCount;
+        } catch (error) {
+            console.error('❌ Failed to update token database:', error.message);
+            return 0;
+        }
+    }
+
+    async scanTokens(contractAddress, includeHistoricalScan = false) {
+        console.log(`🚀 Starting token scan for: ${contractAddress}`);
+        console.log(`📜 Historical scan: ${includeHistoricalScan ? 'ENABLED' : 'DISABLED'}`);
+
+        // Load configuration
+        const configLoaded = await this.loadConfig();
+        if (!configLoaded) {
+            console.error('❌ Failed to load configuration');
+            return;
+        }
+
+        // Load cache
+        await this.loadCache();
+
+        let discoveredTokens = [];
+        const summary = {
+            contract: contractAddress,
+            timestamp: new Date().toISOString(),
+            networks: {},
+            totalTokens: 0,
+            tokensByType: { ERC20: 0, ERC721: 0 },
+            tokens: []
+        };
+
+        // Process all networks in parallel using worker threads
+        const workerPromises = Object.entries(this.networks).map(([networkKey, network]) => {
+            if (!network.rpcUrl) return Promise.resolve(null);
+
+            return new Promise((resolve) => {
+                const worker = new Worker('./data/scanWorker.js');
+                
+                worker.on('message', (message) => {
+                    if (message.type === 'success') {
+                        const result = message.data;
+                        console.log(`\n🌐 Completed ${result.networkName}...`);
+                        worker.terminate();
+                        resolve(result);
+                    } else if (message.type === 'error') {
+                        console.error(`❌ Worker error for ${network.name}:`, message.error);
+                        worker.terminate();
+                        resolve(null);
+                    }
+                });
+
+                worker.on('error', (error) => {
+                    console.error(`❌ Worker crashed for ${network.name}:`, error);
+                    worker.terminate();
+                    resolve(null);
+                });
+
+                worker.postMessage({
+                    networkConfig: {
+                        networkKey,
+                        network,
+                        erc20ABI: this.erc20ABI,
+                        erc721ABI: this.erc721ABI
+                    },
+                    contractAddress,
+                    includeHistorical: includeHistoricalScan
+                });
+            });
+        });
+
+        // Wait for all network scans to complete
+        console.log('🚀 Scanning all networks in parallel...');
+        const results = await Promise.all(workerPromises);
+        
+        // Process results
+        results.forEach(result => {
+            if (result && result.tokens.length > 0) {
+                discoveredTokens.push(...result.tokens);
+                
+                // Update summary
+                summary.networks[result.networkKey] = {
+                    name: result.networkName,
+                    tokenCount: result.tokens.length,
+                    tokens: result.tokens
+                };
+
+                console.log(`  ✅ ${result.networkName}: Found ${result.tokens.length} tokens`);
+            }
+        });
+
+        // Update token database with new discoveries
+        if (discoveredTokens.length > 0) {
+            console.log('\n📝 Updating token database...');
+            const addedCount = await this.updateTokenDatabase(discoveredTokens);
+            if (addedCount > 0) {
+                console.log(`  ✨ Added ${addedCount} new tokens to database`);
+            }
+
+            // Update cache with all discovered tokens
+            const cacheKey = `${contractAddress}_scan`;
+            this.cache.set(cacheKey, {
+                data: discoveredTokens,
+                timestamp: Date.now()
+            });
+            await this.saveCache();
+        }
+
+        // Final summary
+        summary.totalTokens = discoveredTokens.length;
+        summary.tokensByType.ERC20 = discoveredTokens.filter(t => t.type === 'ERC20').length;
+        summary.tokensByType.ERC721 = discoveredTokens.filter(t => t.type === 'ERC721').length;
+        summary.tokens = discoveredTokens;
+
+        console.log(`\n🎉 Token scan complete!`);
+        console.log(`📊 Total: ${summary.totalTokens} tokens (${summary.tokensByType.ERC20} ERC20, ${summary.tokensByType.ERC721} ERC721)`);
+
+        // Display results by network
+        if (discoveredTokens.length > 0) {
+            console.log(`\n📋 Found Tokens:`);
+            
+            // Group tokens by network
+            const networkGroups = {};
+            discoveredTokens.forEach(token => {
+                if (!networkGroups[token.network]) {
+                    networkGroups[token.network] = [];
+                }
+                networkGroups[token.network].push(token);
+            });
+
+            // Display tokens by network
+            Object.entries(networkGroups).forEach(([network, tokens]) => {
+                const networkInfo = this.networks[network];
+                console.log(`\n🌐 ${networkInfo.name}:`);
+                
+                // Display ERC20 tokens first
+                const erc20Tokens = tokens.filter(t => t.type === 'ERC20');
+                if (erc20Tokens.length > 0) {
+                    console.log('  📈 ERC20 Tokens:');
+                    erc20Tokens.forEach(token => {
+                        console.log(`    • ${token.symbol} (${token.name})`);
+                        console.log(`      Balance: ${token.balance}`);
+                        console.log(`      Address: ${token.address}`);
+                    });
+                }
+
+                // Then display ERC721 tokens
+                const erc721Tokens = tokens.filter(t => t.type === 'ERC721');
+                if (erc721Tokens.length > 0) {
+                    console.log('  🎨 NFT Collections:');
+                    erc721Tokens.forEach(token => {
+                        console.log(`    • ${token.symbol} (${token.name})`);
+                        console.log(`      Total Owned: ${token.balance}`);
+                        console.log(`      Address: ${token.address}`);
+                        if (token.tokenDetails && token.tokenDetails.length > 0) {
+                            console.log(`      Token IDs:`);
+                            token.tokenDetails.forEach(detail => {
+                                if (detail.uri) {
+                                    console.log(`        - #${detail.id} (URI: ${detail.uri}`);
+                                } else {
+                                    console.log(`        - #${detail.id}`);
+                                }
+                            });
+                        } else if (token.tokenIds && token.tokenIds.length > 0) {
+                            console.log(`      Token IDs: ${token.tokenIds.join(', ')}`);
+                        }
+                    });
+                }
+            });
+        }
+
+        return summary;
+    }
+}
+
+// CLI interface
+async function main() {
+    const args = process.argv.slice(2);
+    
+    if (args.length === 0) {
+        console.log('Usage: node data/tokens.js <contract_address> [--historical]');
+        console.log('Example: node data/tokens.js 0xe4F717Fbe2901efF97d3fD48593Ef2c6453b4Eee --historical');
+        process.exit(1);
+    }
+
+    const contractAddress = args[0];
+    const includeHistorical = args.includes('--historical');
+
+    if (!ethers.isAddress(contractAddress)) {
+        console.error('❌ Invalid contract address');
+        process.exit(1);
+    }
+
+    const scanner = new TokenScanner();
+    await scanner.scanTokens(contractAddress, includeHistorical);
+}
+
+// Run if called directly
+if (require.main === module) {
+    main().catch(error => {
+        console.error('❌ Script failed:', error.message);
+        process.exit(1);
+    });
+}
+
+module.exports = TokenScanner;