@graphprotocol/graph-cli 0.30.0-alpha.1 → 0.30.2

package/src/command-helpers/scaffold.js

@@ -1,8 +1,28 @@
 const fs = require('fs-extra')
 const path = require('path')
+const prettier = require('prettier')
+const yaml = require('yaml')
 
 const { step } = require('./spinner')
 const Scaffold = require('../scaffold')
+const { generateEventIndexingHandlers } = require('../scaffold/mapping')
+const { generateEventType, abiEvents } = require('../scaffold/schema')
+const { strings } = require('gluegun')
+const { Map } = require('immutable')
+
+const generateDataSource = async (protocol, contractName, network, contractAddress, abi) => {
+  const protocolManifest = protocol.getManifestScaffold()
+
+  return Map.of(
+    'kind', protocol.name,
+    'name', contractName,
+    'network', network,
+    'source', yaml.parse(prettier.format(protocolManifest.source({contract: contractAddress, contractName}),
+      {parser: 'yaml'})),
+    'mapping', yaml.parse(prettier.format(protocolManifest.mapping({abi, contractName}),
+      {parser: 'yaml'}))
+  ).asMutable()
+}
 
 const generateScaffold = async (
   {
@@ -59,8 +79,53 @@ const writeScaffold = async (scaffold, directory, spinner) => {
   await writeScaffoldDirectory(scaffold, directory, spinner)
 }
 
+const writeABI = async (abi, contractName, abiPath = `./abis/${contractName}.json`) => {
+  let data = prettier.format(JSON.stringify(abi.data), {
+    parser: 'json',
+  })
+
+  await fs.writeFile(abiPath, data, { encoding: 'utf-8' })
+}
+
+const writeSchema = async (abi, protocol, schemaPath, entities) => {
+  const events = protocol.hasEvents()
+    ? abiEvents(abi).filter(event => entities.indexOf(event.get('name')) === -1).toJS()
+    : []
+
+  let data = prettier.format(
+    events.map(
+        event => generateEventType(event, protocol.name)
+      ).join('\n\n'),
+    {
+      parser: 'graphql',
+    },
+  )
+
+  await fs.appendFile(schemaPath, data, { encoding: 'utf-8' })
+}
+
+const writeMapping = async (abi, protocol, contractName, entities) => {
+  const events = protocol.hasEvents()
+    ? abiEvents(abi).filter(event => entities.indexOf(event.get('name')) === -1).toJS()
+    : []
+
+  let mapping = prettier.format(
+    generateEventIndexingHandlers(
+        events,
+        contractName,
+      ),
+    { parser: 'typescript', semi: false },
+  )
+
+  await fs.writeFile(`./src/${strings.kebabCase(contractName)}.ts`, mapping, { encoding: 'utf-8' })
+}
+
 module.exports = {
   ...module.exports,
   generateScaffold,
   writeScaffold,
+  generateDataSource,
+  writeABI,
+  writeSchema,
+  writeMapping,
 }

package/src/commands/add.js

@@ -0,0 +1,198 @@
+const chalk = require('chalk')
+const toolbox = require('gluegun/toolbox')
+const immutable = require('immutable')
+const { withSpinner } = require('../command-helpers/spinner')
+const Subgraph = require('../subgraph')
+const Protocol = require('../protocols')
+const DataSourcesExtractor = require('../command-helpers/data-sources')
+const { generateDataSource, writeABI, writeSchema, writeMapping } = require('../command-helpers/scaffold')
+const { loadAbiFromEtherscan, loadAbiFromBlockScout } = require('../command-helpers/abi')
+const EthereumABI = require('../protocols/ethereum/abi')
+const { fixParameters } = require('../command-helpers/gluegun')
+
+const HELP = `
+${chalk.bold('graph add')} <address> [<subgraph-manifest default: "./subgraph.yaml">]
+
+${chalk.dim('Options:')}
+
+      --abi <path>              Path to the contract ABI (default: download from Etherscan)
+      --contract-name           Name of the contract (default: Contract)
+      --merge-entities          Whether to merge entities with the same name (default: false)
+  -h, --help                    Show usage information
+`
+
+module.exports = {
+  description: 'Creates a new subgraph with basic scaffolding',
+  run: async toolbox => {
+    // Obtain tools
+    let { print, system } = toolbox
+
+    // Read CLI parameters
+    let {
+      abi,
+      contractName,
+      h,
+      help,
+      mergeEntities
+    } = toolbox.parameters.options
+
+    let address = toolbox.parameters.first
+    let manifestPath = toolbox.parameters.second || './subgraph.yaml'
+    contractName = contractName || 'Contract'
+
+    // Validate the address
+    if (!address) {
+      print.error('No contract address provided')
+      process.exitCode = 1
+      return
+    }
+
+    try {
+      fixParameters(toolbox.parameters, {
+        h,
+        help,
+        mergeEntities,
+      })
+    } catch (e) {
+      print.error(e.message)
+      process.exitCode = 1
+      return
+    }
+
+    // Show help text if requested
+    if (help || h) {
+      print.info(HELP)
+      return
+    }
+
+    const dataSourcesAndTemplates = await DataSourcesExtractor.fromFilePath(manifestPath)
+    let protocol = Protocol.fromDataSources(dataSourcesAndTemplates)
+    let manifest = await Subgraph.load(manifestPath, { protocol })
+    let network = manifest.result.get('dataSources').get(0).get('network')
+    let result = manifest.result.asMutable()
+
+    let entities = getEntities(manifest)
+    let contractNames = getContractNames(manifest)
+    if (contractNames.indexOf(contractName) !== -1) {
+      print.error(
+        `Datasource or template with name ${contractName} already exists, please choose a different name`,
+      )
+      process.exitCode = 1
+      return
+    }
+
+    let ethabi = null
+    if (abi) {
+      ethabi = EthereumABI.load(contractName, abi)
+    } else {
+      if (network === 'poa-core') {
+        ethabi = await loadAbiFromBlockScout(EthereumABI, network, address)
+      } else {
+        ethabi = await loadAbiFromEtherscan(EthereumABI, network, address)
+      }
+    }
+
+    let { collisionEntities, onlyCollisions, abiData } = updateEventNamesOnCollision(ethabi, entities, contractName, mergeEntities)
+    ethabi.data = abiData
+
+    await writeABI(ethabi, contractName, abi)
+    await writeSchema(ethabi, protocol, result.getIn(['schema', 'file']), collisionEntities)
+    await writeMapping(ethabi, protocol, contractName, collisionEntities)
+
+    let dataSources = result.get('dataSources')
+    let dataSource = await generateDataSource(protocol, 
+      contractName, network, address, ethabi)
+
+    // Handle the collisions edge case by copying another data source yaml data
+    if (mergeEntities && onlyCollisions) {
+      let firstDataSource = dataSources.get(0)
+      let source = dataSource.get('source')
+      let mapping = firstDataSource.get('mapping').asMutable()
+
+      // Save the address of the new data source
+      source.abi = firstDataSource.get('source').get('abi')
+
+      dataSource.set('mapping', mapping)
+      dataSource.set('source', source)
+    }
+
+    result.set('dataSources', dataSources.push(dataSource))
+
+    await Subgraph.write(result, manifestPath)
+
+    // Detect Yarn and/or NPM
+    let yarn = await system.which('yarn')
+    let npm = await system.which('npm')
+    if (!yarn && !npm) {
+      print.error(
+        `Neither Yarn nor NPM were found on your system. Please install one of them.`,
+      )
+      process.exitCode = 1
+      return
+    }
+
+    await withSpinner(
+      'Running codegen',
+      'Failed to run codegen',
+      'Warning during codegen',
+      async spinner => {
+        await system.run(yarn ? 'yarn codegen' : 'npm run codegen')
+      }
+    )
+  }
+}
+
+const getEntities = (manifest) => {
+  let dataSources = manifest.result.get('dataSources', immutable.List())
+  let templates = manifest.result.get('templates', immutable.List())
+
+  return dataSources
+    .concat(templates)
+    .map(dataSource => dataSource.getIn(['mapping', 'entities']))
+    .flatten()
+}
+
+const getContractNames = (manifest) => {
+  let dataSources = manifest.result.get('dataSources', immutable.List())
+  let templates = manifest.result.get('templates', immutable.List())
+
+  return dataSources
+    .concat(templates)
+    .map(dataSource => dataSource.get('name'))
+}
+
+const updateEventNamesOnCollision = (ethabi, entities, contractName, mergeEntities) => {
+  let abiData = ethabi.data
+  let { print } = toolbox
+  let collisionEntities = []
+  let onlyCollisions = true
+
+  for (let i = 0; i < abiData.size; i++) {
+    let dataRow = abiData.get(i).asMutable()
+
+    if (dataRow.get('type') === 'event'){
+      if (entities.indexOf(dataRow.get('name')) !== -1) {
+        if (entities.indexOf(`${contractName}${dataRow.get('name')}`) !== -1) {
+          print.error(`Contract name ('${contractName}') 
+            + event name ('${dataRow.get('name')}') entity already exists.`)
+          process.exitCode = 1
+          return
+        }
+        
+        if (mergeEntities) {
+          collisionEntities.push(dataRow.get('name'))
+          abiData = abiData.asImmutable().delete(i) // needs to be immutable when deleting, yes you read that right - https://github.com/immutable-js/immutable-js/issues/1901
+          i-- // deletion also shifts values to the left
+          continue
+        } else {
+          dataRow.set('name', `${contractName}${dataRow.get('name')}`)
+        }
+      } else {
+        onlyCollisions = false
+      }
+    }
+    abiData = abiData.asMutable().set(i, dataRow)
+  }
+
+  return { abiData, collisionEntities, onlyCollisions }
+}

package/src/commands/init.js

@@ -16,6 +16,7 @@ const { initNetworksConfig } = require('../command-helpers/network')
 const { withSpinner, step } = require('../command-helpers/spinner')
 const { fixParameters } = require('../command-helpers/gluegun')
 const { chooseNodeUrl } = require('../command-helpers/node')
+const { loadAbiFromEtherscan, loadAbiFromBlockScout } = require('../command-helpers/abi')
 const { generateScaffold, writeScaffold } = require('../command-helpers/scaffold')
 const { abiEvents } = require('../scaffold/schema')
 const { validateContract } = require('../validation')
@@ -57,6 +58,11 @@ ${chalk.dim.underline('NEAR:')}
 
       --network <${availableNetworks.get('near').join('|')}>
                                  Selects the network the contract is deployed to
+
+${chalk.dim.underline('Cosmos:')}
+
+      --network <${availableNetworks.get('cosmos').join('|')}>
+                                 Selects the network the contract is deployed to
 `
 
 const processInitForm = async (
@@ -169,6 +175,11 @@ const processInitForm = async (
         return value
       },
     },
+    // TODO:
+    //
+    // protocols that don't support contract
+    // - arweave
+    // - cosmos
     {
       type: 'input',
       name: 'contract',
@@ -176,10 +187,10 @@ const processInitForm = async (
         ProtocolContract = protocolInstance.getContract()
         return `Contract ${ProtocolContract.identifierName()}`
       },
-      skip: fromExample !== undefined,
+      skip: () => fromExample !== undefined || !protocolInstance.hasContract(),
       initial: contract,
       validate: async value => {
-        if (fromExample !== undefined) {
+        if (fromExample !== undefined || !protocolInstance.hasContract()) {
           return true
         }
 
@@ -237,11 +248,11 @@ const processInitForm = async (
       name: 'contractName',
       message: 'Contract Name',
       initial: contractName || 'Contract',
-      skip: () => fromExample !== undefined,
+      skip: () => fromExample !== undefined || !protocolInstance.hasContract(),
       validate: value => value && value.length > 0,
       result: value => {
-        contractName = value;
-        return value;
+        contractName = value
+        return value
       }
     },
   ]
@@ -254,68 +265,6 @@ const processInitForm = async (
   }
 }
 
-const loadAbiFromBlockScout = async (ABI, network, address) =>
-  await withSpinner(
-    `Fetching ABI from BlockScout`,
-    `Failed to fetch ABI from BlockScout`,
-    `Warnings while fetching ABI from BlockScout`,
-    async spinner => {
-      let result = await fetch(
-        `https://blockscout.com/${
-          network.replace('-', '/')
-        }/api?module=contract&action=getabi&address=${address}`,
-      )
-      let json = await result.json()
-
-      // BlockScout returns a JSON object that has a `status`, a `message` and
-      // a `result` field. The `status` is '0' in case of errors and '1' in
-      // case of success
-      if (json.status === '1') {
-        return new ABI('Contract', undefined, immutable.fromJS(JSON.parse(json.result)))
-      } else {
-        throw new Error('ABI not found, try loading it from a local file')
-      }
-    },
-  )
-
-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`;
-    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`;
-    case "avalanche": return `https://api.snowtrace.io/api`;
-    default: return `https://api-${network}.etherscan.io/api`;
-  }
-}
-
-const loadAbiFromEtherscan = async (ABI, network, address) =>
-  await withSpinner(
-    `Fetching ABI from Etherscan`,
-    `Failed to fetch ABI from Etherscan`,
-    `Warnings while fetching ABI from Etherscan`,
-    async spinner => {
-      const scanApiUrl = getEtherscanLikeAPIUrl(network);
-      let result = await fetch(
-        `${scanApiUrl}?module=contract&action=getabi&address=${address}`,
-      )
-      let json = await result.json()
-
-      // Etherscan returns a JSON object that has a `status`, a `message` and
-      // a `result` field. The `status` is '0' in case of errors and '1' in
-      // case of success
-      if (json.status === '1') {
-        return new ABI('Contract', undefined, immutable.fromJS(JSON.parse(json.result)))
-      } else {
-        throw new Error('ABI not found, try loading it from a local file')
-      }
-    },
-  )
-
 const loadAbiFromFile = async (ABI, filename) => {
   let exists = await toolbox.filesystem.exists(filename)
 
@@ -836,11 +785,13 @@ const initSubgraphFromContract = async (
     return
   }
 
-  let identifierName = protocolInstance.getContract().identifierName()
-  let networkConf = await initNetworksConfig(toolbox, directory, identifierName)
-  if (networkConf !== true) {
-    process.exitCode = 1
-    return
+  if (protocolInstance.hasContract()) {
+    let identifierName = protocolInstance.getContract().identifierName()
+    let networkConf = await initNetworksConfig(toolbox, directory, identifierName)
+    if (networkConf !== true) {
+      process.exitCode = 1
+      return
+    }
   }
 
   // Initialize a fresh Git repository

package/src/migrations.js

@@ -6,10 +6,8 @@ const MIGRATIONS = [
   require('./migrations/mapping_api_version_0_0_3'),
   require('./migrations/mapping_api_version_0_0_4'),
   require('./migrations/mapping_api_version_0_0_5'),
-  require('./migrations/mapping_api_version_0_0_6'),
   require('./migrations/spec_version_0_0_2'),
   require('./migrations/spec_version_0_0_3'),
-  require('./migrations/spec_version_0_0_4'),
 ]
 
 const applyMigrations = async options =>

package/src/protocols/arweave/manifest.graphql

@@ -0,0 +1,57 @@
+# Each referenced type's in any of the types below must be listed
+# here either as `scalar` or `type` for the validation code to work
+# properly.
+#
+# That's why `String` is listed as a scalar even though it's built-in
+# GraphQL basic types.
+scalar String
+scalar File
+scalar BigInt
+
+type SubgraphManifest {
+  specVersion: String!
+  schema: Schema!
+  description: String
+  repository: String
+  graft: Graft
+  dataSources: [DataSource!]!
+}
+
+type Schema {
+  file: File!
+}
+
+type DataSource {
+  kind: String!
+  name: String!
+  network: String
+  source: ContractSource!
+  mapping: ContractMapping!
+}
+
+type ContractSource {
+  owner: String
+  startBlock: BigInt
+}
+
+type ContractMapping {
+  apiVersion: String!
+  language: String!
+  file: File!
+  entities: [String!]!
+  blockHandlers: [BlockHandler!]
+  transactionHandlers: [TransactionHandler!]
+}
+
+type BlockHandler {
+  handler: String!
+}
+
+type TransactionHandler {
+  handler: String!
+}
+
+type Graft {
+  base: String!
+  block: BigInt!
+}

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

@@ -0,0 +1,19 @@
+const source = ({ contract }) => `
+      owner: '${contract}'`
+
+const mapping = () => `
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        - Block
+        - Transaction
+      blockHandlers:
+        - handler: handleBlock
+      transactionHandlers:
+        - handler: handleTx
+      file: ./src/mapping.ts`
+
+module.exports = {
+  source,
+  mapping,
+}

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

@@ -0,0 +1,53 @@
+const generatePlaceholderHandlers = () =>
+  `
+  import { arweave, BigInt } from '@graphprotocol/graph-ts'
+  import { Block, Transaction } from '../generated/schema'
+
+  export function handleBlock(block: arweave.Block): void {
+    // Entities can be loaded from the store using a indepHash; this indepHash
+    // needs to be unique across all entities of the same type
+    let entity = Block.load(block.indepHash.toHexString())
+
+    // Entities only exist after they have been saved to the store;
+    // \`null\` checks allow to create entities on demand
+    if (!entity) {
+      entity = new Block(block.indepHash.toHexString());
+
+      // Entity fields can be set using simple assignments
+      entity.height = BigInt.fromU64(block.height)
+    }
+
+    // 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.
+  }
+
+  export function handleTx(tb: arweave.TransactionWithBlockPtr): void {
+    const tx = tb.tx;
+    const entity = new Transaction(tx.id.toHexString());
+
+    entity.block = tb.block.indepHash;
+    entity.tx_id = tx.id;
+    entity.last_tx = tx.lastTx;
+    entity.owner = tx.owner;
+    entity.tags = saveTags(tx.id.toHexString(), tx.tags);
+    entity.data = tx.data;
+    entity.data_root = tx.dataRoot;
+    entity.data_size = tx.dataSize;
+    entity.target = tx.target;
+    entity.quantity = tx.quantity;
+    entity.signature = tx.signature;
+    entity.reward = tx.reward;
+
+    entity.save();
+  }
+`
+
+module.exports = {
+  generatePlaceholderHandlers,
+}

package/src/protocols/arweave/subgraph.js

@@ -0,0 +1,20 @@
+const immutable = require('immutable')
+
+module.exports = class ArweaveSubgraph {
+  constructor(options = {}) {
+    this.manifest = options.manifest
+    this.resolveFile = options.resolveFile
+    this.protocol = options.protocol
+  }
+
+  validateManifest() {
+    return immutable.List()
+  }
+
+  handlerTypes() {
+    return immutable.List([
+      'blockHandlers',
+      'transactionHandlers',
+    ])
+  }
+}

package/src/protocols/{tendermint → cosmos}/manifest.graphql

@@ -10,6 +10,7 @@ scalar BigInt
 
 type SubgraphManifest {
   specVersion: String!
+  features: [String!]
   schema: Schema!
   description: String
   repository: String
@@ -40,6 +41,11 @@ type ContractMapping {
   entities: [String!]!
   blockHandlers: [BlockHandler!]
   eventHandlers: [EventHandler!]
+  transactionHandlers: [TransactionHandler!]
+}
+
+type TransactionHandler {
+  handler: String!
 }
 
 type BlockHandler {

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

@@ -0,0 +1,16 @@
+const source = () => `
+      startBlock: 0`
+
+const mapping = () => `
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        - ExampleEntity
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/contract.ts`
+
+module.exports = {
+  source,
+  mapping,
+}

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

@@ -0,0 +1,39 @@
+const generatePlaceholderHandlers = () =>
+  `
+  import { cosmos, BigInt } from '@graphprotocol/graph-ts'
+  import { ExampleEntity } from '../generated/schema'
+
+  export function handleBlock(block: cosmos.Block): 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(block.header.hash.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(block.header.hash.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 receipt information
+    entity.height = block.header.height
+
+    // 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.
+  }
+`
+
+module.exports = {
+  generatePlaceholderHandlers,
+}

package/src/protocols/{tendermint → cosmos}/subgraph.js

@@ -1,6 +1,6 @@
 const immutable = require('immutable')
 
-module.exports = class TendermintSubgraph {
+module.exports = class CosmosSubgraph {
   constructor(options = {}) {
     this.manifest = options.manifest
     this.resolveFile = options.resolveFile
@@ -15,6 +15,7 @@ module.exports = class TendermintSubgraph {
     return immutable.List([
       'blockHandlers',
       'eventHandlers',
+      'transactionHandlers',
     ])
   }
 }