@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/src/codegen/types/conversions.ts

@@ -0,0 +1,382 @@
+import immutable from 'immutable'
+
+/**
+ * ethereum.Value -> AssemblyScript conversions
+ */
+const ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT = [
+  // Scalar values
+
+  ['address', 'Address', (code: any) => `${code}.toAddress()`],
+  ['bool', 'boolean', (code: any) => `${code}.toBoolean()`],
+  ['byte', 'Bytes', (code: any) => `${code}.toBytes()`],
+  [
+    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?$/,
+    'Bytes',
+    (code: any) => `${code}.toBytes()`,
+  ],
+  [/^int(8|16|24|32)$/, 'i32', (code: any) => `${code}.toI32()`],
+  [/^uint(8|16|24)$/, 'i32', (code: any) => `${code}.toI32()`],
+  ['uint32', 'BigInt', (code: any) => `${code}.toBigInt()`],
+  [
+    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
+    'BigInt',
+    (code: any) => `${code}.toBigInt()`,
+  ],
+  ['string', 'string', (code: any) => `${code}.toString()`],
+
+  // Arrays
+
+  [/^address\[([0-9]+)?\]$/, 'Array<Address>', (code: any) => `${code}.toAddressArray()`],
+  [/^bool\[([0-9]+)?\]$/, 'Array<boolean>', (code: any) => `${code}.toBooleanArray()`],
+  [/^byte\[([0-9]+)?\]$/, 'Array<Bytes>', (code: any) => `${code}.toBytesArray()`],
+  [
+    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?\[([0-9]+)?\]$/,
+    'Array<Bytes>',
+    (code: any) => `${code}.toBytesArray()`,
+  ],
+  [/^int(8|16|24|32)\[([0-9]+)?\]$/, 'Array<i32>', (code: any) => `${code}.toI32Array()`],
+  [/^uint(8|16|24)\[([0-9]+)?\]$/, 'Array<i32>', (code: any) => `${code}.toI32Array()`],
+  [/^uint32\[([0-9]+)?\]$/, 'Array<BigInt>', (code: any) => `${code}.toBigIntArray()`],
+  [
+    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
+    'Array<BigInt>',
+    (code: any) => `${code}.toBigIntArray()`,
+  ],
+  [/^string\[([0-9]+)?\]$/, 'Array<string>', (code: any) => `${code}.toStringArray()`],
+
+  // Tuples
+
+  ['tuple', 'ethereum.Tuple', (code: any) => `${code}.toTuple()`],
+  [
+    /^tuple\[([0-9]+)?\]$/,
+    'Array<ethereum.Tuple>',
+    (code: any, type: any) => `${code}.toTupleArray<${type}>()`,
+  ],
+
+  // Multi dimensional arrays
+
+  [
+    /^address\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<Address>>',
+    (code: any) => `${code}.toAddressMatrix()`,
+  ],
+  [
+    /^bool\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<boolean>>',
+    (code: any) => `${code}.toBooleanMatrix()`,
+  ],
+  [
+    /^byte\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<Bytes>>',
+    (code: any) => `${code}.toBytesMatrix()`,
+  ],
+  [
+    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<Bytes>>',
+    (code: any) => `${code}.toBytesMatrix()`,
+  ],
+  [
+    /^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<i32>>',
+    (code: any) => `${code}.toI32Matrix()`,
+  ],
+  [
+    /^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<i32>>',
+    (code: any) => `${code}.toI32Matrix()`,
+  ],
+  [
+    /^uint32\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<BigInt>>',
+    (code: any) => `${code}.toBigIntMatrix()`,
+  ],
+  [
+    /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<BigInt>>',
+    (code: any) => `${code}.toBigIntMatrix()`,
+  ],
+  [
+    /^string\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<string>>',
+    (code: any) => `${code}.toStringMatrix()`,
+  ],
+  [
+    /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<ethereum.Tuple>>',
+    (code: any, type: any) => `${code}.toTupleMatrix<${type}>()`,
+  ],
+]
+
+/**
+ * AssemblyScript -> ethereum.Value conversions
+ *
+ * Note: The order and patterns for conversions in this direction differ slightly
+ * from ethereum.Value -> AssemblyScript, which is why there is a separate table
+ * for them.
+ */
+const ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE = [
+  // Scalar values
+
+  ['Address', 'address', (code: any) => `ethereum.Value.fromAddress(${code})`],
+  ['boolean', 'bool', (code: any) => `ethereum.Value.fromBoolean(${code})`],
+  ['Bytes', 'byte', (code: any) => `ethereum.Value.fromFixedBytes(${code})`],
+  ['Bytes', 'bytes', (code: any) => `ethereum.Value.fromBytes(${code})`],
+  [
+    'Bytes',
+    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)$/,
+    (code: any) => `ethereum.Value.fromFixedBytes(${code})`,
+  ],
+  ['i32', /^int(8|16|24|32)$/, (code: any) => `ethereum.Value.fromI32(${code})`],
+  [
+    'i32',
+    /^uint(8|16|24)$/,
+    (code: any) => `ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(${code}))`,
+  ],
+  [
+    'BigInt',
+    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
+    (code: any) => `ethereum.Value.fromSignedBigInt(${code})`,
+  ],
+  [
+    'BigInt',
+    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)$/,
+    (code: any) => `ethereum.Value.fromUnsignedBigInt(${code})`,
+  ],
+  ['string', 'string', (code: any) => `ethereum.Value.fromString(${code})`],
+
+  // Arrays
+
+  [
+    'Array<Address>',
+    /^address\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromAddressArray(${code})`,
+  ],
+  [
+    'Array<boolean>',
+    /^bool\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromBooleanArray(${code})`,
+  ],
+  [
+    'Array<Bytes>',
+    /^byte\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromFixedBytesArray(${code})`,
+  ],
+  [
+    'Array<Bytes>',
+    /bytes\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromBytesArray(${code})`,
+  ],
+  [
+    'Array<Bytes>',
+    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromFixedBytesArray(${code})`,
+  ],
+  [
+    'Array<i32>',
+    /^int(8|16|24|32)\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromI32Array(${code})`,
+  ],
+  [
+    'Array<i32>',
+    /^uint(8|16|24)\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromI32Array(${code})`,
+  ],
+  [
+    'Array<BigInt>',
+    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromSignedBigIntArray(${code})`,
+  ],
+  [
+    'Array<BigInt>',
+    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromUnsignedBigIntArray(${code})`,
+  ],
+  [
+    'Array<string>',
+    /^string\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromStringArray(${code})`,
+  ],
+
+  // Tuples
+
+  ['ethereum.Tuple', 'tuple', (code: any) => `ethereum.Value.fromTuple(${code})`],
+  [
+    'Array<ethereum.Tuple>',
+    /^tuple\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromTupleArray(${code})`,
+  ],
+
+  // Multi dimentional arrays
+
+  [
+    'Array<Array<Address>>',
+    /^address\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromAddressMatrix(${code})`,
+  ],
+  [
+    'Array<Array<boolean>>',
+    /^bool\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromBooleanMatrix(${code})`,
+  ],
+  [
+    'Array<Array<Bytes>>',
+    /^byte\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromFixedBytesMatrix(${code})`,
+  ],
+  [
+    'Array<Array<Bytes>>',
+    /bytes\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromBytesMatrix(${code})`,
+  ],
+  [
+    'Array<Array<Bytes>>',
+    /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromFixedBytesMatrix(${code})`,
+  ],
+  [
+    'Array<Array<i32>>',
+    /^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromI32Matrix(${code})`,
+  ],
+  [
+    'Array<Array<i32>>',
+    /^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromI32Matrix(${code})`,
+  ],
+  [
+    'Array<Array<BigInt>>',
+    /^int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromSignedBigIntMatrix(${code})`,
+  ],
+  [
+    'Array<Array<BigInt>>',
+    /^uint(32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromUnsignedBigIntMatrix(${code})`,
+  ],
+  [
+    'Array<Array<string>>',
+    /^string\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromStringMatrix(${code})`,
+  ],
+  [
+    'Array<Array<ethereum.Tuple>>',
+    /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    (code: any) => `ethereum.Value.fromTupleMatrix(${code})`,
+  ],
+]
+
+/**
+ * Value -> AssemblyScript conversions
+ */
+const VALUE_TO_ASSEMBLYSCRIPT = [
+  // Arrays
+
+  ['[Bytes]', 'Array<Bytes>', (code: any) => `${code}.toBytesArray()`],
+  ['[Boolean]', 'Array<boolean>', (code: any) => `${code}.toBooleanArray()`],
+  ['[Int]', 'Array<i32>', (code: any) => `${code}.toI32Array()`],
+  ['[BigInt]', 'Array<BigInt>', (code: any) => `${code}.toBigIntArray()`],
+  ['[ID]', 'Array<string>', (code: any) => `${code}.toStringArray()`],
+  ['[String]', 'Array<string>', (code: any) => `${code}.toStringArray()`],
+  ['[BigDecimal]', 'Array<BigDecimal>', (code: any) => `${code}.toBigDecimalArray()`],
+  [/\[.*\]/, 'Array<string>', (code: any) => `${code}.toStringArray()`],
+
+  // Scalar values
+
+  ['Bytes', 'Bytes', (code: any) => `${code}.toBytes()`],
+  ['Boolean', 'boolean', (code: any) => `${code}.toBoolean()`],
+  ['Int', 'i32', (code: any) => `${code}.toI32()`],
+  ['BigInt', 'BigInt', (code: any) => `${code}.toBigInt()`],
+  ['ID', 'string', (code: any) => `${code}.toString()`],
+  ['String', 'string', (code: any) => `${code}.toString()`],
+  ['BigDecimal', 'BigDecimal', (code: any) => `${code}.toBigDecimal()`],
+  [/.*/, 'string', (code: any) => `${code}.toString()`],
+]
+
+/**
+ * AssemblyScript -> Value conversions
+ *
+ * Note: The order and patterns for conversions in this direction differ slightly
+ * from Value -> AssemblyScript, which is why there is a separate table
+ * for them.
+ */
+const ASSEMBLYSCRIPT_TO_VALUE = [
+  // Matrices
+
+  ['Array<Array<Address>>', '[[Bytes]]', (code: any) => `Value.fromBytesMatrix(${code})`],
+  ['Array<Array<Bytes>>', '[[Bytes]]', (code: any) => `Value.fromBytesMatrix(${code})`],
+  [
+    'Array<Array<boolean>>',
+    '[[Boolean]]',
+    (code: any) => `Value.fromBooleanMatrix(${code})`,
+  ],
+  ['Array<Array<i32>>', '[[Int]]', (code: any) => `Value.fromI32Matrix(${code})`],
+  [
+    'Array<Array<BigInt>>',
+    '[[BigInt]]',
+    (code: any) => `Value.fromBigIntMatrix(${code})`,
+  ],
+  [
+    'Array<Array<string>>',
+    '[[String]]',
+    (code: any) => `Value.fromStringMatrix(${code})`,
+  ],
+  ['Array<Array<string>>', '[[ID]]', (code: any) => `Value.fromStringMatrix(${code})`],
+  [
+    'Array<Array<BigDecimal>>',
+    '[[BigDecimal]]',
+    (code: any) => `Value.fromBigDecimalMatrix(${code})`,
+  ],
+  [
+    'Array<Array<string>>',
+    /\[\[.*\]\]/,
+    (code: any) => `Value.fromStringMatrix(${code})`,
+  ],
+  ['Array<Array<string | null>>', null, (code: any) => `Value.fromStringMatrix(${code})`], // is this overwriting the Array null below?
+
+  // Arrays
+
+  ['Array<Address>', '[Bytes]', (code: any) => `Value.fromBytesArray(${code})`],
+  ['Array<Bytes>', '[Bytes]', (code: any) => `Value.fromBytesArray(${code})`],
+  ['Array<boolean>', '[Boolean]', (code: any) => `Value.fromBooleanArray(${code})`],
+  ['Array<i32>', '[Int]', (code: any) => `Value.fromI32Array(${code})`],
+  ['Array<BigInt>', '[BigInt]', (code: any) => `Value.fromBigIntArray(${code})`],
+  ['Array<string>', '[String]', (code: any) => `Value.fromStringArray(${code})`],
+  ['Array<string>', '[ID]', (code: any) => `Value.fromStringArray(${code})`],
+  [
+    'Array<BigDecimal>',
+    '[BigDecimal]',
+    (code: any) => `Value.fromBigDecimalArray(${code})`,
+  ],
+  ['Array<string>', /\[.*\]/, (code: any) => `Value.fromStringArray(${code})`],
+  ['Array<string | null>', null, (code: any) => `Value.fromStringArray(${code})`],
+
+  // Scalar values
+
+  ['Address', 'Bytes', (code: any) => `Value.fromBytes(${code})`],
+  ['Bytes', 'Bytes', (code: any) => `Value.fromBytes(${code})`],
+  ['boolean', 'Boolean', (code: any) => `Value.fromBoolean(${code})`],
+  ['i32', 'Int', (code: any) => `Value.fromI32(${code})`],
+  ['BigInt', 'BigInt', (code: any) => `Value.fromBigInt(${code})`],
+  ['string', 'String', (code: any) => `Value.fromString(${code})`],
+  ['string', 'ID', (code: any) => `Value.fromString(${code})`],
+  ['BigDecimal', 'BigDecimal', (code: any) => `Value.fromBigDecimal(${code})`],
+  ['string', /.*/, (code: any) => `Value.fromString(${code})`],
+]
+
+const CONVERSIONS = {
+  ethereum: {
+    AssemblyScript: ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT,
+  },
+  AssemblyScript: {
+    ethereum: ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE,
+    Value: ASSEMBLYSCRIPT_TO_VALUE,
+  },
+  Value: {
+    AssemblyScript: VALUE_TO_ASSEMBLYSCRIPT,
+  },
+} as const
+
+/**
+ * Type conversions
+ */
+export default immutable.fromJS(CONVERSIONS)

package/src/codegen/types/index.js

@@ -1,6 +1,6 @@
-const immutable = require('immutable')
+import immutable from 'immutable'
 
-const TYPE_CONVERSIONS = require('./conversions')
+import TYPE_CONVERSIONS from './conversions'
 
 // Conversion utilities
 
@@ -72,8 +72,7 @@ const ascTypeForProtocol = (protocol, protocolType) =>
   findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type'])
 
 // TODO: this can be removed/replaced by the function above
-const ascTypeForEthereum = ethereumType =>
-  ascTypeForProtocol('ethereum', ethereumType)
+const ascTypeForEthereum = ethereumType => ascTypeForProtocol('ethereum', ethereumType)
 
 const ethereumTypeForAsc = ascType =>
   findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type'])
@@ -99,16 +98,14 @@ const valueToAsc = (code, valueType) =>
 const valueFromAsc = (code, valueType) =>
   findConversionToType('AssemblyScript', 'Value', valueType).get('convert')(code)
 
-module.exports = {
+export {
   // protocol <-> AssemblyScript
   ascTypeForProtocol,
-
   // ethereum <-> AssemblyScript
   ascTypeForEthereum,
   ethereumTypeForAsc,
   ethereumToAsc,
   ethereumFromAsc,
-
   // Value <-> AssemblyScript
   ascTypeForValue,
   valueTypeForAsc,

package/src/codegen/types/index.test.js

@@ -1,4 +1,4 @@
-const codegen = require('.')
+import * as codegen from '.'
 
 describe('ethereum.Value -> AssemblyScript', () => {
   // Scalar values
@@ -268,7 +268,9 @@ describe('ethereum.Value -> AssemblyScript', () => {
       expect(codegen.ascTypeForEthereum(`bytes${i}[][]`)).toBe('Array<Array<Bytes>>')
       expect(codegen.ascTypeForEthereum(`bytes${i}[6][]`)).toBe('Array<Array<Bytes>>')
       expect(codegen.ascTypeForEthereum(`bytes${i}[][7]`)).toBe('Array<Array<Bytes>>')
-      expect(codegen.ascTypeForEthereum(`bytes${i}[432][234]`)).toBe('Array<Array<Bytes>>')
+      expect(codegen.ascTypeForEthereum(`bytes${i}[432][234]`)).toBe(
+        'Array<Array<Bytes>>',
+      )
     }
   })
 
@@ -331,7 +333,9 @@ describe('ethereum.Value -> AssemblyScript', () => {
       expect(codegen.ascTypeForEthereum(`int${i}[][]`)).toBe('Array<Array<BigInt>>')
       expect(codegen.ascTypeForEthereum(`int${i}[7][]`)).toBe('Array<Array<BigInt>>')
       expect(codegen.ascTypeForEthereum(`int${i}[][7]`)).toBe('Array<Array<BigInt>>')
-      expect(codegen.ascTypeForEthereum(`int${i}[6833][3386]`)).toBe('Array<Array<BigInt>>')
+      expect(codegen.ascTypeForEthereum(`int${i}[6833][3386]`)).toBe(
+        'Array<Array<BigInt>>',
+      )
 
       expect(codegen.ethereumToAsc('x', `uint${i}[][]`)).toBe('x.toBigIntMatrix()')
       expect(codegen.ethereumToAsc('x', `uint${i}[23][]`)).toBe('x.toBigIntMatrix()')
@@ -341,7 +345,9 @@ describe('ethereum.Value -> AssemblyScript', () => {
       expect(codegen.ascTypeForEthereum(`uint${i}[][]`)).toBe('Array<Array<BigInt>>')
       expect(codegen.ascTypeForEthereum(`uint${i}[23][]`)).toBe('Array<Array<BigInt>>')
       expect(codegen.ascTypeForEthereum(`uint${i}[][32]`)).toBe('Array<Array<BigInt>>')
-      expect(codegen.ascTypeForEthereum(`uint${i}[467][764]`)).toBe('Array<Array<BigInt>>')
+      expect(codegen.ascTypeForEthereum(`uint${i}[467][764]`)).toBe(
+        'Array<Array<BigInt>>',
+      )
     }
   })
 

package/src/codegen/{typescript.js → typescript.ts}

@@ -1,8 +1,5 @@
-let immutable = require('immutable')
-let Map = immutable.Map
-
 class Param {
-  constructor(name, type) {
+  constructor(public name: string, public type: string) {
     this.name = name
     this.type = type
   }
@@ -13,7 +10,12 @@ class Param {
 }
 
 class Method {
-  constructor(name, params, returnType, body) {
+  constructor(
+    public name: string,
+    public params: string[],
+    public returnType: string,
+    public body: string,
+  ) {
     this.name = name
     this.params = params || []
     this.returnType = returnType
@@ -31,7 +33,12 @@ class Method {
 }
 
 class StaticMethod {
-  constructor(name, params, returnType, body) {
+  constructor(
+    public name: string,
+    public params: string[],
+    public returnType: string,
+    public body: string,
+  ) {
     this.name = name
     this.params = params || []
     this.returnType = returnType || 'void'
@@ -48,8 +55,18 @@ class StaticMethod {
   }
 }
 
+interface ClassOptions {
+  extends?: string
+  export?: boolean
+}
+
 class Class {
-  constructor(name, options) {
+  public extends: string | undefined
+  public methods: string[]
+  public members: any[]
+  public export: boolean
+
+  constructor(public name: string, options: ClassOptions) {
     this.name = name
     this.extends = options.extends
     this.methods = []
@@ -57,11 +74,11 @@ class Class {
     this.export = options.export || false
   }
 
-  addMember(member) {
+  addMember(member: any) {
     this.members.push(member)
   }
 
-  addMethod(method) {
+  addMethod(method: any) {
     this.methods.push(method)
   }
 
@@ -78,7 +95,7 @@ ${this.methods.map(method => method.toString()).join('')}
 }
 
 class ClassMember {
-  constructor(name, type) {
+  constructor(public name: string, public type: string) {
     this.name = name
     this.type = type
   }
@@ -89,7 +106,7 @@ class ClassMember {
 }
 
 class NamedType {
-  constructor(name) {
+  constructor(public name: string) {
     this.name = name
   }
 
@@ -123,7 +140,9 @@ class NamedType {
 }
 
 class ArrayType {
-  constructor(inner) {
+  public name: string
+
+  constructor(public inner: string) {
     this.inner = inner
     this.name = `Array<${inner.toString()}>`
   }
@@ -134,7 +153,7 @@ class ArrayType {
 }
 
 class NullableType {
-  constructor(inner) {
+  constructor(public inner: string) {
     this.inner = inner
   }
 
@@ -144,7 +163,7 @@ class NullableType {
 }
 
 class ModuleImports {
-  constructor(nameOrNames, module) {
+  constructor(public nameOrNames: string | string[], public module: string) {
     this.nameOrNames = nameOrNames
     this.module = module
   }
@@ -156,23 +175,24 @@ class ModuleImports {
   }
 }
 
-const namedType = name => new NamedType(name)
-const arrayType = name => new ArrayType(name)
-const param = (name, type) => new Param(name, type)
-const method = (name, params, returnType, body) =>
+const namedType = (name: string) => new NamedType(name)
+const arrayType = (name: string) => new ArrayType(name)
+const param = (name: string, type: string) => new Param(name, type)
+const method = (name: string, params: string[], returnType: string, body: string) =>
   new Method(name, params, returnType, body)
-const staticMethod = (name, params, returnType, body) =>
+const staticMethod = (name: string, params: string[], returnType: string, body: string) =>
   new StaticMethod(name, params, returnType, body)
-const klass = (name, options) => new Class(name, options)
-const klassMember = (name, type) => new ClassMember(name, type)
-const nullableType = type => new NullableType(type)
-const moduleImports = (nameOrNames, module) => new ModuleImports(nameOrNames, module)
+const klass = (name: string, options: ClassOptions) => new Class(name, options)
+const klassMember = (name: string, type: string) => new ClassMember(name, type)
+const nullableType = (type: string) => new NullableType(type)
+const moduleImports = (nameOrNames: string | string[], module: string) =>
+  new ModuleImports(nameOrNames, module)
 
 const GENERATED_FILE_NOTE = `
 // THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
 `
 
-module.exports = {
+export {
   // Types
   Param,
   Method,
@@ -183,7 +203,6 @@ module.exports = {
   NullableType,
   ArrayType,
   ModuleImports,
-
   // Code generators
   namedType,
   arrayType,
@@ -194,7 +213,6 @@ module.exports = {
   param,
   nullableType,
   moduleImports,
-
   // Utilities
   GENERATED_FILE_NOTE,
 }

package/src/codegen/util.js

@@ -43,7 +43,7 @@ const unrollTuple = ({ path, index, value }) =>
     )
   }, [])
 
-module.exports = {
+export {
   containsTupleType,
   disambiguateNames,
   isTupleType,

package/src/codegen/util.test.js

@@ -1,4 +1,4 @@
-const { disambiguateNames, unrollTuple } = require('./util')
+import { disambiguateNames, unrollTuple } from './util'
 
 describe('Codegen utilities', () => {
   test('Name disambiguation', () => {
@@ -64,7 +64,10 @@ describe('Codegen utilities', () => {
         value: {
           type: 'tuple',
           name: 'value',
-          components: [{ name: 'a', type: 'string' }, { name: 'b', type: 'uint256' }],
+          components: [
+            { name: 'a', type: 'string' },
+            { name: 'b', type: 'uint256' },
+          ],
         },
         path: ['value'],
         index: 0,