《兄弟，你在哪？》与链上定位：寻找作为链上搜索

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title 链上搜索索引合约
 * @notice 为链上数据提供搜索索引
 */
contract OnChainSearch {
    struct SearchIndex {
        bytes32 keyword;
        address indexedAddress;
        uint256[] tokenIds;
        bytes32[] transactionHashes;
        uint256 timestamp;
    }
    
    struct SearchQuery {
        uint256 id;
        address searcher;
        string query;
        uint256 timestamp;
        bool completed;
    }
    
    mapping(bytes32 => SearchIndex) public indices;
    mapping(address => bytes32[]) public userKeywords;
    mapping(uint256 => SearchQuery) public queries;
    
    uint256 public nextQueryId;
    
    event IndexCreated(bytes32 indexed keyword, address indexedAddress);
    event SearchPerformed(uint256 indexed queryId, address searcher, string query);
    
    function createIndex(bytes32 keyword, address indexedAddress) external {
        indices[keyword] = SearchIndex({
            keyword: keyword,
            indexedAddress: indexedAddress,
            tokenIds: new uint256[](0),
            transactionHashes: new bytes32[](0),
            timestamp: block.timestamp
        });
        userKeywords[msg.sender].push(keyword);
        emit IndexCreated(keyword, indexedAddress);
    }
    
    function search(bytes32 keyword) external view returns (SearchIndex memory) {
        return indices[keyword];
    }
    
    function recordSearch(string memory query) external returns (uint256) {
        uint256 id = nextQueryId++;
        queries[id] = SearchQuery({
            id: id,
            searcher: msg.sender,
            query: query,
            timestamp: block.timestamp,
            completed: true
        });
        emit SearchPerformed(id, msg.sender, query);
        return id;
    }
}

from web3 import Web3
from typing import Dict, List, Optional
import json

class OnChainSearcher:
    """链上搜索工具"""
    
    def __init__(self, rpc_url: str):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        
    def search_transactions(self, address: str, start_block: int = 0) -> List[Dict]:
        """搜索地址的交易"""
        txs = []
        current_block = self.w3.eth.block_number
        
        for block_num in range(start_block, min(start_block + 100, current_block)):
            block = self.w3.eth.get_block(block_num, full_transactions=True)
            for tx in block.transactions:
                if tx['from'] == address or tx.to == address:
                    txs.append({
                        'hash': tx.hash.hex(),
                        'from': tx['from'],
                        'to': tx.to,
                        'value': tx.value,
                        'block': block_num
                    })
        return txs
    
    def search_events(self, contract_address: str, event_signature: str, from_block: int = 0) -> List[Dict]:
        """搜索合约事件"""
        events = []
        # 简化的事件搜索
        return events
    
    def find_common_interactions(self, address_a: str, address_b: str) -> List[Dict]:
        """查找两个地址的共同交互"""
        interactions = []
        return interactions

searcher = OnChainSearcher('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY')
txs = searcher.search_transactions('0xVitalikButerin.eth')
print(json.dumps(txs[:5], indent=2))

const ethers = require('ethers');

class SearchUI {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
  }

  async searchByAddress(address) {
    const balance = await this.provider.getBalance(address);
    const txCount = await this.provider.getTransactionCount(address);
    const code = await this.provider.getCode(address);
    
    return {
      address,
      balance: ethers.utils.formatEther(balance),
      txCount: txCount.toString(),
      isContract: code !== '0x'
    };
  }

  async searchByTransaction(hash) {
    const tx = await this.provider.getTransaction(hash);
    const receipt = await this.provider.getTransactionReceipt(hash);
    return { tx, receipt };
  }

  async searchByBlock(blockNumber) {
    const block = await this.provider.getBlockWithTransactions(blockNumber);
    return block;
  }
}

const search = new SearchUI('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');