The wire decoder (in-house transaction and event decoding)

packages/truffle-decode-utils/package.json → packages/truffle-codec-utils/package.json

@@ -1,14 +1,13 @@
 {
-  "name": "truffle-decode-utils",
+  "name": "truffle-codec-utils",
   "version": "1.0.14",
-  "description": "Utilities for decoding data from the EVM",
+  "description": "Utilities for decoding data from the EVM or encoding it for the EVM",
   "dependencies": {
     "bn.js": "^4.11.8",
     "lodash.clonedeep": "^4.5.0",
     "lodash.escaperegexp": "^4.1.2",
     "semver": "^6.1.1",
-    "web3": "1.0.0-beta.37",
-    "web3-eth-abi": "1.0.0-beta.52"
+    "web3": "1.0.0-beta.37"
   },
   "main": "dist/index.js",
   "types": "src/index.ts",
@@ -18,13 +17,13 @@
     "start": "node_modules/.bin/tsc --watch",
     "test": "echo \"No test specified\" && exit 0;"
   },
-  "repository": "https://github.com/trufflesuite/truffle/tree/master/packages/truffle-decode-utils",
+  "repository": "https://github.com/trufflesuite/truffle/tree/master/packages/truffle-codec-utils",
   "author": "Truffle Suite <[email protected]>",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/trufflesuite/truffle-decode-utils/issues"
+    "url": "https://github.com/trufflesuite/truffle-codec-utils/issues"
   },
-  "homepage": "https://github.com/trufflesuite/truffle-decode-utils#readme",
+  "homepage": "https://github.com/trufflesuite/truffle-codec-utils#readme",
   "publishConfig": {
     "access": "public"
   },
@@ -33,7 +32,9 @@
     "@types/lodash.clonedeep": "^4.5.4",
     "@types/lodash.escaperegexp": "^4.1.6",
     "@types/semver": "^6.0.0",
-    "@types/web3": "^1.0.5",
+    "@types/web3": "^1.0.19",
+    "truffle-contract-schema": "^3.0.11",
+    "json-schema-to-typescript": "^6.1.3",
     "typescript": "^3.5.1"
   },
   "gitHead": "b207efb3c1409746537293b3e0fc27350029188e"

packages/truffle-codec-utils/src/abi.ts

