@graphprotocol/graph-cli 0.37.1 → 0.37.2-alpha-20221219142030-0cf2a37

package/src/protocols/ethereum/codegen/abi.js

@@ -1,14 +1,13 @@
-const immutable = require('immutable')
 const fs = require('fs')
 const yaml = require('yaml')
 const request = require('sync-request')
-const Web3EthAbi = require('web3-eth-abi');
+const Web3EthAbi = require('web3-eth-abi')
 
 const tsCodegen = require('../../../codegen/typescript')
 const typesCodegen = require('../../../codegen/types')
 const util = require('../../../codegen/util')
 
-const doFixtureCodegen = fs.existsSync('./fixtures.yaml');
+const doFixtureCodegen = fs.existsSync('./fixtures.yaml')
 
 module.exports = class AbiCodeGenerator {
   constructor(abi) {
@@ -33,17 +32,12 @@ module.exports = class AbiCodeGenerator {
           'BigInt',
         ],
         '@graphprotocol/graph-ts',
-      )
+      ),
     ]
 
     if (doFixtureCodegen) {
       imports.push(
-        tsCodegen.moduleImports(
-          [
-            'newMockEvent',
-          ],
-          'matchstick-as/assembly/index',
-        )
+        tsCodegen.moduleImports(['newMockEvent'], 'matchstick-as/assembly/index'),
       )
     }
 
@@ -66,106 +60,104 @@ module.exports = class AbiCodeGenerator {
       setName: (fn, name) => fn.set('_alias', name),
     })
 
