Merge pull request #4346 from trufflesuite/extract-web3-eth

Internal improvement: Remove web3-eth from decoder

Author: eggplantzzz

packages/decoder/lib/ProviderAdapter.ts

@@ -0,0 +1,185 @@
+import type { BlockSpecifier, RegularizedBlockSpecifier } from "./types";
+import type BN from "bn.js";
+import type { Provider } from "web3/providers";
+import { promisify } from "util";
+
+// lifted from @types/web3
+type Log = {
+    address: string;
+    data: string;
+    topics: string[];
+    logIndex: number;
+    transactionHash: string;
+    transactionIndex: number;
+    blockHash: string;
+    blockNumber: number;
+}
+type PastLogsOptions = {
+  toBlock?: string | number;
+  fromBlock?: string | number;
+  address?: string | string[];
+};
+type SendRequestArgs = {
+  method: string;
+  params: unknown[];
+};
+type Eip1193Provider = {
+  request: (options: { method: string; params?: unknown[] | object; }) => Promise<any>;
+}
+type Block = {
+  number: string;
+  hash: string;
+  parentHash: string;
+  mixHash: string;
+  nonce: string;
+  sha3Uncles: string;
+  logsBloom: string;
+  transactionsRoot: string;
+  stateRoot: string;
+  receiptsRoot: string;
+  miner: string;
+  difficulty: string;
+  totalDifficulty: string;
+  extraData: string;
+  size: string;
+  gasLimit: string;
+  gasUsed: string;
+  timestamp: string;
+  transactions: string[];
+  uncles: string[];
+}
+const stringWhitelist = [
+  "latest",
+  "pending",
+  "genesis",
+  "earliest"
+];
+
+const formatBlockSpecifier = (block: BlockSpecifier): string => {
+  if (typeof block === "string" && stringWhitelist.includes(block)) {
+    // block is one of 'latest', 'pending', 'earliest', or 'genesis'
+    return block === "genesis" ?
+      // convert old web3 input format which uses 'genesis'
+      "earliest" :
+      block;
+  } else if (typeof block === "string" && !isNaN(parseInt(block))) {
+    // block is a string representation of a number
+    if (block.startsWith("0x")) return block;
+    // convert to hex and add '0x' prefix in case block is decimal
+    return `0x${parseInt(block).toString(16)}`;
+  } else if (typeof block === "number") {
+    return `0x${block.toString(16)}`;
+  } else {
+    throw new Error(
+      "The block specified must be a number or one of the strings 'latest'," +
+      "'pending', or 'earliest'."
+    );
+  }
+};
+
+export class ProviderAdapter {
+  public provider: Provider | Eip1193Provider;
+
+  constructor (provider: Provider | Eip1193Provider) {
+    this.provider = provider;
+  }
+
+  private async sendRequest ({
+    method,
+    params
+  }: SendRequestArgs): Promise<any> {
+    if (!this.provider) {
+      throw new Error("There is not a valid provider present.")
+    }
+    // check to see if the provider is compliant with eip1193
+    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md
+    if ("request" in this.provider) {
+      return (await this.provider.request({ method, params })).result;
+    } else {
+      const sendMethod = promisify(this.provider.send).bind(this.provider);
+      return (await sendMethod({
+        jsonrpc: "2.0",
+        id: new Date().getTime(),
+        method,
+        params
+      })).result;
+    }
+  }
+
+  public async getCode (address: string, block: RegularizedBlockSpecifier): Promise<string> {
+    const blockToFetch = formatBlockSpecifier(block);
+    return await this.sendRequest({
+      method: "eth_getCode",
+      params: [
+        address,
+        blockToFetch
+      ]
+    });
+  }
+
+  public async getBlockByNumber (block: BlockSpecifier): Promise<Block> {
+    const blockToFetch = formatBlockSpecifier(block);
+    return await this.sendRequest({
+      method: "eth_getBlockByNumber",
+      params: [ blockToFetch, false ]
+    });
+  }
+
+  public async getPastLogs ({ address, fromBlock, toBlock }: PastLogsOptions): Promise<Log[]> {
+    return await this.sendRequest({
+      method: "eth_getLogs",
+      params: [{ fromBlock, toBlock, address }]
+    });
+  }
+
+  public async getNetworkId (): Promise<string> {
+    return await this.sendRequest({
+      method: "net_version",
+      params: []
+    });
+  }
+
+  public async getBlockNumber (): Promise<number> {
+    const result = await this.sendRequest({
+      method: "eth_blockNumber",
+      params: []
+    });
+    // return decimal
+    return parseInt(result);
+  }
+
+  public async getBalance (address: string, block: BlockSpecifier): Promise<string> {
+    const result = await this.sendRequest({
+      method: "eth_getBalance",
+      params: [
+        address,
+        formatBlockSpecifier(block)
+      ]
+    });
+    // return value in decimal format
+    return parseInt(result).toString();
+  }
+
+  public async getTransactionCount (address: string, block: BlockSpecifier): Promise<string> {
+    const result = await this.sendRequest({
+      method: "eth_getTransactionCount",
+      params: [
+        address,
+        formatBlockSpecifier(block)
+      ]
+    });
+    // return value in decimal format
+    return parseInt(result).toString();
+  }
+
+  public async getStorageAt (address: string, position: BN, block: BlockSpecifier): Promise<string> {
+    return await this.sendRequest({
+      method: "eth_getStorageAt",
+      params: [
+        address,
+        position,
+        formatBlockSpecifier(block)
+      ]
+    });
+  }
+}