@@ -0,0 +1,174 @@
+import debugModule from "debug";
+const debug = debugModule("codec-utils:abi");
+
+import { Abi as SchemaAbi } from "truffle-contract-schema/spec";
+import { EVM as EVMUtils } from "./evm";
+import { AstDefinition, AstReferences, Mutability } from "./ast";
+import { Definition as DefinitionUtils } from "./definition";
+import Web3 from "web3";
+
+//NOTE: SchemaAbi is kind of loose and a pain to use.
+//So we'll generally coerce things to Abi before use.
+//(we combine this with adding a "function" tag for
+//entries that lack it)
+
+export namespace AbiUtils {
+
+  export type Abi = AbiEntry[];
+
+  export type AbiEntry = FunctionAbiEntry | ConstructorAbiEntry | FallbackAbiEntry | EventAbiEntry;
+
+  export interface FunctionAbiEntry {
+    type: "function";
+    name: string;
+    inputs: AbiParameter[];
+    outputs: AbiParameter[];
+    stateMutability?: Mutability; //only in newer ones
+    constant?: boolean; //only in older ones
+    payable?: boolean; //only in older ones
+  }
+
+  export interface ConstructorAbiEntry {
+    type: "constructor";
+    inputs: AbiParameter[];
+    stateMutability?: "payable" | "nonpayable"; //only in newer ones
+    payable?: boolean; //only in older ones
+  }
+
+  export interface FallbackAbiEntry {
+    type: "fallback";
+    stateMutability?: "payable" | "nonpayable"; //only in newer ones
+    payable?: boolean; //only in older ones
+  }
+
+  export interface EventAbiEntry {
+    type: "event";
+    name: string;
+    inputs: AbiParameter[];
+    anonymous: boolean;
+  }
+
+  export interface AbiParameter {
+    name: string;
+    type: string;
+    indexed?: boolean; //only present for inputs
+    components?: AbiParameter[]; //only preset for tuples (structs)
+  }
+
+  export interface FunctionAbiBySelectors {
+    [selector: string]: FunctionAbiEntry
+  }
+
+  export function schemaAbiToAbi(abiLoose: SchemaAbi): Abi {
+    return abiLoose.map(
+      entry => entry.type
+        ? <AbiEntry> entry
+        : <AbiEntry> {type: "function", ...entry}
+    );
+  }
+
+  //note the return value only includes functions!
+  export function computeSelectors(abi: Abi | undefined): FunctionAbiBySelectors | undefined {
+    if(abi === undefined) {
+      return undefined;
+    }
+    return Object.assign({},
+      ...abi.filter(
+        (abiEntry: AbiEntry) => abiEntry.type === "function"
+      ).map(
+        (abiEntry: FunctionAbiEntry) => ({ [abiSelector(abiEntry)]: abiEntry })
+      )
+    )
+  }
+
+  //does this ABI have a payable fallback function?
+  export function abiHasPayableFallback(abi: Abi | undefined): boolean | undefined {
+    if(abi === undefined) {
+      return undefined;
+    }
+    return abi.some(
+      (abiEntry: AbiEntry) =>
+        abiEntry.type === "fallback" && abiMutability(abiEntry) === "payable"
+    );
+  }
+
+  //shim for old abi versions
+  function abiMutability(abiEntry: FunctionAbiEntry | ConstructorAbiEntry | FallbackAbiEntry): Mutability {
+    if(abiEntry.stateMutability !== undefined) {
+      return abiEntry.stateMutability;
+    }
+    if(abiEntry.payable) {
+      return "payable";
+    }
+    if(abiEntry.type === "function" && abiEntry.constant) {
+      return "view";
+    }
+    return "nonpayable";
+  }
+
+  //NOTE: this function returns the written out SIGNATURE, not the SELECTOR
+  export function abiSignature(abiEntry: FunctionAbiEntry | EventAbiEntry): string {
+    return abiEntry.name + abiTupleSignature(abiEntry.inputs);
+  }
+
+  export function abiTupleSignature(parameters: AbiParameter[]): string {
+    let components = parameters.map(abiTypeSignature);
+    return "(" + components.join(",") + ")";
+  }
+
+  function abiTypeSignature(parameter: AbiParameter): string {
+    let tupleMatch = parameter.type.match(/tuple(.*)/);
+    if(tupleMatch === null) { //does not start with "tuple"
+      return parameter.type;
+    }
+    else {
+      let tail = tupleMatch[1]; //everything after "tuple"
+      let tupleSignature = abiTupleSignature(parameter.components);
+      return tupleSignature + tail;
+    }
+  }
+
+  export function abiSelector(abiEntry: FunctionAbiEntry | EventAbiEntry): string {
+    let signature = abiSignature(abiEntry);
+    //NOTE: web3's soliditySha3 has a problem if the empty
+    //string is passed in.  Fortunately, that should never happen here.
+    let hash = Web3.utils.soliditySha3({type: "string", value: signature});
+    switch(abiEntry.type) {
+      case "event":
+        return hash;
+      case "function":
+        return hash.slice(0, 2 + 2 * EVMUtils.SELECTOR_SIZE); //arithmetic to account for hex string
+    }
+  }
+
+  //note: undefined does not match itself :P
+  export function abisMatch(entry1: AbiEntry | undefined, entry2: AbiEntry | undefined): boolean {
+    //we'll consider two abi entries to match if they have the same
+    //type, name (if applicable), and inputs (if applicable).
+    //since there's already a signature function, we can just use that.
+    if(!entry1 || !entry2) {
+      return false;
+    }
+    if(entry1.type !== entry2.type) {
+      return false;
+    }
+    switch(entry1.type) {
+      case "function":
+      case "event":
+        return abiSignature(entry1) === abiSignature(<FunctionAbiEntry|EventAbiEntry>entry2);
+      case "constructor":
+        return abiTupleSignature(entry1.inputs) === abiTupleSignature((<ConstructorAbiEntry>entry2).inputs);
+      case "fallback":
+        return true;
+    }
+  }
+
+  export function definitionMatchesAbi(abiEntry: AbiEntry, definition: AstDefinition, referenceDeclarations: AstReferences): boolean {
+    return abisMatch(abiEntry, DefinitionUtils.definitionToAbi(definition, referenceDeclarations));
+  }
+
+  export function topicsCount(abiEntry: EventAbiEntry): number {
+    let selectorCount = abiEntry.anonymous ? 0 : 1; //if the event is not anonymous, we must account for the selector
+    return abiEntry.inputs.filter(({ indexed }) => indexed).length + selectorCount;
+  }
+}

packages/truffle-decode-utils/src/ast.ts → packages/truffle-codec-utils/src/ast.ts

@@ -31,6 +31,12 @@ export interface AstDefinition {
   //things
   stateMutability?: Mutability;
   referencedDeclaration?: any;
+  parameters?: {
+    parameters: AstDefinition[];
+  };
+  returnParameters?: {
+    parameters: AstDefinition[];
+  };
   parameterTypes?: {
     parameters: AstDefinition[];
   };
@@ -39,6 +45,8 @@ export interface AstDefinition {
   };
   keyType?: AstDefinition;
   valueType?: AstDefinition;
+  indexed?: boolean;
+  anonymous?: boolean;
   contractKind?: ContractKind;
   isConstructor?: boolean;
   [k: string]: any;

packages/truffle-codec-utils/src/compiler.ts

@@ -0,0 +1,6 @@
+export interface CompilerVersion {
+  name?: string;
+  version?: string;
+  //NOTE: both these should really be present,
+  //but they need to be optional for compilation reasons
+}

packages/truffle-decode-utils/src/constants.ts → packages/truffle-codec-utils/src/constants.ts

@@ -3,7 +3,7 @@ import BN from "bn.js";
 export namespace Constants {
   export const WORD_SIZE = 0x20;
   export const ADDRESS_SIZE = 20;
-  export const SELECTOR_SIZE = 4;
+  export const SELECTOR_SIZE = 4; //function selectors, not event selectors
   export const PC_SIZE = 4;
   export const MAX_WORD = new BN(-1).toTwos(WORD_SIZE * 8);
   export const ZERO_ADDRESS = "0x" + "00".repeat(ADDRESS_SIZE);