-    callFunctions = callFunctions
-      .map(fn => {
-        let fnAlias = fn.get('_alias')
-        let fnClassName = `${fnAlias.charAt(0).toUpperCase()}${fnAlias.slice(1)}Call`
-        let tupleClasses = []
-
-        // First, generate a class with the input getters
-        let inputsClassName = fnClassName + '__Inputs'
-        let inputsClass = tsCodegen.klass(inputsClassName, { export: true })
-        inputsClass.addMember(tsCodegen.klassMember('_call', fnClassName))
-        inputsClass.addMethod(
-          tsCodegen.method(
-            `constructor`,
-            [tsCodegen.param(`call`, fnClassName)],
-            null,
-            `this._call = call`,
-          ),
-        )
+    callFunctions = callFunctions.map(fn => {
+      let fnAlias = fn.get('_alias')
+      let fnClassName = `${fnAlias.charAt(0).toUpperCase()}${fnAlias.slice(1)}Call`
+      let tupleClasses = []
 
-        // Generate getters and classes for function inputs
-        util
-          .disambiguateNames({
-            values: fn.get('inputs', immutable.List()),
-            getName: (input, index) => input.get('name') || `value${index}`,
-            setName: (input, name) => input.set('name', name),
-          })
-          .forEach((input, index) => {
-            let callInput = this._generateInputOrOutput(
-              input,
-              index,
-              fnClassName,
-              `call`,
-              `inputValues`,
-            )
-            inputsClass.addMethod(callInput.getter)
-            tupleClasses.push(...callInput.classes)
-          })
-
-        // Second, generate a class with the output getters
-        let outputsClassName = fnClassName + '__Outputs'
-        let outputsClass = tsCodegen.klass(outputsClassName, { export: true })
-        outputsClass.addMember(tsCodegen.klassMember('_call', fnClassName))
-        outputsClass.addMethod(
-          tsCodegen.method(
-            `constructor`,
-            [tsCodegen.param(`call`, fnClassName)],
-            null,
-            `this._call = call`,
-          ),
-        )
+      // First, generate a class with the input getters
+      let inputsClassName = fnClassName + '__Inputs'
+      let inputsClass = tsCodegen.klass(inputsClassName, { export: true })
+      inputsClass.addMember(tsCodegen.klassMember('_call', fnClassName))
+      inputsClass.addMethod(
+        tsCodegen.method(
+          `constructor`,
+          [tsCodegen.param(`call`, fnClassName)],
+          null,
+          `this._call = call`,
+        ),
+      )
 
-        // Generate getters and classes for function outputs
-        util
-          .disambiguateNames({
-            values: fn.get('outputs', immutable.List()),
-            getName: (output, index) => output.get('name') || `value${index}`,
-            setName: (output, name) => output.set('name', name),
-          })
-          .forEach((output, index) => {
-            let callInput = this._generateInputOrOutput(
-              output,
-              index,
-              fnClassName,
-              `call`,
-              `outputValues`,
-            )
-            outputsClass.addMethod(callInput.getter)
-            tupleClasses.push(...callInput.classes)
-          })
+      // Generate getters and classes for function inputs
+      util
+        .disambiguateNames({
+          values: fn.get('inputs', []),
+          getName: (input, index) => input.get('name') || `value${index}`,
+          setName: (input, name) => input.set('name', name),
+        })
+        .forEach((input, index) => {
+          let callInput = this._generateInputOrOutput(
+            input,
+            index,
+            fnClassName,
+            `call`,
+            `inputValues`,
+          )
+          inputsClass.addMethod(callInput.getter)
+          tupleClasses.push(...callInput.classes)
+        })
 
-        // Then, generate the event class itself
-        let klass = tsCodegen.klass(fnClassName, {
-          export: true,
-          extends: 'ethereum.Call',
+      // Second, generate a class with the output getters
+      let outputsClassName = fnClassName + '__Outputs'
+      let outputsClass = tsCodegen.klass(outputsClassName, { export: true })
+      outputsClass.addMember(tsCodegen.klassMember('_call', fnClassName))
+      outputsClass.addMethod(
+        tsCodegen.method(
+          `constructor`,
+          [tsCodegen.param(`call`, fnClassName)],
+          null,
+          `this._call = call`,
+        ),
+      )
+
+      // Generate getters and classes for function outputs
+      util
+        .disambiguateNames({
+          values: fn.get('outputs', []),
+          getName: (output, index) => output.get('name') || `value${index}`,
+          setName: (output, name) => output.set('name', name),
+        })
+        .forEach((output, index) => {
+          let callInput = this._generateInputOrOutput(
+            output,
+            index,
+            fnClassName,
+            `call`,
+            `outputValues`,
+          )
+          outputsClass.addMethod(callInput.getter)
+          tupleClasses.push(...callInput.classes)
         })
-        klass.addMethod(
-          tsCodegen.method(
-            `get inputs`,
-            [],
-            tsCodegen.namedType(inputsClassName),
-            `return new ${inputsClassName}(this)`,
-          ),
-        )
-        klass.addMethod(
-          tsCodegen.method(
-            `get outputs`,
-            [],
-            tsCodegen.namedType(outputsClassName),
-            `return new ${outputsClassName}(this)`,
-          ),
-        )
-        return [klass, inputsClass, outputsClass, ...tupleClasses]
-      })
 
-    return callFunctions
-      .reduce(
-        // flatten the array
-        (array, classes) => array.concat(classes),
-        [],
+      // Then, generate the event class itself
+      let klass = tsCodegen.klass(fnClassName, {
+        export: true,
+        extends: 'ethereum.Call',
+      })
+      klass.addMethod(
+        tsCodegen.method(
+          `get inputs`,
+          [],
+          tsCodegen.namedType(inputsClassName),
+          `return new ${inputsClassName}(this)`,
+        ),
+      )
+      klass.addMethod(
+        tsCodegen.method(
+          `get outputs`,
+          [],
+          tsCodegen.namedType(outputsClassName),
+          `return new ${outputsClassName}(this)`,
+        ),
       )
+      return [klass, inputsClass, outputsClass, ...tupleClasses]
+    })
+
+    return callFunctions.reduce(
+      // flatten the array
+      (array, classes) => array.concat(classes),
+      [],
+    )
   }
 
   _generateEventTypes() {
@@ -176,122 +168,124 @@ module.exports = class AbiCodeGenerator {
       setName: (event, name) => event.set('_alias', name),
     })
 
-    events = events
-      .map(event => {
-        let eventClassName = event.get('_alias')
-        let tupleClasses = []
+    events = events.map(event => {
+      let eventClassName = event.get('_alias')
+      let tupleClasses = []
 
-        // First, generate a class with the param getters
-        let paramsClassName = eventClassName + '__Params'
-        let paramsClass = tsCodegen.klass(paramsClassName, { export: true })
-        paramsClass.addMember(tsCodegen.klassMember('_event', eventClassName))
-        paramsClass.addMethod(
-          tsCodegen.method(
-            `constructor`,
-            [tsCodegen.param(`event`, eventClassName)],
-            null,
-            `this._event = event`,
-          ),
-        )
-
-        // Enumerate inputs with duplicate names
-        let inputs = util.disambiguateNames({
-          values: event.get('inputs'),
-          getName: (input, index) => input.get('name') || `param${index}`,
-          setName: (input, name) => input.set('name', name),
-        })
-
-        let namesAndTypes = []
-        inputs.forEach((input, index) => {
-          // Generate getters and classes for event params
-          let paramObject = this._generateInputOrOutput(
-            input,
-            index,
-            eventClassName,
-            `event`,
-            `parameters`,
-          )
-          paramsClass.addMethod(paramObject.getter)
-
-          // Fixture generation
-          if (doFixtureCodegen) {
-            let ethType = typesCodegen.ethereumTypeForAsc(paramObject.getter.returnType)
-            if (typeof ethType === typeof {} && (ethType.test("int256") || ethType.test("uint256"))) {
-              ethType = "int32"
-            }
-            namesAndTypes.push({name: paramObject.getter.name.slice(4), type: ethType})
-          }
+      // First, generate a class with the param getters
+      let paramsClassName = eventClassName + '__Params'
+      let paramsClass = tsCodegen.klass(paramsClassName, { export: true })
+      paramsClass.addMember(tsCodegen.klassMember('_event', eventClassName))
+      paramsClass.addMethod(
+        tsCodegen.method(
+          `constructor`,
+          [tsCodegen.param(`event`, eventClassName)],
+          null,
+          `this._event = event`,
+        ),
+      )
 
-          tupleClasses.push(...paramObject.classes)
-        })
+      // Enumerate inputs with duplicate names
+      let inputs = util.disambiguateNames({
+        values: event.get('inputs'),
+        getName: (input, index) => input.get('name') || `param${index}`,
+        setName: (input, name) => input.set('name', name),
+      })
 
-        // Then, generate the event class itself
-        let klass = tsCodegen.klass(eventClassName, {
-          export: true,
-          extends: 'ethereum.Event',
-        })
-        klass.addMethod(
-          tsCodegen.method(
-            `get params`,
-            [],
-            tsCodegen.namedType(paramsClassName),
-            `return new ${paramsClassName}(this)`,
-          ),
+      let namesAndTypes = []
+      inputs.forEach((input, index) => {
+        // Generate getters and classes for event params
+        let paramObject = this._generateInputOrOutput(
+          input,
+          index,
+          eventClassName,
+          `event`,
+          `parameters`,
         )
+        paramsClass.addMethod(paramObject.getter)
 
         // Fixture generation
         if (doFixtureCodegen) {
-          const args = yaml.parse(fs.readFileSync('./fixtures.yaml', 'utf8'))
-          const blockNumber = args['blockNumber']
-          const contractAddr = args['contractAddr']
-          const topic0 = args['topic0']
-          const apiKey = args['apiKey']
-          const url = `https://api.etherscan.io/api?module=logs&action=getLogs&fromBlock=${blockNumber}&toBlock=${blockNumber}&address=${contractAddr}&${topic0}=topic0&apikey=${apiKey}`;
-
-          let resp = request("GET", url)
-          let body = JSON.parse(resp.getBody("utf8"))
-          if (body.status === '0') {
-            throw new Error(body.result)
+          let ethType = typesCodegen.ethereumTypeForAsc(paramObject.getter.returnType)
+          if (
+            typeof ethType === typeof {} &&
+            (ethType.test('int256') || ethType.test('uint256'))
+          ) {
+            ethType = 'int32'
           }
+          namesAndTypes.push({ name: paramObject.getter.name.slice(4), type: ethType })
+        }
+
+        tupleClasses.push(...paramObject.classes)
+      })
 
-          let res = Web3EthAbi.decodeLog(
-            namesAndTypes,
-            body.result[0].data,
-            []
-          );
-
-          let stmnts = ""
-          for (let i = 0; i < namesAndTypes.length; i++) {
-            let code = '"' + res[i] + '"'
-            if (namesAndTypes[i].type.toString() == "address") {
-              code = `Address.fromString(${code})`
-            }
-            stmnts = stmnts.concat(`event.parameters.push(new ethereum.EventParam(\"${namesAndTypes[i].name}\", ${typesCodegen.ethereumFromAsc(code, namesAndTypes[i].type)}));`, `\n`)
+      // Then, generate the event class itself
+      let klass = tsCodegen.klass(eventClassName, {
+        export: true,
+        extends: 'ethereum.Event',
+      })
+      klass.addMethod(
+        tsCodegen.method(
+          `get params`,
+          [],
+          tsCodegen.namedType(paramsClassName),
+          `return new ${paramsClassName}(this)`,
+        ),
+      )
+
+      // Fixture generation
+      if (doFixtureCodegen) {
+        const args = yaml.parse(fs.readFileSync('./fixtures.yaml', 'utf8'))
+        const blockNumber = args['blockNumber']
+        const contractAddr = args['contractAddr']
+        const topic0 = args['topic0']
+        const apiKey = args['apiKey']
+        const url = `https://api.etherscan.io/api?module=logs&action=getLogs&fromBlock=${blockNumber}&toBlock=${blockNumber}&address=${contractAddr}&${topic0}=topic0&apikey=${apiKey}`
+
+        let resp = request('GET', url)
+        let body = JSON.parse(resp.getBody('utf8'))
+        if (body.status === '0') {
+          throw new Error(body.result)
+        }
+
+        let res = Web3EthAbi.decodeLog(namesAndTypes, body.result[0].data, [])
+
+        let stmnts = ''
+        for (let i = 0; i < namesAndTypes.length; i++) {
+          let code = '"' + res[i] + '"'
+          if (namesAndTypes[i].type.toString() == 'address') {
+            code = `Address.fromString(${code})`
           }
+          stmnts = stmnts.concat(
+            `event.parameters.push(new ethereum.EventParam(\"${
+              namesAndTypes[i].name
+            }\", ${typesCodegen.ethereumFromAsc(code, namesAndTypes[i].type)}));`,
+            `\n`,
+          )
+        }
 
-          klass.addMethod(
-            tsCodegen.staticMethod(
-              `mock${eventClassName}`,
-              [],
-              tsCodegen.namedType(eventClassName),
-              `
+        klass.addMethod(
+          tsCodegen.staticMethod(
+            `mock${eventClassName}`,
+            [],
+            tsCodegen.namedType(eventClassName),
+            `
               let event = changetype<${eventClassName}>(newMockEvent());
               ${stmnts}
               return event;
               `,
-            )
-          )
-        }
+          ),
+        )
+      }
 
-        return [klass, paramsClass, ...tupleClasses]
-      })
+      return [klass, paramsClass, ...tupleClasses]
+    })
 
-    return events
-      .reduce(
-        // flatten the array
-        (array, classes) => array.concat(classes),
-        [],
-      )
+    return events.reduce(
+      // flatten the array
+      (array, classes) => array.concat(classes),
+      [],
+    )
   }
 
   _generateInputOrOutput(inputOrOutput, index, parentClass, parentType, parentField) {
@@ -363,10 +357,10 @@ module.exports = class AbiCodeGenerator {
       `get ${name}`,
       [],
       util.isTupleMatrixType(type)
-      ? `Array<Array<${tupleClassName}>>`
-      : util.isTupleArrayType(type)
-      ? `Array<${tupleClassName}>`
-      : tupleClassName,
+        ? `Array<Array<${tupleClassName}>>`
+        : util.isTupleArrayType(type)
+        ? `Array<${tupleClassName}>`
+        : tupleClassName,
       `
       return ${
         isTupleType ? `changetype<${tupleClassName}>(${returnValue})` : `${returnValue}`
@@ -408,14 +402,12 @@ module.exports = class AbiCodeGenerator {
       export: true,
       extends: 'ethereum.SmartContract',
     })
-    let types = immutable.List()
+    let types = []
 
     klass.addMethod(
       tsCodegen.staticMethod(
         'bind',
-        immutable.List([
-          tsCodegen.param('address', typesCodegen.ascTypeForEthereum('address')),
-        ]),
+        [tsCodegen.param('address', typesCodegen.ascTypeForEthereum('address'))],
         tsCodegen.namedType(this.abi.name),
         `
         return new ${this.abi.name}('${this.abi.name}', address);
@@ -445,12 +437,12 @@ module.exports = class AbiCodeGenerator {
 
       // Disambiguate outputs with duplicate names
       let outputs = util.disambiguateNames({
-        values: member.get('outputs', immutable.List()),
+        values: member.get('outputs', []),
         getName: (input, index) => input.get('name') || `value${index}`,
         setName: (input, name) => input.set('name', name),
       })
 
-      if (member.get('outputs', immutable.List()).size > 1) {
+      if (member.get('outputs', []).size > 1) {
         simpleReturnType = false
 
         // Create a type dedicated to holding the return values
@@ -506,16 +498,18 @@ module.exports = class AbiCodeGenerator {
             ),
           )
           .forEach(member => returnType.addMember(member))
-        
+
         // Add getters to the type
         outputs
-          .map((output, index) =>
-            !!output.get('name') && tsCodegen.method(
-              `get${output.get('name')[0].toUpperCase()}${output.get('name').slice(1)}`,
-              [],
-              this._getTupleParamType(output, index, tupleResultParentType),
-              `return this.value${index};`
-            )
+          .map(
+            (output, index) =>
+              !!output.get('name') &&
+              tsCodegen.method(
+                `get${output.get('name')[0].toUpperCase()}${output.get('name').slice(1)}`,
+                [],
+                this._getTupleParamType(output, index, tupleResultParentType),
+                `return this.value${index};`,
+              ),
           )
           .forEach(method => !!method && returnType.addMethod(method))
 
@@ -560,7 +554,7 @@ module.exports = class AbiCodeGenerator {
 
       // Disambiguate inputs with duplicate names
       let inputs = util.disambiguateNames({
-        values: member.get('inputs', immutable.List()),
+        values: member.get('inputs', []),
         getName: (input, index) => input.get('name') || `param${index}`,
         setName: (input, name) => input.set('name', name),
       })
@@ -729,7 +723,7 @@ module.exports = class AbiCodeGenerator {
     return this.abi.data.filter(
       member =>
         member.get('type') === 'function' &&
-        member.get('outputs', immutable.List()).size !== 0 &&
+        member.get('outputs', []).size !== 0 &&
         (allowedMutability.includes(member.get('stateMutability')) ||
           (member.get('stateMutability') === undefined && !member.get('payable', false))),
     )

package/src/protocols/ethereum/codegen/abi.test.js

@@ -1,6 +1,5 @@
 const fs = require('fs-extra')
 const path = require('path')
-const immutable = require('immutable')
 
 const ABI = require('../abi')
 const ts = require('../../../codegen/typescript')
@@ -216,31 +215,31 @@ describe('ABI code generation', () => {
     test('Have correct parameters', () => {
       let contract = generatedTypes.find(type => type.name === 'Contract')
       expect(contract.methods.map(method => [method.name, method.params])).toEqual([
-        ['bind', immutable.List([ts.param('address', 'Address')])],
-        ['read', immutable.List()],
-        ['try_read', immutable.List()],
+        ['bind', [ts.param('address', 'Address')]],
+        ['read', []],
+        ['try_read', []],
         [
           'getProposal',
-          immutable.List([
+          [
             ts.param('proposalId', 'BigInt'),
             ts.param('param1', 'Contract__getProposalInputParam1Struct'),
-          ]),
+          ],
         ],
         [
           'try_getProposal',
-          immutable.List([
+          [
             ts.param('proposalId', 'BigInt'),
             ts.param('param1', 'Contract__getProposalInputParam1Struct'),
-          ]),
+          ],
         ],
-        ['getProposals', immutable.List()],
-        ['try_getProposals', immutable.List()],
-        ['overloaded', immutable.List([ts.param('param0', 'string')])],
-        ['try_overloaded', immutable.List([ts.param('param0', 'string')])],
-        ['overloaded1', immutable.List([ts.param('param0', 'BigInt')])],
-        ['try_overloaded1', immutable.List([ts.param('param0', 'BigInt')])],
-        ['overloaded2', immutable.List([ts.param('param0', 'Bytes')])],
-        ['try_overloaded2', immutable.List([ts.param('param0', 'Bytes')])],
+        ['getProposals', []],
+        ['try_getProposals', []],
+        ['overloaded', [ts.param('param0', 'string')]],
+        ['try_overloaded', [ts.param('param0', 'string')]],
+        ['overloaded1', [ts.param('param0', 'BigInt')]],
+        ['try_overloaded1', [ts.param('param0', 'BigInt')]],
+        ['overloaded2', [ts.param('param0', 'Bytes')]],
+        ['try_overloaded2', [ts.param('param0', 'Bytes')]],
       ])
     })