// Educational local-memory proxy observation. No RPC, wallet, private key or real assets. import fs from 'node:fs'; import path from 'node:path'; import crypto from 'node:crypto'; import assert from 'node:assert/strict'; import solc from 'solc'; import {VM} from '@ethereumjs/vm'; import {Common,Chain,Hardfork} from '@ethereumjs/common'; import {Address,Account,hexToBytes,bytesToHex} from '@ethereumjs/util'; import {Interface,AbiCoder,keccak256} from 'ethers'; const source=[ '// SPDX-License-Identifier: MIT', 'pragma solidity ^0.8.20;', 'import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";', 'import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";', '// Minimal experiment only: immutable lab caller, no assets or application storage.', '// This is not a production contract or an audit reference implementation.', 'contract LabV1 is UUPSUpgradeable {', ' address private immutable LAB_OWNER = msg.sender;', ' function revision() public pure virtual returns(uint256) { return 1; }', ' function _authorizeUpgrade(address) internal view override { require(msg.sender == LAB_OWNER, "lab owner only"); }', '}', 'contract LabV2 is LabV1 {', ' function revision() public pure override returns(uint256) { return 2; }', '}', ''].join('\n'); const imports={}; const input={language:'Solidity',sources:{'ProxyLab.sol':{content:source}},settings:{evmVersion:'shanghai',optimizer:{enabled:false},outputSelection:{'*':{'*':['abi','evm.bytecode.object']}}}}; const compiled=JSON.parse(solc.compile(JSON.stringify(input),{import(p){ if(!p.startsWith('@openzeppelin/contracts/'))return{error:'Unexpected import'}; const text=fs.readFileSync(path.join('node_modules',p),'utf8'); imports[p]=crypto.createHash('sha256').update(text).digest('hex');return{contents:text}; }})); assert.deepEqual((compiled.errors??[]).filter(x=>x.severity==='error'),[]); const v1=compiled.contracts['ProxyLab.sol'].LabV1,v2=compiled.contracts['ProxyLab.sol'].LabV2; const proxyContract=compiled.contracts['@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol'].ERC1967Proxy; const abi=new Interface(v1.abi),proxyAbi=new Interface(proxyContract.abi); const vm=await VM.create({common:new Common({chain:Chain.Mainnet,hardfork:Hardfork.Shanghai})}); const owner=Address.fromString('0x1111111111111111111111111111111111111111'); const outsider=Address.fromString('0x2222222222222222222222222222222222222222'); for(const a of [owner,outsider])await vm.stateManager.putAccount(a,Account.fromAccountData({balance:10n**20n})); async function deploy(contract,args=''){ const r=await vm.evm.runCall({caller:owner,gasLimit:12000000n,data:hexToBytes('0x'+contract.evm.bytecode.object+args)}); assert.equal(r.execResult.exceptionError,undefined);assert.ok(r.createdAddress);return r.createdAddress; } const implementation1=await deploy(v1),implementation2=await deploy(v2); assert.notEqual(implementation1.toString(),implementation2.toString()); const args=AbiCoder.defaultAbiCoder().encode(['address','bytes'],[implementation1.toString(),'0x']).slice(2); const proxy=await deploy(proxyContract,args); const SLOT='0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc'; async function call(caller,to,name,args=[]){ return vm.evm.runCall({caller,to,gasLimit:2000000n,data:hexToBytes(abi.encodeFunctionData(name,args))}); } async function state(){ const slot=await vm.stateManager.getContractStorage(proxy,hexToBytes(SLOT)); const address='0x'+Buffer.from(slot).toString('hex').padStart(64,'0').slice(-40); const implementation=Address.fromString(address); const r=await call(owner,proxy,'revision');assert.equal(r.execResult.exceptionError,undefined); return{proxy_address:proxy.toString(),proxy_runtime_keccak256:keccak256(await vm.stateManager.getContractCode(proxy)),implementation_address:address,implementation_runtime_keccak256:keccak256(await vm.stateManager.getContractCode(implementation)),revision_via_proxy:abi.decodeFunctionResult('revision',bytesToHex(r.execResult.returnValue))[0].toString()}; } const states=[{label:'initial V1',...(await state())}],actions=[]; async function upgrade(label,caller,target,shouldSucceed){ const before=await state(),r=await call(caller,proxy,'upgradeToAndCall',[target.toString(),'0x']),success=!r.execResult.exceptionError; assert.equal(success,shouldSucceed,label); const after=await state();if(!success)assert.deepEqual(after,before,label+' reverted state'); const events=(r.execResult.logs??[]).map(l=>proxyAbi.parseLog({topics:l[1].map(bytesToHex),data:bytesToHex(l[2])})?.name??'unknown'); let error=null;if(!success){try{error=abi.parseError(bytesToHex(r.execResult.returnValue))?.name??'undecoded';}catch{error='undecoded';}} actions.push({label,caller:caller.toString(),requested_implementation:target.toString(),success,error,events,before,after}); states.push({label,...after}); } await upgrade('outsider upgrade rejected',outsider,implementation2,false); await upgrade('lab owner upgrade to V2',owner,implementation2,true); await upgrade('non-contract target rejected',owner,outsider,false); assert.equal(states[0].revision_via_proxy,'1');assert.equal(states[2].revision_via_proxy,'2'); assert.equal(states[0].implementation_address,implementation1.toString());assert.equal(states[2].implementation_address,implementation2.toString()); assert.equal(states[0].proxy_address,states[2].proxy_address); assert.equal(states[0].proxy_runtime_keccak256,states[2].proxy_runtime_keccak256); assert.notEqual(states[0].implementation_runtime_keccak256,states[2].implementation_runtime_keccak256); assert.deepEqual(actions[1].events,['Upgraded']); const direct=await call(owner,implementation2,'upgradeToAndCall',[implementation1.toString(),'0x']); assert.ok(direct.execResult.exceptionError); const directError=abi.parseError(bytesToHex(direct.execResult.returnValue))?.name; assert.equal(directError,'UUPSUnauthorizedCallContext'); const result={schema_version:1,experiment_date:'2026-11-08',method:'Compiled minimal LabV1/LabV2 plus OpenZeppelin ERC1967Proxy/UUPSUpgradeable 5.4.0; runCall in isolated EthereumJS Shanghai memory state. Not signed transactions, RPC, a real-chain deployment, wallet operation, audit or safety assessment.',environment:{node:process.version,solc:solc.version(),openzeppelin:'5.4.0',ethereumjs_vm:'8.1.1',hardfork:'Shanghai'},implementation_slot:SLOT,source_sha256:crypto.createHash('sha256').update(source).digest('hex'),package_lock_sha256:crypto.createHash('sha256').update(fs.readFileSync('package-lock.json')).digest('hex'),import_sha256:imports,solidity_source:source,states,actions,direct_implementation_control:{success:false,error:directError},findings:{same_proxy_address:true,same_proxy_runtime_code:true,different_implementation_address:true,different_implementation_runtime_code:true,different_revision_result:true,unauthorized_and_invalid_target_preserve_state:true},limits:['No audit report or deployed protocol was authenticated. The first implementation is a comparison reference,not an audited contract.','Only this minimal immutable-owner UUPS wrapper/version was exercised. No storage migration,initializer,beacon,transparent proxy,multisig,timelock,oracle,bridge or vulnerability assessment.','The public documentation and local selected source explain delegation. Same proxy address/code cannot alone establish implementation identity or security.','Addresses and balances are isolated fictitious test accounts;no keys,real holdings,fees or network used.']}; if(process.argv.length>3)throw Error('Usage: node reproduce-proxy-identity.mjs [expected-result-file]'); if(process.argv[2]){ const expected=JSON.parse(fs.readFileSync(process.argv[2],'utf8')); // Node patch version is reported, but is not a contract-state observation. const comparable=x=>({...x,environment:{...x.environment,node:null}}); assert.deepEqual(comparable(result),comparable(expected),'Reproduced contract state differs from published result'); console.error('PASS: published contract states, hashes, reverts and findings match; Node version is separately reported.'); } console.log(JSON.stringify(result,null,2));