@graphprotocol/graph-cli 0.26.0 → 0.28.1

package/src/codegen/schema.js

@@ -5,6 +5,53 @@ const typesCodegen = require('./types')
 
 const List = immutable.List
 
+class IdField {
+  static BYTES = Symbol("Bytes")
+  static STRING = Symbol("String")
+
+  constructor(idField) {
+    const typeName = idField.getIn(['type', 'type', 'name', 'value'])
+    this.kind = typeName === "Bytes" ? IdField.BYTES : IdField.STRING
+  }
+
+  typeName() {
+    return this.kind === IdField.BYTES ? "Bytes" : "string"
+  }
+
+  gqlTypeName() {
+    return this.kind === IdField.BYTES ? "Bytes" : "String"
+  }
+
+  tsNamedType() {
+    return tsCodegen.namedType(this.typeName())
+  }
+
+  tsValueFrom() {
+    return this.kind === IdField.BYTES ? "Value.fromBytes(id)" : "Value.fromString(id)"
+  }
+
+  tsValueKind() {
+    return this.kind === IdField.BYTES ? "ValueKind.BYTES" : "ValueKind.STRING"
+  }
+
+  tsValueToString() {
+    return this.kind == IdField.BYTES ? "id.toBytes().toHexString()" : "id.toString()"
+  }
+
+  tsToString() {
+    return this.kind == IdField.BYTES ? "id.toHexString()" : "id"
+  }
+
+  static fromFields(fields) {
+    const idField = fields.find(field => field.getIn(['name', 'value']) === 'id')
+    return new IdField(idField)
+  }
+
+  static fromTypeDef(def) {
+    return IdField.fromFields(def.get("fields"))
+  }
+}
+
 module.exports = class SchemaCodeGenerator {
   constructor(schema) {
     this.schema = schema
@@ -52,12 +99,14 @@ module.exports = class SchemaCodeGenerator {
   _generateEntityType(def) {
     let name = def.getIn(['name', 'value'])
     let klass = tsCodegen.klass(name, { export: true, extends: 'Entity' })
+    const fields = def.get('fields')
+    const idField = IdField.fromFields(fields)
 
     // Generate and add a constructor
-    klass.addMethod(this._generateConstructor(name, def.get('fields')))
+    klass.addMethod(this._generateConstructor(name, fields))
 
     // Generate and add save() and getById() methods
-    this._generateStoreMethods(name).forEach(method => klass.addMethod(method))
+    this._generateStoreMethods(name, idField).forEach(method => klass.addMethod(method))
 
     // Generate and add entity field getters and setters
     def
@@ -107,19 +156,20 @@ module.exports = class SchemaCodeGenerator {
   }
 
   _generateConstructor(entityName, fields) {
+    const idField = IdField.fromFields(fields)
     return tsCodegen.method(
       'constructor',
-      [tsCodegen.param('id', tsCodegen.namedType('string'))],
+      [tsCodegen.param('id', idField.tsNamedType())],
       undefined,
       `
       super()
-      this.set('id', Value.fromString(id))
+      this.set('id', ${idField.tsValueFrom()})
       ${this._generateDefaultFieldValues(fields)}
       `,
     )
   }
 
-  _generateStoreMethods(entityName) {
+  _generateStoreMethods(entityName, idField) {
     return List.of(
       tsCodegen.method(
         'save',
@@ -127,23 +177,21 @@ module.exports = class SchemaCodeGenerator {
         tsCodegen.namedType('void'),
         `
         let id = this.get('id')
-        assert(id != null, 'Cannot save ${entityName} entity without an ID')
+        assert(id != null,
+               'Cannot save ${entityName} entity without an ID')
         if (id) {
-          assert(
-            id.kind == ValueKind.STRING,
-            'Cannot save ${entityName} entity with non-string ID. ' +
-            'Considering using .toHex() to convert the "id" to a string.'
-          )
-          store.set('${entityName}', id.toString(), this)
+          assert(id.kind == ${idField.tsValueKind()},
+                 \`Entities of type ${entityName} must have an ID of type ${idField.gqlTypeName()} but the id '\${id.displayData()}' is of type \${id.displayKind()}\`)
+          store.set('${entityName}', ${idField.tsValueToString()}, this)
         }`,
       ),
 
       tsCodegen.staticMethod(
         'load',
-        [tsCodegen.param('id', tsCodegen.namedType('string'))],
+        [tsCodegen.param('id', tsCodegen.namedType(idField.typeName()))],
         tsCodegen.nullableType(tsCodegen.namedType(entityName)),
         `
-        return changetype<${entityName} | null>(store.get('${entityName}', id))
+        return changetype<${entityName} | null>(store.get('${entityName}', ${idField.tsToString()}))
         `,
       ),
     )
@@ -194,13 +242,12 @@ module.exports = class SchemaCodeGenerator {
       isArray &&
       paramType.inner instanceof tsCodegen.NullableType
     ) {
-      let arrayTypeWithoutClosingBracked = fieldValueType.slice(0, -1)
-      let suggestedType = `${arrayTypeWithoutClosingBracked}!]`
+      let baseType = this._baseType(gqlType)
 
       throw new Error(`
 GraphQL schema can't have List's with Nullable members.
-Error in '${name}' field of type '${fieldValueType}'.
-Suggestion: add an '!' to the member type of the List, change from '${fieldValueType}' to '${suggestedType}'`
+Error in '${name}' field of type '[${baseType}]'.
+Suggestion: add an '!' to the member type of the List, change from '[${baseType}]' to '[${baseType}!]'`
       )
     }
 
@@ -212,7 +259,7 @@ Suggestion: add an '!' to the member type of the List, change from '${fieldValue
         this.unset('${name}')
       } else {
         this.set('${name}', ${typesCodegen.valueFromAsc(
-        `<${paramTypeString}>value`,
+      `<${paramTypeString}>value`,
       fieldValueType,
     )})
       }
@@ -226,12 +273,44 @@ Suggestion: add an '!' to the member type of the List, change from '${fieldValue
     )
   }
 
+  _resolveFieldType(gqlType) {
+    let typeName = gqlType.getIn(['name', 'value'])
+
+    // If this is a reference to another type, the field has the type of
+    // the referred type's id field
+    const typeDef = this.schema.ast.get("definitions").
+      find(def => this._isEntityTypeDefinition(def) && def.getIn(["name", "value"]) === typeName)
+    if (typeDef) {
+      return IdField.fromTypeDef(typeDef).typeName()
+    } else {
+      return typeName
+    }
+  }
+
+  /** Return the type that values for this field must have. For scalar
+   * types, that's the type from the subgraph schema. For references to
+   * other entity types, this is the same as the type of the id of the
+   * referred type, i.e., `string` or `Bytes`*/
   _valueTypeFromGraphQl(gqlType) {
-    return gqlType.get('kind') === 'NonNullType'
-      ? this._valueTypeFromGraphQl(gqlType.get('type'), false)
-      : gqlType.get('kind') === 'ListType'
-      ? '[' + this._valueTypeFromGraphQl(gqlType.get('type')) + ']'
-      : gqlType.getIn(['name', 'value'])
+    if (gqlType.get('kind') === 'NonNullType') {
+      return this._valueTypeFromGraphQl(gqlType.get('type'), false)
+    } else if (gqlType.get('kind') === 'ListType') {
+      return '[' + this._valueTypeFromGraphQl(gqlType.get('type')) + ']'
+    } else {
+      return this._resolveFieldType(gqlType)
+    }
+  }
+
+  /** Determine the base type of `gqlType` by removing any non-null
+   * constraints and using the type of elements of lists */
+  _baseType(gqlType) {
+    if (gqlType.get('kind') === 'NonNullType') {
+      return this._baseType(gqlType.get('type'))
+    } else if (gqlType.get('kind') === 'ListType') {
+      return this._baseType(gqlType.get('type'))
+    } else {
+      return gqlType.getIn(['name', 'value'])
+    }
   }
 
   _typeFromGraphQl(gqlType, nullable = true, nullablePrimitive = false) {
@@ -243,7 +322,7 @@ Suggestion: add an '!' to the member type of the List, change from '${fieldValue
     } else {
       // NamedType
       let type = tsCodegen.namedType(
-        typesCodegen.ascTypeForValue(gqlType.getIn(['name', 'value'])),
+        typesCodegen.ascTypeForValue(this._resolveFieldType(gqlType)),
       )
 
       // Will not wrap primitives into NullableType by default.

package/src/codegen/schema.test.js

@@ -129,9 +129,7 @@ describe('Schema code generator', () => {
               if (id) {
                 assert(
                   id.kind == ValueKind.STRING,
-                  'Cannot save Account entity with non-string ID. ' +
-                  'Considering using .toHex() to convert the "id" to a string.'
-                )
+                  \`Entities of type Account must have an ID of type String but the id '\${id.displayData()}' is of type \${id.displayKind()}\`)
                 store.set('Account', id.toString(), this)
               }
             `,
@@ -279,7 +277,7 @@ describe('Schema code generator', () => {
             body: `
               super()
               this.set('id', Value.fromString(id))
-    
+
               this.set('amount', Value.fromBigInt(BigInt.zero()))
               this.set('account', Value.fromString(''))
             `,
@@ -294,9 +292,7 @@ describe('Schema code generator', () => {
               if (id) {
                 assert(
                   id.kind == ValueKind.STRING,
-                  'Cannot save Wallet entity with non-string ID. ' +
-                  'Considering using .toHex() to convert the "id" to a string.'
-                )
+                  \`Entities of type Wallet must have an ID of type String but the id '\${id.displayData()}' is of type \${id.displayKind()}\`)
                 store.set('Wallet', id.toString(), this)
               }
             `,

package/src/commands/codegen.js

@@ -71,7 +71,7 @@ module.exports = {
       // because that would mean the CLI would generate code to
       // the wrong AssemblyScript version.
       await assertManifestApiVersion(manifest, '0.0.5')
-      await assertGraphTsVersion(path.dirname(manifest), '0.22.0')
+      await assertGraphTsVersion(path.dirname(manifest), '0.25.0')
 
       const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifest)
 

package/src/commands/deploy.js

@@ -30,6 +30,7 @@ Options:
   -l  --version-label <label>   Version label used for the deployment
   -h, --help                    Show usage information
   -i, --ipfs <node>             Upload build results to an IPFS node (default: ${DEFAULT_IPFS_URL})
+      --debug-fork              ID of a remote subgraph whose store will be GraphQL queried
   -o, --output-dir <path>       Output directory for build results (default: build/)
       --skip-migrations         Skip subgraph migrations (default: false)
   -w, --watch                   Regenerate types when subgraph files change (default: false)
@@ -96,6 +97,7 @@ module.exports = {
       skipMigrations,
       w,
       watch,
+      debugFork,
     } = toolbox.parameters.options
 
     // Support both long and short option variants
@@ -198,7 +200,7 @@ module.exports = {
       // because that would mean the CLI would try to compile code
       // using the wrong AssemblyScript compiler.
       await assertManifestApiVersion(manifest, '0.0.5')
-      await assertGraphTsVersion(path.dirname(manifest), '0.22.0')
+      await assertGraphTsVersion(path.dirname(manifest), '0.25.0')
 
       const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifest)
 
@@ -264,7 +266,7 @@ module.exports = {
       //       `Failed to deploy to Graph node ${requestUrl}`,
       client.request(
         'subgraph_deploy',
-        { name: subgraphName, ipfs_hash: ipfsHash, version_label: versionLabel },
+        { name: subgraphName, ipfs_hash: ipfsHash, version_label: versionLabel, debug_fork: debugFork },
         async (requestError, jsonRpcError, res) => {
           if (jsonRpcError) {
             spinner.fail(

package/src/commands/init.js

@@ -283,6 +283,9 @@ const getEtherscanLikeAPIUrl = (network) => {
     case "bsc": return `https://api.bscscan.com/api`;
     case "matic": return `https://api.polygonscan.com/api`;
     case "mumbai": return `https://api-testnet.polygonscan.com/api`;
+    case "aurora": return `https://api.aurorascan.dev/api`;
+    case "aurora-testnet": return `https://api-testnet.aurorascan.dev/api`;
+    case "optimism-kovan": return `https://api-kovan-optimistic.etherscan.io/api`;
     default: return `https://api-${network}.etherscan.io/api`;
   }
 } 

package/src/commands/test.js

@@ -2,8 +2,9 @@ const { Binary } = require('binary-install-raw')
 const os = require('os')
 const chalk = require('chalk')
 const fetch = require('node-fetch')
-const { filesystem, print } = require('gluegun')
+const { filesystem, patching, print, system } = require('gluegun')
 const { fixParameters } = require('../command-helpers/gluegun')
+const path = require('path')
 const semver = require('semver')
 const { spawn, exec } = require('child_process')
 const yaml = require('js-yaml')
@@ -102,7 +103,7 @@ async function runBinary(datasource, opts) {
   let latestVersion = opts.get("latestVersion")
   let recompileOpt = opts.get("recompile")
 
-  const platform = getPlatform(logsOpt)
+  const platform = await getPlatform(logsOpt)
 
   const url = `https://github.com/LimeChain/matchstick/releases/download/${versionOpt || latestVersion}/${platform}`
 
@@ -120,19 +121,21 @@ async function runBinary(datasource, opts) {
   args.length > 0 ? binary.run(...args) : binary.run()
 }
 
-function getPlatform(logsOpt) {
+async function getPlatform(logsOpt) {
   const type = os.type()
   const arch = os.arch()
-  const release = os.release()
   const cpuCore = os.cpus()[0]
-  const majorVersion = semver.major(release)
-  const isM1 = cpuCore.model.includes("Apple M1")
+  const isM1 = (arch === 'arm64' && /Apple (M1|processor)/.test(cpuCore.model))
+  const linuxInfo = type === 'Linux' ? await getLinuxInfo() : new Map()
+  const linuxDistro = linuxInfo.get('name')
+  const release = linuxInfo.get('version') || os.release()
+  const majorVersion = parseInt(linuxInfo.get('version'), 10) || semver.major(release)
 
   if (logsOpt) {
-    print.info(`OS type: ${type}\nOS arch: ${arch}\nOS release: ${release}\nOS major version: ${majorVersion}\nCPU model: ${cpuCore.model}`)
+    print.info(`OS type: ${linuxDistro || type}\nOS arch: ${arch}\nOS release: ${release}\nOS major version: ${majorVersion}\nCPU model: ${cpuCore.model}`)
   }
 
-  if (arch === 'x64' || (arch === 'arm64' && isM1)) {
+  if (arch === 'x64' || isM1) {
     if (type === 'Darwin') {
       if (majorVersion === 19) {
         return 'binary-macos-10.15'
@@ -145,8 +148,9 @@ function getPlatform(logsOpt) {
     } else if (type === 'Linux') {
       if (majorVersion === 18) {
         return 'binary-linux-18'
+      } else {
+        return 'binary-linux-20'
       }
-      return 'binary-linux-20'
     } else if (type === 'Windows_NT') {
       return 'binary-windows'
     }
@@ -155,6 +159,23 @@ function getPlatform(logsOpt) {
   throw new Error(`Unsupported platform: ${type} ${arch} ${majorVersion}`)
 }
 
+async function getLinuxInfo() {
+  try {
+    let result = await system.run("cat /etc/*-release | grep -E '(^VERSION|^NAME)='", {trim: true})
+    let infoArray = result.replace(/['"]+/g, '').split('\n').map(p => p.split('='))
+    let infoMap = new Map();
+
+    infoArray.forEach((val) => {
+      infoMap.set(val[0].toLowerCase(), val[1])
+    });
+
+    return infoMap
+  } catch (error) {
+    print.error(`Error fetching the Linux version:\n ${error}`)
+    process.exit(1)
+  }
+}
+
 async function runDocker(datasource, opts) {
   let coverageOpt = opts.get("coverage")
   let forceOpt = opts.get("force")
@@ -169,27 +190,34 @@ async function runDocker(datasource, opts) {
   // Get current working directory
   let current_folder = await filesystem.cwd()
 
-  // Build the Dockerfile location. Defaults to ./tests/.docker if
-  // a custom testsFolder is not declared in the subgraph.yaml
-  let dockerDir = ""
+  // Declate dockerfilePath with default location
+  let dockerfilePath = "./tests/.docker/Dockerfile"
 
-  try {
-    let doc = await yaml.load(filesystem.read('subgraph.yaml', 'utf8'))
-    testsFolder = doc.testsFolder || './tests'
-    dockerDir = testsFolder.endsWith('/') ? testsFolder + '.docker' : testsFolder + '/.docker'
-  } catch (error) {
-    print.error(error.message)
-    return
+  // Check if matchstick.yaml config exists
+  if(filesystem.exists('matchstick.yaml')) {
+    try {
+      // Load the config
+      let config = await yaml.load(filesystem.read('matchstick.yaml', 'utf8'))
+
+      // Check if matchstick.yaml is not empty
+      if(config != null) {
+        // If a custom tests folder is declared update dockerfilePath
+        dockerfilePath = path.join(config.testsFolder || 'tests', '.docker/Dockerfile')
+      }
+    } catch (error) {
+      print.info('A problem occurred while reading matchstick.yaml. Please attend to the errors below:')
+      print.error(error.message)
+      process.exit(1)
+    }
   }
 
-  // Create the Dockerfile
-  try {
-    await filesystem.write(`${dockerDir}/Dockerfile`, dockerfile(versionOpt, latestVersion))
-    print.info('Successfully generated Dockerfile.')
-  } catch (error) {
-    print.info('A problem occurred while generating the Dockerfile. Please attend to the errors below:')
-    print.error(error.message)
-    return
+  // Check if the Dockerfil already exists
+  let dockerfileExists = filesystem.exists(dockerfilePath)
+
+  // Generate the Dockerfile only if it doesn't exists,
+  // version flag and/or force flag is passed.
+  if(!dockerfileExists || versionOpt || forceOpt) {
+    await dockerfile(dockerfilePath, versionOpt, latestVersion)
   }
 
   // Run a command to check if matchstick image already exists
@@ -212,10 +240,10 @@ async function runDocker(datasource, opts) {
 
     // If a matchstick image does not exists, the command returns an empty string,
     // else it'll return the image ID. Skip `docker build` if an image already exists
-    // If `-v/--version` is specified, delete current image(if any) and rebuild.
+    // Delete current image(if any) and rebuild.
     // Use spawn() and {stdio: 'inherit'} so we can see the logs in real time.
-    if(stdout === '' || versionOpt || forceOpt) {
-      if ((stdout !== '' && versionOpt) || forceOpt) {
+    if(!dockerfileExists || stdout === '' || versionOpt || forceOpt) {
+      if (stdout !== '') {
         exec('docker image rm matchstick', (error, stdout, stderr) => {
           print.info(chalk.bold(`Removing matchstick image\n${stdout}`))
         })
@@ -224,7 +252,7 @@ async function runDocker(datasource, opts) {
       // run a container from that image.
       spawn(
         'docker',
-        ['build', '--no-cache', '-f', `${dockerDir}/Dockerfile`, '-t', 'matchstick', '.'],
+        ['build', '-f', dockerfilePath, '-t', 'matchstick', '.'],
         { stdio: 'inherit' }
       ).on('close', code => {
         if (code === 0) {
@@ -239,37 +267,32 @@ async function runDocker(datasource, opts) {
   })
 }
 
-// TODO: Move these in separate file (in a function maybe)
-function dockerfile(versionOpt, latestVersion) {
-  return `
-  FROM ubuntu:20.04
-  ENV ARGS=""
-
-  # Install necessary packages
-  RUN apt update
-  RUN apt install -y nodejs
-  RUN apt install -y npm
-  RUN apt install -y git
-  RUN apt install -y postgresql
-  RUN apt install -y curl
-  RUN apt install -y cmake
-  RUN npm install -g @graphprotocol/graph-cli
+// Downloads Dockerfile template from the demo-subgraph repo
+// Replaces the placeholders with their respective values
+async function dockerfile(dockerfilePath, versionOpt, latestVersion) {
+  let spinner = print.spin("Generating Dockerfile...")
 
-  # Download the latest linux binary
-  RUN curl -OL https://github.com/LimeChain/matchstick/releases/download/${versionOpt || latestVersion}/binary-linux-20
-
-  # Make it executable
-  RUN chmod a+x binary-linux-20
+  try {
+    // Fetch the Dockerfile template content from the demo-subgraph repo
+    let content = await fetch('https://raw.githubusercontent.com/LimeChain/demo-subgraph/main/Dockerfile')
+        .then((response) => {
+          if (response.ok) {
+            return response.text()
+          } else {
+            throw new Error(`Status Code: ${response.status}, with error: ${response.statusText}`);
+          }
+        })
 
-  # Create a matchstick dir where the host will be copied
-  RUN mkdir matchstick
-  WORKDIR matchstick
+    // Write the Dockerfile
+    await filesystem.write(dockerfilePath, content)
 
-  # Copy host to /matchstick
-  COPY ../ .
+    // Replaces the version placeholders
+    await patching.replace(dockerfilePath, '<MATCHSTICK_VERSION>', versionOpt || latestVersion)
 
-  RUN graph codegen
-  RUN graph build
+  } catch (error) {
+    spinner.fail(`A problem occurred while generating the Dockerfile. Please attend to the errors below:\n ${error.message}`)
+    process.exit(1)
+  }
 
-  CMD ../binary-linux-20 \${ARGS}`
+  spinner.succeed('Successfully generated Dockerfile.')
 }

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

@@ -1,16 +1,22 @@
 const immutable = require('immutable')
+const fs = require('fs')
+const yaml = require('yaml')
+const request = require('sync-request')
+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');
+
 module.exports = class AbiCodeGenerator {
   constructor(abi) {
     this.abi = abi
   }
 
   generateModuleImports() {
-    return [
+    let imports = [
       tsCodegen.moduleImports(
         [
           // Ethereum integration
@@ -27,8 +33,21 @@ module.exports = class AbiCodeGenerator {
           'BigInt',
         ],
         '@graphprotocol/graph-ts',
-      ),
+      )
     ]
+
+    if (doFixtureCodegen) {
+      imports.push(
+        tsCodegen.moduleImports(
+          [
+            'newMockEvent',
+          ],
+          'matchstick-as/assembly/index',
+        )
+      )
+    }
+
+    return imports
   }
 
   generateTypes() {
@@ -182,6 +201,7 @@ module.exports = class AbiCodeGenerator {
           setName: (input, name) => input.set('name', name),
         })
 
+        let namesAndTypes = []
         inputs.forEach((input, index) => {
           // Generate getters and classes for event params
           let paramObject = this._generateInputOrOutput(
@@ -192,6 +212,11 @@ module.exports = class AbiCodeGenerator {
             `parameters`,
           )
           paramsClass.addMethod(paramObject.getter)
+          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)
         })
 
@@ -208,6 +233,51 @@ module.exports = class AbiCodeGenerator {
             `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),
+              `
+              let event = changetype<${eventClassName}>(newMockEvent());
+              ${stmnts}
+              return event;
+              `,
+            )
+          )
+        }
+
         return [klass, paramsClass, ...tupleClasses]
       })