eth_getCode | Hyperliquid EVM

// Check if address is a contract
const isContract = (code) => code !== "0x" && code.length > 2;

// Check if address is an EOA
const isEOA = (code) => code === "0x";

// Get contract bytecode on Hyperliquid
const getContractCode = async (address) => {
  const response = await fetch('https://hyperliquid-mainnet.core.chainstack.com/YOUR_ENDPOINT/evm', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'eth_getCode',
      params: [address, 'latest'], // Only 'latest' is supported
      id: 1
    })
  });
  
  const data = await response.json();
  return data.result;
};

// Check if address is a contract or EOA
const analyzeAddress = async (address) => {
  const code = await getContractCode(address);
  
  const isContract = code !== "0x" && code.length > 2;
  const isEOA = code === "0x";
  
  return {
    address,
    code,
    isContract,
    isEOA,
    codeSize: isContract ? (code.length - 2) / 2 : 0, // Convert hex to bytes
    hasCode: isContract
  };
};

// Analyze multiple addresses
const analyzeMultipleAddresses = async (addresses) => {
  const results = [];
  
  for (const address of addresses) {
    try {
      const analysis = await analyzeAddress(address);
      results.push(analysis);
    } catch (error) {
      console.error(`Error analyzing address ${address}:`, error);
      results.push({
        address,
        error: error.message,
        isContract: null,
        isEOA: null
      });
    }
  }
  
  return results;
};

// Check for common proxy patterns
const checkProxyPattern = (bytecode) => {
  if (bytecode === "0x") return { isProxy: false, type: null };
  
  // EIP-1167 minimal proxy pattern
  if (bytecode.includes("363d3d373d3d3d363d73")) {
    return { isProxy: true, type: "EIP-1167 Minimal Proxy" };
  }
  
  // Other common proxy patterns
  if (bytecode.includes("3660008037600080366000845af43d6000803e")) {
    return { isProxy: true, type: "Delegatecall Proxy" };
  }
  
  return { isProxy: false, type: null };
};

// Usage examples
const contractAddress = "0x5555555555555555555555555555555555555555";
const eoaAddress = "0xFC1286EeddF81d6955eDAd5C8D99B8Aa32F3D2AA";

analyzeAddress(contractAddress)
  .then(analysis => {
    console.log('Contract Analysis:', analysis);
    if (analysis.isContract) {
      const proxyInfo = checkProxyPattern(analysis.code);
      console.log('Proxy Analysis:', proxyInfo);
    }
  })
  .catch(error => console.error('Error:', error));

// Analyze multiple addresses
analyzeMultipleAddresses([contractAddress, eoaAddress])
  .then(results => console.log('Multiple Address Analysis:', results))
  .catch(error => console.error('Error:', error));