@graphprotocol/graph-cli 0.24.0 → 0.25.2

package/examples/basic-event-handlers/package.json

@@ -9,7 +9,7 @@
     "deploy-test": "../../bin/graph deploy test/basic-event-handlers --version-label v0.0.1 --ipfs http://localhost:15001 --node http://127.0.0.1:18020"
   },
   "devDependencies": {
-    "@graphprotocol/graph-ts": "0.24.0",
+    "@graphprotocol/graph-ts": "0.24.1",
     "apollo-fetch": "^0.7.0"
   },
   "dependencies": {

package/examples/basic-event-handlers/yarn.lock

@@ -2,10 +2,10 @@
 # yarn lockfile v1
 
 
-"@graphprotocol/graph-ts@0.24.0":
-  version "0.24.0"
-  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-ts/-/graph-ts-0.24.0.tgz#ccfa14edf015f3fc6d37b7d2a95e71ec6acc0005"
-  integrity sha512-XciVlalOXzS2Iv8WeAwO0jwWzPBlzEWLtwNT5FdII962TAzbgZ6fx1nNGjGZLwwq38/aUX154+tdvEmL57gZqQ==
+"@graphprotocol/graph-ts@0.24.1":
+  version "0.24.1"
+  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-ts/-/graph-ts-0.24.1.tgz#50961b52b5383f9c5cf5e6e23fa039f24e729ddf"
+  integrity sha512-2vU4m5ZPQIqMlMce/z5vmOtGHRlRmcRhMfemS3NIwxCSxSBGVnX2zb7QBTzzdQKGwsAZdbz6V0okkOtvohELfQ==
   dependencies:
     assemblyscript "0.19.10"
 

package/examples/example-subgraph/package.json

@@ -7,7 +7,7 @@
     "build-wast": "../../bin/graph build -t wast subgraph.yaml"
   },
   "devDependencies": {
-    "@graphprotocol/graph-ts": "0.24.0"
+    "@graphprotocol/graph-ts": "0.24.1"
   },
   "resolutions": {
     "assemblyscript": "0.19.10"

package/examples/example-subgraph/yarn.lock

@@ -2,10 +2,10 @@
 # yarn lockfile v1
 
 
-"@graphprotocol/graph-ts@0.24.0":
-  version "0.24.0"
-  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-ts/-/graph-ts-0.24.0.tgz#ccfa14edf015f3fc6d37b7d2a95e71ec6acc0005"
-  integrity sha512-XciVlalOXzS2Iv8WeAwO0jwWzPBlzEWLtwNT5FdII962TAzbgZ6fx1nNGjGZLwwq38/aUX154+tdvEmL57gZqQ==
+"@graphprotocol/graph-ts@0.24.1":
+  version "0.24.1"
+  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-ts/-/graph-ts-0.24.1.tgz#50961b52b5383f9c5cf5e6e23fa039f24e729ddf"
+  integrity sha512-2vU4m5ZPQIqMlMce/z5vmOtGHRlRmcRhMfemS3NIwxCSxSBGVnX2zb7QBTzzdQKGwsAZdbz6V0okkOtvohELfQ==
   dependencies:
     assemblyscript "0.19.10"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.24.0",
+  "version": "0.25.2",
   "description": "CLI for building for and deploying to The Graph",
   "dependencies": {
     "assemblyscript": "0.19.10",
@@ -12,7 +12,7 @@
     "dockerode": "^2.5.8",
     "fs-extra": "^9.0.0",
     "glob": "^7.1.2",
-    "gluegun": "^4.3.1",
+    "gluegun": "https://github.com/edgeandnode/gluegun#v4.3.1-pin-colors-dep",
     "graphql": "^15.5.0",
     "immutable": "^3.8.2",
     "ipfs-http-client": "^34.0.0",

package/src/codegen/schema.js

@@ -80,17 +80,24 @@ module.exports = class SchemaCodeGenerator {
       .map(field => {
         const name = field.getIn(['name', 'value'])
         const type = this._typeFromGraphQl(field.get('type'))
+
         const isNullable = type instanceof tsCodegen.NullableType
+        const isPrimitive = type.isPrimitive && type.isPrimitive()
 
         const directives = field.get('directives')
         const isDerivedFrom = directives.some(directive => directive.getIn(['name', 'value']) === 'derivedFrom')
 
-        return { name, type, isNullable, isDerivedFrom }
+        return { name, type, isNullable, isPrimitive, isDerivedFrom }
       })
       // We only call the setter with the default value in the constructor for fields that are:
+      // - Not primitive (such as Int/i32)
       // - Not nullable, so that AS doesn't break when subgraph developers try to access them before a `set`
       // - Not tagged as `derivedFrom`, because they only exist in query time
-      .filter(({ isNullable, isDerivedFrom }) => !isNullable && !isDerivedFrom)
+      .filter(({
+        isNullable,
+        isPrimitive,
+        isDerivedFrom,
+      }) => !(isNullable || isPrimitive || isDerivedFrom))
       .map(({ name, type, isNullable }) => {
         const fieldTypeString = isNullable ? type.inner.toString() : type.toString()
 

package/src/codegen/types/defaults.js

@@ -0,0 +1,34 @@
+const immutable = require('immutable')
+
+// TODO: kill me
+const EMPTY_ARRAY = 'new Array(0)'
+
+const ASC_DEFAULTS = [
+  // Scalar values
+
+  ['Address', 'Address.zero()'],
+  ['Bytes', 'Bytes.empty()'],
+  ['boolean', 'false'],
+  ['i32', '0'],
+  ['string', '""'],
+  ['BigInt', 'BigInt.zero()'],
+  ['BigDecimal', 'BigDecimal.zero()'],
+
+  // Arrays
+
+  ['Array<Address>', EMPTY_ARRAY],
+  ['Array<Bytes>', EMPTY_ARRAY],
+  ['Array<boolean>', EMPTY_ARRAY],
+  ['Array<i32>', EMPTY_ARRAY],
+  ['Array<string>', EMPTY_ARRAY],
+  ['Array<BigInt>', EMPTY_ARRAY],
+  ['Array<BigDecimal>', EMPTY_ARRAY],
+  ['Array<string | null>', EMPTY_ARRAY],
+]
+
+module.exports = immutable.fromJS({
+  AssemblyScript: ASC_DEFAULTS,
+})
+// TODO: use me:
+  // [/Array<.*>/, 'new Array(0)'],
+  // [/Array\<.*\>/, 'new Array(0)'],

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/command-helpers/version.js

@@ -57,7 +57,7 @@ const assertGraphTsVersion = async (sourceDir, minimumGraphTsVersion) => {
   if (graphTsVersion && semver.lt(semver.coerce(graphTsVersion), minimumGraphTsVersion)) {
     throw new Error(
       `To use this version of the graph-cli you must upgrade the graph-ts dependency to a version greater than or equal to ${minimumGraphTsVersion}
-Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://gist.github.com/otaviopace/8406cb39644d2e7678570d1e7f50dac4`
+Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://thegraph.com/docs/developer/assemblyscript-migration-guide`
     )
   }
 }

package/src/command-helpers/version.test.js

@@ -197,7 +197,7 @@ describe('Version Command Helpers', () => {
         .rejects
         .toThrow(new Error(
           `To use this version of the graph-cli you must upgrade the graph-ts dependency to a version greater than or equal to ${minimumGraphTsVersion}
-Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://gist.github.com/otaviopace/8406cb39644d2e7678570d1e7f50dac4`
+Also, you'll probably need to take a look at our AssemblyScript migration guide because of language breaking changes: https://thegraph.com/docs/developer/assemblyscript-migration-guide`
         ))
     })
     test('When the installed graph-ts version is a supported one', async () => {

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`,
@@ -260,6 +279,7 @@ const loadAbiFromBlockScout = async (network, address) =>
 const getEtherscanLikeAPIUrl = (network) => {
   switch(network){
     case "mainnet": return `https://api.etherscan.io/api`;
+    case "arbitrum-one": return `https://api.arbiscan.io/api`;
     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`;
@@ -267,7 +287,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 +310,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 +335,7 @@ module.exports = {
 
     // Read CLI parameters
     let {
+      protocol,
       product,
       studio,
       node,
@@ -400,35 +421,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 +476,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 +518,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 +748,13 @@ const initSubgraphFromExample = async (
 const initSubgraphFromContract = async (
   toolbox,
   {
+    protocolInstance,
     allowSimpleName,
     subgraphName,
     directory,
     abi,
     network,
-    address,
+    contract,
     indexEvents,
     contractName,
     node,
@@ -742,7 +778,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 +796,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 +804,11 @@ const initSubgraphFromContract = async (
     async spinner => {
       let scaffold = await generateScaffold(
         {
+          protocolInstance,
           subgraphName,
           abi,
           network,
-          address,
+          contract,
           indexEvents,
           contractName,
           node,