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

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

@@ -1,13 +1,14 @@
+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) {
@@ -32,12 +33,17 @@ 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',
+        )
       )
     }
 
@@ -60,104 +66,106 @@ 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 = []
+
+        // 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 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)
-        })
+        // 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`,
+          ),
+        )
 
-      // 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', 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 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)
+        // Then, generate the event class itself
+        let klass = tsCodegen.klass(fnClassName, {
+          export: true,
+          extends: 'ethereum.Call',
         })
-
-      // 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]
       })
-      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),
-      [],
-    )
+    return callFunctions
+      .reduce(
+        // flatten the array
+        (array, classes) => array.concat(classes),
+        [],
+      )
   }
 
   _generateEventTypes() {
@@ -168,124 +176,122 @@ 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`,
-        ),
-      )
+        // 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),
-      })
+        // 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`,
+        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})
+          }
+
+          tupleClasses.push(...paramObject.classes)
+        })
+
+        // 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)`,
+          ),
         )
-        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'
+          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)
           }
-          namesAndTypes.push({ name: paramObject.getter.name.slice(4), type: ethType })
-        }
-
-        tupleClasses.push(...paramObject.classes)
-      })
 
-      // 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})`
+          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`)
           }
-          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) {
@@ -357,10 +363,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}`
@@ -402,12 +408,14 @@ module.exports = class AbiCodeGenerator {
       export: true,
       extends: 'ethereum.SmartContract',
     })
-    let types = []
+    let types = immutable.List()
 
     klass.addMethod(
       tsCodegen.staticMethod(
         'bind',
-        [tsCodegen.param('address', typesCodegen.ascTypeForEthereum('address'))],
+        immutable.List([
+          tsCodegen.param('address', typesCodegen.ascTypeForEthereum('address')),
+        ]),
         tsCodegen.namedType(this.abi.name),
         `
         return new ${this.abi.name}('${this.abi.name}', address);
@@ -437,12 +445,12 @@ module.exports = class AbiCodeGenerator {
 
       // Disambiguate outputs with duplicate names
       let outputs = util.disambiguateNames({
-        values: member.get('outputs', []),
+        values: member.get('outputs', immutable.List()),
         getName: (input, index) => input.get('name') || `value${index}`,
         setName: (input, name) => input.set('name', name),
       })
 
-      if (member.get('outputs', []).size > 1) {
+      if (member.get('outputs', immutable.List()).size > 1) {
         simpleReturnType = false
 
         // Create a type dedicated to holding the return values
@@ -498,18 +506,16 @@ 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))
 
@@ -554,7 +560,7 @@ module.exports = class AbiCodeGenerator {
 
       // Disambiguate inputs with duplicate names
       let inputs = util.disambiguateNames({
-        values: member.get('inputs', []),
+        values: member.get('inputs', immutable.List()),
         getName: (input, index) => input.get('name') || `param${index}`,
         setName: (input, name) => input.set('name', name),
       })
@@ -723,7 +729,7 @@ module.exports = class AbiCodeGenerator {
     return this.abi.data.filter(
       member =>
         member.get('type') === 'function' &&
-        member.get('outputs', []).size !== 0 &&
+        member.get('outputs', immutable.List()).size !== 0 &&
         (allowedMutability.includes(member.get('stateMutability')) ||
           (member.get('stateMutability') === undefined && !member.get('payable', false))),
     )

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

@@ -1,5 +1,6 @@
 const fs = require('fs-extra')
 const path = require('path')
+const immutable = require('immutable')
 
 const ABI = require('../abi')
 const ts = require('../../../codegen/typescript')
@@ -215,31 +216,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', [ts.param('address', 'Address')]],
-        ['read', []],
-        ['try_read', []],
+        ['bind', immutable.List([ts.param('address', 'Address')])],
+        ['read', immutable.List()],
+        ['try_read', immutable.List()],
         [
           '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', []],
-        ['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')]],
+        ['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')])],
       ])
     })