@graphprotocol/graph-cli 0.22.4 → 0.23.2

package/src/compiler/index.js

@@ -9,7 +9,6 @@ const toolbox = require('gluegun/toolbox')
 const { step, withSpinner } = require('../command-helpers/spinner')
 const Subgraph = require('../subgraph')
 const Watcher = require('../watcher')
-const ABI = require('../abi')
 const { applyMigrations } = require('../migrations')
 const asc = require('./asc')
 
@@ -52,6 +51,9 @@ class Compiler {
 
     this.globalsFile = path.join(globalsLib, globalsFile)
 
+    this.protocol = this.options.protocol
+    this.ABI = this.protocol.getABI()
+
     process.on('uncaughtException', function(e) {
       toolbox.print.error(`UNCAUGHT EXCEPTION: ${e}`)
     })
@@ -104,8 +106,10 @@ class Compiler {
   }
 
   async loadSubgraph({ quiet } = { quiet: false }) {
+    const subgraphLoadOptions = { protocol: this.protocol, skipValidation: false }
+
     if (quiet) {
-      return Subgraph.load(this.options.subgraphManifest).result
+      return Subgraph.load(this.options.subgraphManifest, subgraphLoadOptions).result
     } else {
       const manifestPath = this.displayPath(this.options.subgraphManifest)
 
@@ -114,7 +118,7 @@ class Compiler {
         `Failed to load subgraph from ${manifestPath}`,
         `Warnings loading subgraph from ${manifestPath}`,
         async spinner => {
-          return Subgraph.load(this.options.subgraphManifest)
+          return Subgraph.load(this.options.subgraphManifest, subgraphLoadOptions)
         },
       )
     }
@@ -132,9 +136,12 @@ class Compiler {
       files.push(path.resolve(subgraph.getIn(['schema', 'file'])))
       subgraph.get('dataSources').map(dataSource => {
         files.push(dataSource.getIn(['mapping', 'file']))
-        dataSource.getIn(['mapping', 'abis']).map(abi => {
-          files.push(abi.get('file'))
-        })
+        // Only watch ABI related files if the target protocol has support/need for them.
+        if (this.protocol.hasABIs()) {
+          dataSource.getIn(['mapping', 'abis']).map(abi => {
+            files.push(abi.get('file'))
+          })
+        }
       })
 
       // Make paths absolute
@@ -403,52 +410,59 @@ class Compiler {
         })
 
         // Copy data source files and update their paths
-        subgraph = subgraph.update('dataSources', dataSources => {
-          return dataSources.map(dataSource =>
-            dataSource
-              // Write data source ABIs to the output directory
-              .updateIn(['mapping', 'abis'], abis =>
-                abis.map(abi =>
-                  abi.update('file', abiFile => {
-                    abiFile = path.resolve(this.sourceDir, abiFile)
-                    let abiData = ABI.load(abi.get('name'), abiFile)
-                    return path.relative(
-                      this.options.outputDir,
-                      this._writeSubgraphFile(
-                        abiFile,
-                        JSON.stringify(abiData.data.toJS(), null, 2),
-                        this.sourceDir,
-                        this.subgraphDir(this.options.outputDir, dataSource),
-                        spinner,
-                      ),
-                    )
-                  }),
-                ),
-              )
-
-              // The mapping file is already being written to the output
-              // directory by the AssemblyScript compiler
-              .updateIn(['mapping', 'file'], mappingFile =>
-                path.relative(
-                  this.options.outputDir,
-                  path.resolve(this.sourceDir, mappingFile),
-                ),
+        subgraph = subgraph.update('dataSources', dataSources =>
+          dataSources.map(dataSource => {
+            let updatedDataSource = dataSource
+
+            if (this.protocol.hasABIs()) {
+              updatedDataSource = updatedDataSource
+                // Write data source ABIs to the output directory
+                .updateIn(['mapping', 'abis'], abis =>
+                  abis.map(abi =>
+                    abi.update('file', abiFile => {
+                      abiFile = path.resolve(this.sourceDir, abiFile)
+                      let abiData = this.ABI.load(abi.get('name'), abiFile)
+                      return path.relative(
+                        this.options.outputDir,
+                        this._writeSubgraphFile(
+                          abiFile,
+                          JSON.stringify(abiData.data.toJS(), null, 2),
+                          this.sourceDir,
+                          this.subgraphDir(this.options.outputDir, dataSource),
+                          spinner,
+                        ),
+                      )
+                    }),
+                  ),
+                )
+            }
+
+            // The mapping file is already being written to the output
+            // directory by the AssemblyScript compiler
+            return updatedDataSource.updateIn(['mapping', 'file'], mappingFile =>
+              path.relative(
+                this.options.outputDir,
+                path.resolve(this.sourceDir, mappingFile),
               ),
-          )
-        })
+            )
+          })
+        )
 
         // Copy template files and update their paths
-        subgraph = subgraph.update('templates', templates => {
-          return templates === undefined
+        subgraph = subgraph.update('templates', templates =>
+          templates === undefined
             ? templates
-            : templates.map(template =>
-                template
+            : templates.map(template => {
+              let updatedTemplate = template
+
+              if (this.protocol.hasABIs()) {
+                updatedTemplate = updatedTemplate
                   // Write template ABIs to the output directory
                   .updateIn(['mapping', 'abis'], abis =>
                     abis.map(abi =>
                       abi.update('file', abiFile => {
                         abiFile = path.resolve(this.sourceDir, abiFile)
-                        let abiData = ABI.load(abi.get('name'), abiFile)
+                        let abiData = this.ABI.load(abi.get('name'), abiFile)
                         return path.relative(
                           this.options.outputDir,
                           this._writeSubgraphFile(
@@ -462,17 +476,18 @@ class Compiler {
                       }),
                     ),
                   )
+              }
 
-                  // The mapping file is already being written to the output
-                  // directory by the AssemblyScript compiler
-                  .updateIn(['mapping', 'file'], mappingFile =>
-                    path.relative(
-                      this.options.outputDir,
-                      path.resolve(this.sourceDir, mappingFile),
-                    ),
-                  ),
+              // The mapping file is already being written to the output
+              // directory by the AssemblyScript compiler
+              return updatedTemplate.updateIn(['mapping', 'file'], mappingFile =>
+                path.relative(
+                  this.options.outputDir,
+                  path.resolve(this.sourceDir, mappingFile),
+                ),
               )
-        })
+            })
+        )
 
         // Write the subgraph manifest itself
         let outputFilename = path.join(this.options.outputDir, 'subgraph.yaml')
@@ -506,17 +521,18 @@ class Compiler {
           ),
         })
 
-        // Upload the ABIs of all data sources to IPFS
-        for (let [i, dataSource] of subgraph.get('dataSources').entries()) {
-          for (let [j, abi] of dataSource.getIn(['mapping', 'abis']).entries()) {
-            updates.push({
-              keyPath: ['dataSources', i, 'mapping', 'abis', j, 'file'],
-              value: await this._uploadFileToIPFS(
-                abi.get('file'),
-                uploadedFiles,
-                spinner,
-              ),
-            })
+        if (this.protocol.hasABIs()) {
+          for (let [i, dataSource] of subgraph.get('dataSources').entries()) {
+            for (let [j, abi] of dataSource.getIn(['mapping', 'abis']).entries()) {
+              updates.push({
+                keyPath: ['dataSources', i, 'mapping', 'abis', j, 'file'],
+                value: await this._uploadFileToIPFS(
+                  abi.get('file'),
+                  uploadedFiles,
+                  spinner,
+                ),
+              })
+            }
           }
         }
 
@@ -532,17 +548,18 @@ class Compiler {
           })
         }
 
-        // Upload the mapping and ABIs of all data source templates
         for (let [i, template] of subgraph.get('templates', immutable.List()).entries()) {
-          for (let [j, abi] of template.getIn(['mapping', 'abis']).entries()) {
-            updates.push({
-              keyPath: ['templates', i, 'mapping', 'abis', j, 'file'],
-              value: await this._uploadFileToIPFS(
-                abi.get('file'),
-                uploadedFiles,
-                spinner,
-              ),
-            })
+          if (this.protocol.hasABIs()) {
+            for (let [j, abi] of template.getIn(['mapping', 'abis']).entries()) {
+              updates.push({
+                keyPath: ['templates', i, 'mapping', 'abis', j, 'file'],
+                value: await this._uploadFileToIPFS(
+                  abi.get('file'),
+                  uploadedFiles,
+                  spinner,
+                ),
+              })
+            }
           }
 
           updates.push({

package/src/{codegen → protocols/ethereum/codegen}/abi.js

@@ -1,9 +1,8 @@
 const immutable = require('immutable')
 
-const tsCodegen = require('./typescript')
-const typesCodegen = require('./types')
-const util = require('./util')
-const ABI = require('../abi')
+const tsCodegen = require('../../../codegen/typescript')
+const typesCodegen = require('../../../codegen/types')
+const util = require('../../../codegen/util')
 
 module.exports = class AbiCodeGenerator {
   constructor(abi) {
@@ -48,7 +47,7 @@ module.exports = class AbiCodeGenerator {
       setName: (fn, name) => fn.set('_alias', name),
     })
 
-    return callFunctions
+    callFunctions = callFunctions
       .map(fn => {
         let fnAlias = fn.get('_alias')
         let fnClassName = `${fnAlias.charAt(0).toUpperCase()}${fnAlias.slice(1)}Call`
@@ -141,6 +140,8 @@ module.exports = class AbiCodeGenerator {
         )
         return [klass, inputsClass, outputsClass, ...tupleClasses]
       })
+
+    return callFunctions
       .reduce(
         // flatten the array
         (array, classes) => array.concat(classes),
@@ -156,7 +157,7 @@ module.exports = class AbiCodeGenerator {
       setName: (event, name) => event.set('_alias', name),
     })
 
-    return events
+    events = events
       .map(event => {
         let eventClassName = event.get('_alias')
         let tupleClasses = []
@@ -209,6 +210,8 @@ module.exports = class AbiCodeGenerator {
         )
         return [klass, paramsClass, ...tupleClasses]
       })
+
+    return events
       .reduce(
         // flatten the array
         (array, classes) => array.concat(classes),

package/src/{codegen → protocols/ethereum/codegen}/abi.test.js

@@ -3,7 +3,7 @@ const path = require('path')
 const immutable = require('immutable')
 
 const ABI = require('../abi')
-const ts = require('./typescript')
+const ts = require('../../../codegen/typescript')
 const AbiCodeGenerator = require('./abi')
 
 let tempdir

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

@@ -0,0 +1,42 @@
+const tsCodegen = require('../../../codegen/typescript')
+
+module.exports = class EthereumTemplateCodeGen {
+  constructor(template) {
+    this.template = template
+  }
+
+  generateModuleImports() {
+    return [
+      'Address',
+    ]
+  }
+
+  generateCreateMethod() {
+    const name = this.template.get('name')
+
+    return tsCodegen.staticMethod(
+      'create',
+      [tsCodegen.param('address', tsCodegen.namedType('Address'))],
+      tsCodegen.namedType('void'),
+      `
+      DataSourceTemplate.create('${name}', [address.toHex()])
+      `,
+    )
+  }
+
+  generateCreateWithContextMethod() {
+    const name = this.template.get('name')
+
+    return tsCodegen.staticMethod(
+      'createWithContext',
+      [
+        tsCodegen.param('address', tsCodegen.namedType('Address')),
+        tsCodegen.param('context', tsCodegen.namedType('DataSourceContext')),
+      ],
+      tsCodegen.namedType('void'),
+      `
+      DataSourceTemplate.createWithContext('${name}', [address.toHex()], context)
+      `,
+    )
+  }
+}

package/src/protocols/ethereum/subgraph.js

@@ -0,0 +1,205 @@
+const immutable = require('immutable')
+const ABI = require('./abi')
+const DataSourcesExtractor = require('../../command-helpers/data-sources')
+const { validateContractValues } = require('../../validation')
+
+module.exports = class EthereumSubgraph {
+  constructor(options = {}) {
+    this.manifest = options.manifest
+    this.resolveFile = options.resolveFile
+    this.protocol = options.protocol
+  }
+
+  validateManifest() {
+    return this.validateAbis()
+      .concat(this.validateContractAddresses())
+      .concat(this.validateEvents())
+      .concat(this.validateCallFunctions())
+  }
+
+  validateAbis() {
+    const dataSourcesAndTemplates = DataSourcesExtractor.fromManifest(this.manifest, this.protocol)
+
+    return dataSourcesAndTemplates.reduce(
+      (errors, dataSourceOrTemplate) =>
+        errors.concat(
+          this.validateDataSourceAbis(
+            dataSourceOrTemplate.get('dataSource'),
+            dataSourceOrTemplate.get('path'),
+          ),
+        ),
+      immutable.List(),
+    )
+  }
+
+  validateDataSourceAbis(dataSource, path) {
+    // Validate that the the "source > abi" reference of all data sources
+    // points to an existing ABI in the data source ABIs
+    let abiName = dataSource.getIn(['source', 'abi'])
+    let abiNames = dataSource.getIn(['mapping', 'abis']).map(abi => abi.get('name'))
+    let nameErrors = abiNames.includes(abiName)
+      ? immutable.List()
+      : immutable.fromJS([
+          {
+            path: [...path, 'source', 'abi'],
+            message: `\
+ABI name '${abiName}' not found in mapping > abis.
+Available ABIs:
+${abiNames
+  .sort()
+  .map(name => `- ${name}`)
+  .join('\n')}`,
+          },
+        ])
+
+    // Validate that all ABI files are valid
+    let fileErrors = dataSource
+      .getIn(['mapping', 'abis'])
+      .reduce((errors, abi, abiIndex) => {
+        try {
+          ABI.load(abi.get('name'), this.resolveFile(abi.get('file')))
+          return errors
+        } catch (e) {
+          return errors.push(
+            immutable.fromJS({
+              path: [...path, 'mapping', 'abis', abiIndex, 'file'],
+              message: e.message,
+            }),
+          )
+        }
+      }, immutable.List())
+
+    return nameErrors.concat(fileErrors)
+  }
+
+  validateContractAddresses() {
+    const ethereumAddressPattern = /^(0x)?[0-9a-fA-F]{40}$/
+
+    return validateContractValues(
+      this.manifest,
+      this.protocol,
+      'address',
+      address => ethereumAddressPattern.test(address),
+      "Must be 40 hexadecimal characters, with an optional '0x' prefix.",
+    )
+  }
+
+  validateEvents() {
+    const dataSourcesAndTemplates = DataSourcesExtractor.fromManifest(this.manifest, this.protocol)
+
+    return dataSourcesAndTemplates
+      .reduce((errors, dataSourceOrTemplate) => {
+        return errors.concat(
+          this.validateDataSourceEvents(
+            dataSourceOrTemplate.get('dataSource'),
+            dataSourceOrTemplate.get('path'),
+          ),
+        )
+      }, immutable.List())
+  }
+
+  validateDataSourceEvents(dataSource, path) {
+    let abi
+    try {
+      // Resolve the source ABI name into a real ABI object
+      let abiName = dataSource.getIn(['source', 'abi'])
+      let abiEntry = dataSource
+        .getIn(['mapping', 'abis'])
+        .find(abi => abi.get('name') === abiName)
+      abi = ABI.load(abiEntry.get('name'), this.resolveFile(abiEntry.get('file')))
+    } catch (_) {
+      // Ignore errors silently; we can't really say anything about
+      // the events if the ABI can't even be loaded
+      return immutable.List()
+    }
+
+    // Obtain event signatures from the mapping
+    let manifestEvents = dataSource
+      .getIn(['mapping', 'eventHandlers'], immutable.List())
+      .map(handler => handler.get('event'))
+
+    // Obtain event signatures from the ABI
+    let abiEvents = abi.eventSignatures()
+
+    // Add errors for every manifest event signature that is not
+    // present in the ABI
+    return manifestEvents.reduce(
+      (errors, manifestEvent, index) =>
+        abiEvents.includes(manifestEvent)
+          ? errors
+          : errors.push(
+              immutable.fromJS({
+                path: [...path, 'eventHandlers', index],
+                message: `\
+Event with signature '${manifestEvent}' not present in ABI '${abi.name}'.
+Available events:
+${abiEvents
+  .sort()
+  .map(event => `- ${event}`)
+  .join('\n')}`,
+              }),
+            ),
+      immutable.List(),
+    )
+  }
+
+  validateCallFunctions() {
+    return this.manifest
+      .get('dataSources')
+      .filter(dataSource => this.protocol.isValidKindName(dataSource.get('kind')))
+      .reduce((errors, dataSource, dataSourceIndex) => {
+        let path = ['dataSources', dataSourceIndex, 'callHandlers']
+
+        let abi
+        try {
+          // Resolve the source ABI name into a real ABI object
+          let abiName = dataSource.getIn(['source', 'abi'])
+          let abiEntry = dataSource
+            .getIn(['mapping', 'abis'])
+            .find(abi => abi.get('name') === abiName)
+          abi = ABI.load(abiEntry.get('name'), this.resolveFile(abiEntry.get('file')))
+        } catch (e) {
+          // Ignore errors silently; we can't really say anything about
+          // the call functions if the ABI can't even be loaded
+          return errors
+        }
+
+        // Obtain event signatures from the mapping
+        let manifestFunctions = dataSource
+          .getIn(['mapping', 'callHandlers'], immutable.List())
+          .map(handler => handler.get('function'))
+
+        // Obtain event signatures from the ABI
+        let abiFunctions = abi.callFunctionSignatures()
+
+        // Add errors for every manifest event signature that is not
+        // present in the ABI
+        return manifestFunctions.reduce(
+          (errors, manifestFunction, index) =>
+            abiFunctions.includes(manifestFunction)
+              ? errors
+              : errors.push(
+                  immutable.fromJS({
+                    path: [...path, index],
+                    message: `\
+Call function with signature '${manifestFunction}' not present in ABI '${abi.name}'.
+Available call functions:
+${abiFunctions
+  .sort()
+  .map(tx => `- ${tx}`)
+  .join('\n')}`,
+                  }),
+                ),
+          errors,
+        )
+      }, immutable.List())
+  }
+
+  handlerTypes() {
+    return immutable.List([
+      'blockHandlers',
+      'callHandlers',
+      'eventHandlers',
+    ])
+  }
+}