packages/decoder/lib/decoders.ts

@@ -22,7 +22,7 @@ import {
 } from "@truffle/codec";
 import * as Utils from "./utils";
 import type * as DecoderTypes from "./types";
-import Web3 from "web3";
+import Web3Utils from "web3-utils";
 import type { ContractObject as Artifact } from "@truffle/contract-schema/spec";
 import BN from "bn.js";
 import type { Provider } from "web3/providers";
@@ -33,10 +33,10 @@ import {
   InvalidAddressError,
   VariableNotFoundError,
   MemberNotFoundError,
-  ArrayIndexOutOfBoundsError,
   NoProviderError
 } from "./errors";
 import { Shims } from "@truffle/compile-common";
+import { ProviderAdapter } from "./ProviderAdapter";
 //sorry for the untyped import, but...
 const SourceMapUtils = require("@truffle/source-map-utils");
 
@@ -45,7 +45,7 @@ const SourceMapUtils = require("@truffle/source-map-utils");
  * @category Decoder
  */
 export class ProjectDecoder {
-  private web3: Web3;
+  private providerAdapter: ProviderAdapter;
 
   private compilations: Compilations.Compilation[];
   private contexts: Contexts.Contexts = {}; //all contexts
@@ -72,7 +72,7 @@ export class ProjectDecoder {
     if (!provider) {
       throw new NoProviderError();
     }
-    this.web3 = new Web3(provider);
+    this.providerAdapter = new ProviderAdapter(provider);
     this.compilations = compilations;
     this.ensSettings = ensSettings || {};
     let allocationInfo: AbiData.Allocate.ContractAllocationInfo[];
@@ -133,7 +133,7 @@ export class ProjectDecoder {
   ): Promise<Uint8Array> {
     //if pending, ignore the cache
     if (block === "pending") {
-      return Conversion.toBytes(await this.web3.eth.getCode(address, block));
+      return Conversion.toBytes(await this.providerAdapter.getCode(address, block));
     }
 
     //otherwise, start by setting up any preliminary layers as needed
@@ -145,7 +145,7 @@ export class ProjectDecoder {
       return this.codeCache[block][address];
     }
     //otherwise, get it, cache it, and return it
-    let code = Conversion.toBytes(await this.web3.eth.getCode(address, block));
+    let code = Conversion.toBytes(await this.providerAdapter.getCode(address, block));
     this.codeCache[block][address] = code;
     return code;
   }
@@ -163,7 +163,7 @@ export class ProjectDecoder {
       return "pending";
     }
 
-    return (await this.web3.eth.getBlock(block)).number;
+    return parseInt((await this.providerAdapter.getBlockByNumber(block)).number);
   }
 
   /**
@@ -346,7 +346,7 @@ export class ProjectDecoder {
     const fromBlockNumber = await this.regularizeBlock(fromBlock);
     const toBlockNumber = await this.regularizeBlock(toBlock);
 
-    const logs = await this.web3.eth.getPastLogs({
+    const logs = await this.providerAdapter.getPastLogs({
       address,
       fromBlock: fromBlockNumber,
       toBlock: toBlockNumber
@@ -552,10 +552,10 @@ export class ProjectDecoder {
     address: string,
     block: DecoderTypes.BlockSpecifier = "latest"
   ): Promise<ContractInstanceDecoder> {
-    if (!Web3.utils.isAddress(address)) {
+    if (!Web3Utils.isAddress(address)) {
       throw new InvalidAddressError(address);
     }
-    address = Web3.utils.toChecksumAddress(address);
+    address = Web3Utils.toChecksumAddress(address);
     const blockNumber = await this.regularizeBlock(block);
     const deployedBytecode = Conversion.toHexString(
       await this.getCode(address, blockNumber)
@@ -610,8 +610,8 @@ export class ProjectDecoder {
   /**
    * @protected
    */
-  public getWeb3(): Web3 {
-    return this.web3;
+  public getProviderAdapter(): ProviderAdapter {
+    return this.providerAdapter;
   }
 
   /**
@@ -636,7 +636,7 @@ export class ProjectDecoder {
  * @category Decoder
  */
 export class ContractDecoder {
-  private web3: Web3;
+  private providerAdapter: ProviderAdapter;
 
   private contexts: Contexts.Contexts; //note: this is deployed contexts only!
 
@@ -669,7 +669,7 @@ export class ContractDecoder {
     this.contract = contract;
     this.compilation = compilation;
     this.projectDecoder = projectDecoder;
-    this.web3 = projectDecoder.getWeb3();
+    this.providerAdapter = projectDecoder.getProviderAdapter();
     this.contexts = projectDecoder.getDeployedContexts();
     this.userDefinedTypes = this.projectDecoder.getUserDefinedTypes();
 
@@ -751,7 +751,7 @@ export class ContractDecoder {
    * @protected
    */
   public async init(): Promise<void> {
-    this.contractNetwork = (await this.web3.eth.net.getId()).toString();
+    this.contractNetwork = await this.providerAdapter.getNetworkId();
   }
 
   private get context(): Contexts.Context {
@@ -1002,7 +1002,7 @@ export class ContractDecoder {
  * @category Decoder
  */
 export class ContractInstanceDecoder {
-  private web3: Web3;
+  private providerAdapter: ProviderAdapter;
 
   private compilation: Compilations.Compilation;
   private contract: Compilations.Contract;
@@ -1036,12 +1036,12 @@ export class ContractInstanceDecoder {
   constructor(contractDecoder: ContractDecoder, address?: string) {
     this.contractDecoder = contractDecoder;
     this.projectDecoder = this.contractDecoder.getProjectDecoder();
-    this.web3 = this.projectDecoder.getWeb3();
+    this.providerAdapter = this.projectDecoder.getProviderAdapter();
     if (address !== undefined) {
-      if (!Web3.utils.isAddress(address)) {
+      if (!Web3Utils.isAddress(address)) {
         throw new InvalidAddressError(address);
       }
-      this.contractAddress = Web3.utils.toChecksumAddress(address);
+      this.contractAddress = Web3Utils.toChecksumAddress(address);
     }
 
     this.referenceDeclarations = this.projectDecoder.getReferenceDeclarations();
@@ -1076,7 +1076,7 @@ export class ContractInstanceDecoder {
     this.contractCode = Conversion.toHexString(
       await this.getCode(
         this.contractAddress,
-        await this.web3.eth.getBlockNumber() //not "latest" because regularized
+        await this.providerAdapter.getBlockNumber() //not "latest" because regularized
       )
     );
 
@@ -1253,10 +1253,10 @@ export class ContractInstanceDecoder {
       address: this.contractAddress,
       code: this.contractCode,
       balanceAsBN: new BN(
-        await this.web3.eth.getBalance(this.contractAddress, blockNumber)
+        await this.providerAdapter.getBalance(this.contractAddress, blockNumber)
       ),
       nonceAsBN: new BN(
-        await this.web3.eth.getTransactionCount(
+        await this.providerAdapter.getTransactionCount(
           this.contractAddress,
           blockNumber
         )
@@ -1383,7 +1383,7 @@ export class ContractInstanceDecoder {
     //if pending, bypass the cache
     if (block === "pending") {
       return Conversion.toBytes(
-        await this.web3.eth.getStorageAt(address, slot, block),
+        await this.providerAdapter.getStorageAt(address, slot, block),
         Codec.Evm.Utils.WORD_SIZE
       );
     }
@@ -1401,7 +1401,7 @@ export class ContractInstanceDecoder {
     }
     //otherwise, get it, cache it, and return it
     let word = Conversion.toBytes(
-      await this.web3.eth.getStorageAt(address, slot, block),
+      await this.providerAdapter.getStorageAt(address, slot, block),
       Codec.Evm.Utils.WORD_SIZE
     );
     this.storageCache[block][address][slot.toString()] = word;

packages/decoder/lib/types.ts

@@ -1,4 +1,5 @@
 import type BN from "bn.js";
+import type Web3 from "web3";
 import type { ContractObject as Artifact } from "@truffle/contract-schema/spec";
 import type {
   Format,
@@ -9,7 +10,6 @@ import type {
   ExtrasAllowed
 } from "@truffle/codec";
 import type { Provider } from "web3/providers";
-import type Web3 from "web3";
 
 //StateVariable used to be defined here, so let's continue
 //to export it