import debugModule from "debug"; const debug = debugModule("debugger:web3:adapter"); import Web3 from "web3"; import * as Codec from "@truffle/codec"; import ENS, { getEnsAddress } from "@ensdomains/ensjs"; import { promisify } from "util"; export default class Web3Adapter { constructor(provider, ensOptions) { this.web3 = new Web3(provider); this.ensRegistryAddress = ensOptions.registryAddress; //note: may be null to turn off resolution } async init() { debug("initting; registry = %o", this.ensRegistryAddress); if (this.ensRegistryAddress === undefined) { const networkId = await this.web3.eth.net.getId(); this.ensRegistryAddress = getEnsAddress(networkId); } if (this.ensRegistryAddress) { //not an else! can be set up above! debug("setting up"); this.ens = new ENS({ provider: this.web3.currentProvider, ensAddress: this.ensRegistryAddress }); } } async getTrace(txHash) { const provider = this.web3.currentProvider; //send *only* uses callbacks, so we use promsifiy to make things more readable //we also use bind here to prevent a problem that sometimes occurs where //provider.send ends up unable to call its own methods because `this` gets //set incorrectly const result = await promisify(provider.send.bind(provider))({ jsonrpc: "2.0", method: "debug_traceTransaction", id: Date.now(), params: [ txHash, { enableMemory: true, //recent geth versions require this option disableStorage: true //we no longer use storage } ] }); if (!result.result) { //we assume if there's no result then there is an error. //note: some nodes may return an error even if there is a //usable result, so we don't assume that the presence of //an error means we should throw an error, but rather check //for the absence of a result. throw new Error(result.error.message); } else { return result.result.structLogs; } } async getTransaction(txHash) { return await this.web3.eth.getTransaction(txHash); } async getReceipt(txHash) { return await this.web3.eth.getTransactionReceipt(txHash); } async getBlock(blockNumberOrHash) { return await this.web3.eth.getBlock(blockNumberOrHash); } async getChainId() { return await this.web3.eth.getChainId(); } async getExistingStorage(address, slot, blockHash, txIndex) { debug("slot: %O", slot); const provider = this.web3.currentProvider; const hashedSlot = Web3.utils.soliditySha3({ type: "bytes", value: slot }); //note: see comment in getTrace for why we do this thing with bind const result = await promisify(provider.send.bind(provider))({ jsonrpc: "2.0", method: "debug_storageRangeAt", id: Date.now(), params: [ blockHash, txIndex, address, hashedSlot, 1 //we only want the one slot ] }); //again, see above for an explanation of the logic here if (result.result) { const storage = result.result.storage; debug("hashedSlot: %O", hashedSlot); debug("storage: %O", storage); debug("found? %O", hashedSlot in storage); if (hashedSlot in storage) { return storage[hashedSlot].value; } else { const zeroWord = "0x" + "00".repeat(Codec.Evm.Utils.WORD_SIZE); return zeroWord; } } else { throw new Error(result.error.message); } } /** * getDeployedCode - get the deployed code for an address from the client * NOTE: the block argument is optional * @param {String} address * @return {String} deployedBinary */ async getDeployedCode(address, block) { debug("getting deployed code for %s", address); let code = await this.web3.eth.getCode(address, block); return code === "0x0" ? "0x" : code; } async reverseEnsResolve(address) { if (!this.ens) { debug("no ens you fool!"); return null; } try { debug("addr: %s", address); //unfortunately, ensjs will throw on invalid UTF-8 //and we really don't want this erroring... so we'll just swallow it, //sorry :-/ return (await this.ens.getName(address)).name; } catch { return null; } } async ensResolve(name) { if (!this.ens) { return null; } try { //unfortunately, ensjs will error if the name contains certain characters //that aren't allowed in domain names. //and again, we really don't want this erroring, so we swallow it, sorry :-/ return await this.ens.name(name).getAddress(); } catch { return null; } } }