@graphprotocol/graph-cli 0.24.1 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "CLI for building for and deploying to The Graph",
   "dependencies": {
     "assemblyscript": "0.19.10",

package/src/codegen/types/index.js

@@ -89,8 +89,12 @@ const findInitializationForType = (fromTypeSystem, toTypeSystem, ascType) => {
 
 // High-level type system API
 
+const ascTypeForProtocol = (protocol, protocolType) =>
+  findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type'])
+
+// TODO: this can be removed/replaced by the function above
 const ascTypeForEthereum = ethereumType =>
-  findConversionFromType('ethereum', 'AssemblyScript', ethereumType).getIn(['to', 'type'])
+  ascTypeForProtocol('ethereum', ethereumType)
 
 const ethereumTypeForAsc = ascType =>
   findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type'])
@@ -120,6 +124,9 @@ const initializedValueFromAsc = ascType =>
   findInitializationForType('AssemblyScript', 'Value', ascType)
 
 module.exports = {
+  // protocol <-> AssemblyScript
+  ascTypeForProtocol,
+
   // ethereum <-> AssemblyScript
   ascTypeForEthereum,
   ethereumTypeForAsc,

package/src/command-helpers/scaffold.js

@@ -0,0 +1,66 @@
+const fs = require('fs-extra')
+const path = require('path')
+
+const { step } = require('./spinner')
+const Scaffold = require('../scaffold')
+
+const generateScaffold = async (
+  {
+    protocolInstance,
+    abi,
+    contract,
+    network,
+    subgraphName,
+    indexEvents,
+    contractName = 'Contract',
+    node,
+  },
+  spinner,
+) => {
+  step(spinner, 'Generate subgraph')
+
+  const scaffold = new Scaffold({
+    protocol: protocolInstance,
+    abi,
+    indexEvents,
+    contract,
+    network,
+    contractName,
+    subgraphName,
+    node,
+  })
+
+  return scaffold.generate()
+}
+
+const writeScaffoldDirectory = async (scaffold, directory, spinner) => {
+  // Create directory itself
+  await fs.mkdirs(directory)
+
+  let promises = Object.keys(scaffold).map(async basename => {
+    let content = scaffold[basename]
+    let filename = path.join(directory, basename)
+
+    // Write file or recurse into subdirectory
+    if (typeof content === 'string') {
+      await fs.writeFile(filename, content, { encoding: 'utf-8' })
+    } else if (content == null) {
+      return // continue loop
+    } else {
+      writeScaffoldDirectory(content, path.join(directory, basename), spinner)
+    }
+  })
+
+  await Promise.all(promises)
+}
+
+const writeScaffold = async (scaffold, directory, spinner) => {
+  step(spinner, `Write subgraph to directory`)
+  await writeScaffoldDirectory(scaffold, directory, spinner)
+}
+
+module.exports = {
+  ...module.exports,
+  generateScaffold,
+  writeScaffold,
+}

package/src/commands/init.js

@@ -14,98 +14,107 @@ const { validateStudioNetwork } = require('../command-helpers/studio')
 const { withSpinner, step } = require('../command-helpers/spinner')
 const { fixParameters } = require('../command-helpers/gluegun')
 const { chooseNodeUrl } = require('../command-helpers/node')
-const { abiEvents, generateScaffold, writeScaffold } = require('../scaffold')
-// TODO: Use Protocol class to getABI
-const ABI = require('../protocols/ethereum/abi')
-
-const networkChoices = [
-  'mainnet',
-  'kovan',
-  'rinkeby',
-  'ropsten',
-  'goerli',
-  'poa-core',
-  'poa-sokol',
-  'xdai',
-  'matic',
-  'mumbai',
-  'fantom',
-  'bsc',
-  'chapel',
-  'clover',
-  'avalanche',
-  'fuji',
-  'celo',
-  'celo-alfajores',
-  'fuse',
-  'mbase',
-  'arbitrum-one',
-  'arbitrum-rinkeby',
-  'optimism',
-  'optimism-kovan'
-]
+const { generateScaffold, writeScaffold } = require('../command-helpers/scaffold')
+const { abiEvents } = require('../scaffold/schema')
+const { validateContract } = require('../validation')
+const Protocol = require('../protocols')
+
+const protocolChoices = Array.from(Protocol.availableProtocols().keys())
+const availableNetworks = Protocol.availableNetworks()
 
 const HELP = `
 ${chalk.bold('graph init')} [options] [subgraph-name] [directory]
 
 ${chalk.dim('Options:')}
 
+      --protocol <${protocolChoices.join('|')}>
       --product <subgraph-studio|hosted-service>
-                                Selects the product for which to initialize
-      --studio                  Shortcut for --product subgraph-studio
-  -g, --node <node>             Graph node for which to initialize
-      --allow-simple-name       Use a subgraph name without a prefix (default: false)
-  -h, --help                    Show usage information
+                                 Selects the product for which to initialize
+      --studio                   Shortcut for --product subgraph-studio
+  -g, --node <node>              Graph node for which to initialize
+      --allow-simple-name        Use a subgraph name without a prefix (default: false)
+  -h, --help                     Show usage information
 
 ${chalk.dim('Choose mode with one of:')}
 
-      --from-contract <address> Creates a scaffold based on an existing contract
-      --from-example            Creates a scaffold based on an example subgraph
+      --from-contract <contract> Creates a scaffold based on an existing contract
+      --from-example             Creates a scaffold based on an example subgraph
 
 ${chalk.dim('Options for --from-contract:')}
 
-      --abi <path>              Path to the contract ABI (default: download from Etherscan)
-      --network <${networkChoices.join('|')}>
-                                Selects the network the contract is deployed to
-      --index-events            Index contract events as entities
-      --contract-name           Name of the contract (default: Contract)      
+      --contract-name            Name of the contract (default: Contract)
+      --index-events             Index contract events as entities
+
+${chalk.dim.underline('Ethereum:')}
+
+      --abi <path>               Path to the contract ABI (default: download from Etherscan)
+      --network <${availableNetworks.get('ethereum').join('|')}>
+                                 Selects the network the contract is deployed to
+
+${chalk.dim.underline('NEAR:')}
+
+      --network <${availableNetworks.get('near').join('|')}>
+                                 Selects the network the contract is deployed to
 `
 
 const processInitForm = async (
   toolbox,
   {
+    protocol,
     product,
     studio,
     node,
     abi,
     allowSimpleName,
     directory,
-    address,
+    contract,
     fromExample,
     network,
     subgraphName,
     contractName
   },
 ) => {
-  let addressPattern = /^(0x)?[0-9a-fA-F]{40}$/
-
   let abiFromEtherscan = undefined
   let abiFromFile = undefined
+  let protocolInstance
+  let ProtocolContract
+  let ABI
 
   let questions = [
+    {
+      type: 'select',
+      name: 'protocol',
+      message: 'Protocol',
+      choices: protocolChoices,
+      skip: protocolChoices.includes(protocol),
+      result: value => {
+        protocol = protocol || value
+        protocolInstance = new Protocol(protocol)
+        return protocol
+      },
+    },
     {
       type: 'select',
       name: 'product',
       message: 'Product for which to initialize',
       choices: ['subgraph-studio', 'hosted-service'],
-      skip: 
+      skip: () =>
+        protocol === 'near' ||
         product === 'subgraph-studio' ||
         product === 'hosted-service' ||
         studio !== undefined || node !== undefined,
       result: value => {
+        // For now we only support NEAR subgraphs in the Hosted Service
+        if (protocol === 'near') {
+          // Can be overwritten because the question will be skipped (product === undefined)
+          product = 'hosted-service'
+          return product
+        }
+
         if (value == 'subgraph-studio') {
           allowSimpleName = true
         }
+
         product = value
         return value
       },
@@ -146,8 +155,11 @@ const processInitForm = async (
     {
       type: 'select',
       name: 'network',
-      message: 'Ethereum network',
-      choices: networkChoices,
+      message: () => `${protocolInstance.displayName()} network`,
+      choices: () =>
+        availableNetworks
+          .get(protocol) // Get networks related to the chosen protocol.
+          .toArray(), // Needed because of gluegun. It can't even receive a JS iterable.
       skip: fromExample !== undefined,
       initial: network || 'mainnet',
       result: value => {
@@ -157,35 +169,39 @@ const processInitForm = async (
     },
     {
       type: 'input',
-      name: 'address',
-      message: 'Contract address',
+      name: 'contract',
+      message: () => {
+        ProtocolContract = protocolInstance.getContract()
+        return `Contract ${ProtocolContract.identifierName()}`
+      },
       skip: fromExample !== undefined,
-      initial: address,
+      initial: contract,
       validate: async value => {
         if (fromExample !== undefined) {
           return true
         }
 
-        // Validate whether the address is valid
-        if (!addressPattern.test(value)) {
-          return `Contract address "${value}" is invalid.
-  Must be 40 hexadecimal characters, with an optional '0x' prefix.`
-        }
+        // Validate whether the contract is valid
+        const { valid, error } = validateContract(value, ProtocolContract)
 
-        return true
+        return valid
+          ? true
+          : error
       },
       result: async value => {
         if (fromExample !== undefined) {
           return value
         }
 
+        ABI = protocolInstance.getABI()
+
         // Try loading the ABI from Etherscan, if none was provided
-        if (!abi) {
+        if (protocolInstance.hasABIs() && !abi) {
           try {
             if (network === 'poa-core') {
-              abiFromBlockScout = await loadAbiFromBlockScout(network, value)
+              abiFromBlockScout = await loadAbiFromBlockScout(ABI, network, value)
             } else {
-              abiFromEtherscan = await loadAbiFromEtherscan(network, value)
+              abiFromEtherscan = await loadAbiFromEtherscan(ABI, network, value)
             }
           } catch (e) {}
         }
@@ -197,14 +213,17 @@ const processInitForm = async (
       name: 'abi',
       message: 'ABI file (path)',
       initial: abi,
-      skip: () => fromExample !== undefined || abiFromEtherscan !== undefined,
+      skip: () =>
+        !protocolInstance.hasABIs() ||
+        fromExample !== undefined ||
+        abiFromEtherscan !== undefined,
       validate: async value => {
-        if (fromExample || abiFromEtherscan) {
+        if (fromExample || abiFromEtherscan || !protocolInstance.hasABIs()) {
           return true
         }
 
         try {
-          abiFromFile = await loadAbiFromFile(value)
+          abiFromFile = await loadAbiFromFile(ABI, value)
           return true
         } catch (e) {
           return e.message
@@ -227,13 +246,13 @@ const processInitForm = async (
 
   try {
     let answers = await toolbox.prompt.ask(questions)
-    return { ...answers, abi: abiFromEtherscan || abiFromFile }
+    return { ...answers, abi: abiFromEtherscan || abiFromFile, protocolInstance }
   } catch (e) {
     return undefined
   }
 }
 
-const loadAbiFromBlockScout = async (network, address) =>
+const loadAbiFromBlockScout = async (ABI, network, address) =>
   await withSpinner(
     `Fetching ABI from BlockScout`,
     `Failed to fetch ABI from BlockScout`,
@@ -267,7 +286,7 @@ const getEtherscanLikeAPIUrl = (network) => {
   }
 } 
 
-const loadAbiFromEtherscan = async (network, address) =>
+const loadAbiFromEtherscan = async (ABI, network, address) =>
   await withSpinner(
     `Fetching ABI from Etherscan`,
     `Failed to fetch ABI from Etherscan`,
@@ -290,7 +309,7 @@ const loadAbiFromEtherscan = async (network, address) =>
     },
   )
 
-const loadAbiFromFile = async filename => {
+const loadAbiFromFile = async (ABI, filename) => {
   let exists = await toolbox.filesystem.exists(filename)
 
   if (!exists) {
@@ -315,6 +334,7 @@ module.exports = {
 
     // Read CLI parameters
     let {
+      protocol,
       product,
       studio,
       node,
@@ -400,35 +420,47 @@ module.exports = {
 
     // If all parameters are provided from the command-line,
     // go straight to creating the subgraph from an existing contract
-    if (fromContract && subgraphName && directory && network && node) {
-      if (abi) {
-        try {
-          abi = await loadAbiFromFile(abi)
-        } catch (e) {
-          print.error(`Failed to load ABI: ${e.message}`)
-          process.exitCode = 1
-          return
-        }
-      } else {
-        try {
-          if (network === 'poa-core') {
-            abi = await loadAbiFromBlockScout(network, fromContract)
-          } else {
-            abi = await loadAbiFromEtherscan(network, fromContract)
+    if (fromContract && protocol && subgraphName && directory && network && node) {
+      if (!protocolChoices.includes(protocol)) {
+        print.error(`Protocol '${protocol}' is not supported, choose from these options: ${protocolChoices.join(', ')}`)
+        process.exitCode = 1
+        return
+      }
+
+      const protocolInstance = new Protocol(protocol)
+
+      if (protocolInstance.hasABIs()) {
+        const ABI = protocolInstance.getABI()
+        if (abi) {
+          try {
+            abi = await loadAbiFromFile(ABI, abi)
+          } catch (e) {
+            print.error(`Failed to load ABI: ${e.message}`)
+            process.exitCode = 1
+            return
+          }
+        } else {
+          try {
+            if (network === 'poa-core') {
+              abi = await loadAbiFromBlockScout(ABI, network, fromContract)
+            } else {
+              abi = await loadAbiFromEtherscan(ABI, network, fromContract)
+            }
+          } catch (e) {
+            process.exitCode = 1
+            return
           }
-        } catch (e) {
-          process.exitCode = 1
-          return
         }
       }
 
       return await initSubgraphFromContract(
         toolbox,
         {
+          protocolInstance,
           abi,
           allowSimpleName,
           directory,
-          address: fromContract,
+          contract: fromContract,
           indexEvents,
           network,
           subgraphName,
@@ -443,13 +475,14 @@ module.exports = {
 
     // Otherwise, take the user through the interactive form
     let inputs = await processInitForm(toolbox, {
+      protocol,
       product,
       studio,
       node,
       abi,
       allowSimpleName,
       directory,
-      address: fromContract,
+      contract: fromContract,
       fromExample,
       network,
       subgraphName,
@@ -484,12 +517,13 @@ module.exports = {
       await initSubgraphFromContract(
         toolbox,
         {
+          protocolInstance: inputs.protocolInstance,
           allowSimpleName,
           subgraphName: inputs.subgraphName,
           directory: inputs.directory,
           abi: inputs.abi,
           network: inputs.network,
-          address: inputs.address,
+          contract: inputs.contract,
           indexEvents,
           contractName: inputs.contractName,
           node,
@@ -713,12 +747,13 @@ const initSubgraphFromExample = async (
 const initSubgraphFromContract = async (
   toolbox,
   {
+    protocolInstance,
     allowSimpleName,
     subgraphName,
     directory,
     abi,
     network,
-    address,
+    contract,
     indexEvents,
     contractName,
     node,
@@ -742,7 +777,7 @@ const initSubgraphFromContract = async (
     return
   }
 
-  if (abiEvents(abi).length === 0) {
+  if (protocolInstance.hasABIs() && abiEvents(abi).length === 0) {
     // Fail if the ABI does not contain any events
     print.error(`ABI does not contain any events`)
     process.exitCode = 1
@@ -760,7 +795,7 @@ const initSubgraphFromContract = async (
     return
   }
 
-  // Scaffold subgraph from ABI
+  // Scaffold subgraph
   let scaffold = await withSpinner(
     `Create subgraph scaffold`,
     `Failed to create subgraph scaffold`,
@@ -768,10 +803,11 @@ const initSubgraphFromContract = async (
     async spinner => {
       let scaffold = await generateScaffold(
         {
+          protocolInstance,
           subgraphName,
           abi,
           network,
-          address,
+          contract,
           indexEvents,
           contractName,
           node,

package/src/protocols/ethereum/contract.js

@@ -0,0 +1,22 @@
+module.exports = class EthereumContract {
+  static identifierName() {
+    return 'address'
+  }
+
+  constructor(address) {
+    this.address = address
+  }
+
+  validate() {
+    const pattern = /^(0x)?[0-9a-fA-F]{40}$/
+
+    const errorMessage = "Must be 40 hexadecimal characters, with an optional '0x' prefix."
+
+    const valid = pattern.test(this.address)
+
+    return {
+      valid,
+      error: valid ? null : errorMessage,
+    }
+  }
+}

package/src/protocols/ethereum/scaffold/manifest.js

@@ -0,0 +1,32 @@
+const { abiEvents } = require('../../../scaffold/schema')
+const ABI = require('../abi')
+
+const source = ({ contract, contractName }) => `
+      address: '${contract}'
+      abi: ${contractName}`
+
+const mapping = ({ abi, contractName }) => `
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        ${abiEvents(abi)
+          .map(event => `- ${event.get('_alias')}`)
+          .join('\n        ')}
+      abis:
+        - name: ${contractName}
+          file: ./abis/${contractName}.json
+      eventHandlers:
+        ${abiEvents(abi)
+          .map(
+            event => `
+        - event: ${ABI.eventSignature(event)}
+          handler: handle${event.get('_alias')}`,
+          )
+          .join('')}
+      file: ./src/mapping.ts`
+
+module.exports = {
+  source,
+  mapping,
+}

package/src/protocols/ethereum/scaffold/mapping.js

@@ -0,0 +1,76 @@
+const { generateEventFieldAssignments } = require('../../../scaffold/mapping')
+
+const generatePlaceholderHandlers = ({ abi, events, contractName }) =>
+  `
+  import { BigInt } from '@graphprotocol/graph-ts'
+  import { ${contractName}, ${events.map(event => event._alias)} }
+    from '../generated/${contractName}/${contractName}'
+  import { ExampleEntity } from '../generated/schema'
+
+  ${events
+    .map((event, index) =>
+      index === 0
+        ? `
+    export function handle${event._alias}(event: ${event._alias}): void {
+      // Entities can be loaded from the store using a string ID; this ID
+      // needs to be unique across all entities of the same type
+      let entity = ExampleEntity.load(event.transaction.from.toHex())
+
+      // Entities only exist after they have been saved to the store;
+      // \`null\` checks allow to create entities on demand
+      if (!entity) {
+        entity = new ExampleEntity(event.transaction.from.toHex())
+
+        // Entity fields can be set using simple assignments
+        entity.count = BigInt.fromI32(0)
+      }
+
+      // BigInt and BigDecimal math are supported
+      entity.count = entity.count + BigInt.fromI32(1)
+
+      // Entity fields can be set based on event parameters
+      ${generateEventFieldAssignments(event)
+        .slice(0, 2)
+        .join('\n')}
+
+      // Entities can be written to the store with \`.save()\`
+      entity.save()
+
+      // Note: If a handler doesn't require existing field values, it is faster
+      // _not_ to load the entity from the store. Instead, create it fresh with
+      // \`new Entity(...)\`, set the fields that should be updated and save the
+      // entity back to the store. Fields that were not set or unset remain
+      // unchanged, allowing for partial updates to be applied.
+
+      // It is also possible to access smart contracts from mappings. For
+      // example, the contract that has emitted the event can be connected to
+      // with:
+      //
+      // let contract = Contract.bind(event.address)
+      //
+      // The following functions can then be called on this contract to access
+      // state variables and other data:
+      //
+      // ${
+        abi
+          .codeGenerator()
+          .callableFunctions()
+          .isEmpty()
+          ? 'None'
+          : abi
+              .codeGenerator()
+              .callableFunctions()
+              .map(fn => `- contract.${fn.get('name')}(...)`)
+              .join('\n// ')
+      }
+    }
+    `
+        : `
+export function handle${event._alias}(event: ${event._alias}): void {}
+`,
+    )
+    .join('\n')}`
+
+module.exports = {
+  generatePlaceholderHandlers,
+}

package/src/protocols/ethereum/subgraph.js

@@ -1,7 +1,6 @@
 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 = {}) {
@@ -12,7 +11,6 @@ module.exports = class EthereumSubgraph {
 
   validateManifest() {
     return this.validateAbis()
-      .concat(this.validateContractAddresses())
       .concat(this.validateEvents())
       .concat(this.validateCallFunctions())
   }
@@ -72,18 +70,6 @@ ${abiNames
     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)