@graphprotocol/graph-cli 0.24.1 → 0.25.0

package/src/protocols/index.js

@@ -4,6 +4,12 @@ const EthereumTemplateCodeGen = require('./ethereum/codegen/template')
 const EthereumABI = require('./ethereum/abi')
 const EthereumSubgraph = require('./ethereum/subgraph')
 const NearSubgraph = require('./near/subgraph')
+const EthereumContract = require('./ethereum/contract')
+const NearContract = require('./near/contract')
+const EthereumManifestScaffold = require('./ethereum/scaffold/manifest')
+const NearManifestScaffold = require('./near/scaffold/manifest')
+const EthereumMappingScaffold = require('./ethereum/scaffold/mapping')
+const NearMappingScaffold = require('./near/scaffold/mapping')
 
 module.exports = class Protocol {
   static fromDataSources(dataSourcesAndTemplates) {
@@ -15,7 +21,7 @@ module.exports = class Protocol {
     this.name = this.normalizeName(name)
   }
 
-  availableProtocols() {
+  static availableProtocols() {
     return immutable.fromJS({
       // `ethereum/contract` is kept for backwards compatibility.
       // New networks (or protocol perhaps) shouldn't have the `/contract` anymore (unless a new case makes use of it).
@@ -24,15 +30,58 @@ module.exports = class Protocol {
     })
   }
 
+  static availableNetworks() {
+    return immutable.fromJS({
+      ethereum: [
+        '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',
+      ],
+      near: [
+        'near-mainnet',
+      ],
+    })
+  }
+
   normalizeName(name) {
-    return this.availableProtocols()
+    return Protocol.availableProtocols()
       .findKey(possibleNames => possibleNames.includes(name))
   }
 
+  displayName() {
+    switch (this.name) {
+      case 'ethereum':
+        return 'Ethereum'
+      case 'near':
+        return 'NEAR'
+    }
+  }
+
   // Receives a data source kind, and checks if it's valid
   // for the given protocol instance (this).
   isValidKindName(kind) {
-    return this.availableProtocols()
+    return Protocol.availableProtocols()
       .get(this.name, immutable.List())
       .includes(kind)
   }
@@ -40,7 +89,15 @@ module.exports = class Protocol {
   hasABIs() {
     switch (this.name) {
       case 'ethereum':
-      case 'ethereum/contract':
+        return true
+      case 'near':
+        return false
+    }
+  }
+
+  hasEvents() {
+    switch (this.name) {
+      case 'ethereum':
         return true
       case 'near':
         return false
@@ -50,7 +107,6 @@ module.exports = class Protocol {
   getTypeGenerator(options) {
     switch (this.name) {
       case 'ethereum':
-      case 'ethereum/contract':
         return new EthereumTypeGenerator(options)
       case 'near':
         return null
@@ -60,7 +116,6 @@ module.exports = class Protocol {
   getTemplateCodeGen(template) {
     switch (this.name) {
       case 'ethereum':
-      case 'ethereum/contract':
         return new EthereumTemplateCodeGen(template)
       default:
         throw new Error(
@@ -72,7 +127,6 @@ module.exports = class Protocol {
   getABI() {
     switch (this.name) {
       case 'ethereum':
-      case 'ethereum/contract':
         return EthereumABI
       case 'near':
         return null
@@ -84,7 +138,6 @@ module.exports = class Protocol {
 
     switch (this.name) {
       case 'ethereum':
-      case 'ethereum/contract':
         return new EthereumSubgraph(optionsWithProtocol)
       case 'near':
         return new NearSubgraph(optionsWithProtocol)
@@ -94,4 +147,31 @@ module.exports = class Protocol {
         )
     }
   }
+
+  getContract() {
+    switch (this.name) {
+      case 'ethereum':
+        return EthereumContract
+      case 'near':
+        return NearContract
+    }
+  }
+
+  getManifestScaffold() {
+    switch (this.name) {
+      case 'ethereum':
+        return EthereumManifestScaffold
+      case 'near':
+        return NearManifestScaffold
+    }
+  }
+
+  getMappingScaffold() {
+    switch (this.name) {
+      case 'ethereum':
+        return EthereumMappingScaffold
+      case 'near':
+        return NearMappingScaffold
+    }
+  }
 }

package/src/protocols/near/contract.js

@@ -0,0 +1,46 @@
+const MINIMUM_ACCOUNT_ID_LENGTH = 2
+const MAXIMUM_ACCOUNT_ID_LENGTH = 64
+
+const RULES_URL = 'https://docs.near.org/docs/concepts/account#account-id-rules'
+
+module.exports = class NearContract {
+  static identifierName() {
+    return 'account'
+  }
+
+  constructor(account) {
+    this.account = account
+  }
+
+  _validateLength() {
+    return this.account.length >= MINIMUM_ACCOUNT_ID_LENGTH &&
+      this.account.length <= MAXIMUM_ACCOUNT_ID_LENGTH
+  }
+
+  _validateFormat() {
+    const pattern = /^(([a-z\d]+[\-_])*[a-z\d]+\.)*([a-z\d]+[\-_])*[a-z\d]+$/
+
+    return pattern.test(this.account)
+  }
+
+  validate() {
+    if (!this._validateLength(this.account)) {
+      return {
+        valid: false,
+        error: `Account must be between '${MINIMUM_ACCOUNT_ID_LENGTH}' and '${MAXIMUM_ACCOUNT_ID_LENGTH}' characters, see ${RULES_URL}`,
+      }
+    }
+
+    if (!this._validateFormat()) {
+      return {
+        valid: false,
+        error: `Account must conform to the rules on ${RULES_URL}`,
+      }
+    }
+
+    return {
+      valid: true,
+      error: null,
+    }
+  }
+}

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

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

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

@@ -0,0 +1,39 @@
+const generatePlaceholderHandlers = () =>
+  `
+  import { near, BigInt } from '@graphprotocol/graph-ts'
+  import { ExampleEntity } from '../generated/schema'
+
+  export function handleReceipt(receiptWithOutcome: near.ReceiptWithOutcome): 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(receiptWithOutcome.receipt.id.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(receiptWithOutcome.receipt.id.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.block = receiptWithOutcome.block.header.hash
+
+    // 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/near/subgraph.js

@@ -1,5 +1,4 @@
 const immutable = require('immutable')
-const { validateContractValues } = require('../../validation')
 
 module.exports = class NearSubgraph {
   constructor(options = {}) {
@@ -9,28 +8,7 @@ module.exports = class NearSubgraph {
   }
 
   validateManifest() {
-    return this.validateContractAccounts()
-  }
-
-  validateContractAccounts() {
-    // Reference: https://docs.near.org/docs/concepts/account#account-id-rules
-    const MINIMUM_ACCOUNT_ID_LENGTH = 2
-    const MAXIMUM_ACCOUNT_ID_LENGTH = 64
-    const validateLength = accountId =>
-      accountId.length >= MINIMUM_ACCOUNT_ID_LENGTH &&
-      accountId.length <= MAXIMUM_ACCOUNT_ID_LENGTH
-    const nearAccountIdPattern = /^(([a-z\d]+[\-_])*[a-z\d]+\.)*([a-z\d]+[\-_])*[a-z\d]+$/
-
-    return validateContractValues(
-      this.manifest,
-      this.protocol,
-      'account',
-      accountId => validateLength(accountId) && nearAccountIdPattern.test(accountId),
-      `Must be between '${MINIMUM_ACCOUNT_ID_LENGTH}' and '${MAXIMUM_ACCOUNT_ID_LENGTH}' characters
-An Account ID consists of Account ID parts separated by '.' (dots)
-Each Account ID part consists of lowercase alphanumeric symbols separated by either a '_' (underscore) or '-' (dash)
-For further information look for: https://docs.near.org/docs/concepts/account#account-id-rules`,
-    )
+    return immutable.List()
   }
 
   handlerTypes() {

package/src/{scaffold.test.js → scaffold/ethereum.test.js}

@@ -1,11 +1,7 @@
-const ABI = require('./protocols/ethereum/abi')
+const ABI = require('../protocols/ethereum/abi')
 const immutable = require('immutable')
-const {
-  generateEventFieldAssignments,
-  generateManifest,
-  generateMapping,
-  generateSchema,
-} = require('./scaffold')
+const Scaffold = require('./')
+const Protocol = require('../protocols')
 
 const TEST_EVENT = {
   name: 'ExampleEvent',
@@ -73,21 +69,33 @@ const TEST_ABI = new ABI(
   ]),
 )
 
-describe('Subgraph scaffolding', () => {
+const protocol = new Protocol('ethereum')
+
+const scaffoldOptions = {
+  protocol,
+  abi: TEST_ABI,
+  contract: '0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d',
+  network: 'kovan',
+  contractName: 'Contract',
+}
+
+const scaffold = new Scaffold(scaffoldOptions)
+
+const scaffoldWithIndexEvents = new Scaffold({
+  ...scaffoldOptions,
+  indexEvents: true,
+})
+
+describe('Ethereum subgraph scaffolding', () => {
   test('Manifest', () => {
     expect(
-      generateManifest({
-        abi: TEST_ABI,
-        network: 'kovan',
-        address: '0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d',
-        contractName: 'Contract'
-      }),
+      scaffold.generateManifest(),
     ).toEqual(`\
 specVersion: 0.0.1
 schema:
   file: ./schema.graphql
 dataSources:
-  - kind: ethereum/contract
+  - kind: ethereum
     name: Contract
     network: kovan
     source:
@@ -113,7 +121,7 @@ dataSources:
   })
 
   test('Schema (default)', () => {
-    expect(generateSchema({ abi: TEST_ABI })).toEqual(`\
+    expect(scaffold.generateSchema()).toEqual(`\
 type ExampleEntity @entity {
   id: ID!
   count: BigInt!
@@ -124,7 +132,7 @@ type ExampleEntity @entity {
   })
 
   test('Schema (for indexing events)', () => {
-    expect(generateSchema({ abi: TEST_ABI, indexEvents: true })).toEqual(`\
+    expect(scaffoldWithIndexEvents.generateSchema()).toEqual(`\
 type ExampleEvent @entity {
   id: ID!
   a: BigInt! # uint256
@@ -147,7 +155,7 @@ type ExampleEvent1 @entity {
   })
 
   test('Mapping (default)', () => {
-    expect(generateMapping({ abi: TEST_ABI, contractName: 'Contract' })).toEqual(`\
+    expect(scaffold.generateMapping()).toEqual(`\
 import { BigInt } from "@graphprotocol/graph-ts"
 import {
   Contract,
@@ -204,7 +212,7 @@ export function handleExampleEvent1(event: ExampleEvent1): void {}
   })
 
   test('Mapping (for indexing events)', () => {
-    expect(generateMapping({ abi: TEST_ABI, indexEvents: true, contractName: 'Contract' })).toEqual(`\
+    expect(scaffoldWithIndexEvents.generateMapping()).toEqual(`\
 import {
   ExampleEvent as ExampleEventEvent,
   ExampleEvent1 as ExampleEvent1Event

package/src/scaffold/index.js

@@ -0,0 +1,149 @@
+const prettier = require('prettier')
+const pkginfo = require('pkginfo')(module)
+
+const GRAPH_CLI_VERSION = process.env.GRAPH_CLI_TESTS
+  // JSON.stringify should remove this key, we will install the local
+  // graph-cli for the tests using `npm link` instead of fetching from npm.
+  ? undefined
+  // For scaffolding real subgraphs
+  : `${module.exports.version}`
+
+const {
+  abiEvents,
+  generateEventType,
+  generateExampleEntityType,
+} = require('./schema')
+const { generateEventIndexingHandlers } = require('./mapping')
+const { getSubgraphBasename } = require('../command-helpers/subgraph')
+
+module.exports = class Scaffold {
+  constructor(options = {}) {
+    this.protocol = options.protocol
+    this.abi = options.abi
+    this.indexEvents = options.indexEvents
+    this.contract = options.contract
+    this.network = options.network
+    this.contractName = options.contractName
+    this.subgraphName = options.subgraphName
+    this.node = options.node
+  }
+
+  generatePackageJson() {
+    return prettier.format(
+      JSON.stringify({
+        name: getSubgraphBasename(this.subgraphName),
+        license: 'UNLICENSED',
+        scripts: {
+          codegen: 'graph codegen',
+          build: 'graph build',
+          deploy:
+            `graph deploy ` +
+            `--node ${this.node} ` +
+            this.subgraphName,
+          'create-local': `graph create --node http://localhost:8020/ ${this.subgraphName}`,
+          'remove-local': `graph remove --node http://localhost:8020/ ${this.subgraphName}`,
+          'deploy-local':
+            `graph deploy ` +
+            `--node http://localhost:8020/ ` +
+            `--ipfs http://localhost:5001 ` +
+            this.subgraphName,
+        },
+        dependencies: {
+          '@graphprotocol/graph-cli': GRAPH_CLI_VERSION,
+          '@graphprotocol/graph-ts': `0.24.1`,
+        },
+      }),
+      { parser: 'json' },
+    )
+  }
+
+  generateManifest() {
+    const protocolManifest = this.protocol.getManifestScaffold()
+
+    return prettier.format(`
+specVersion: 0.0.1
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ${this.protocol.name}
+    name: ${this.contractName}
+    network: ${this.network}
+    source: ${protocolManifest.source(this)}
+    mapping: ${protocolManifest.mapping(this)}
+`,
+      { parser: 'yaml' },
+    )
+  }
+
+  generateSchema() {
+    const hasEvents = this.protocol.hasEvents()
+    const events = hasEvents
+      ? abiEvents(this.abi).toJS()
+      : []
+
+    return prettier.format(
+      hasEvents && this.indexEvents
+        ? events.map(
+            event => generateEventType(event, this.protocol.name)
+          )
+            .join('\n\n')
+        : generateExampleEntityType(this.protocol, events),
+      {
+        parser: 'graphql',
+      },
+    )
+  }
+
+  generateTsConfig() {
+    return prettier.format(
+      JSON.stringify({
+        extends: '@graphprotocol/graph-ts/types/tsconfig.base.json',
+        include: ['src'],
+      }),
+      { parser: 'json' },
+    )
+  }
+
+  generateMapping() {
+    const hasEvents = this.protocol.hasEvents()
+    const events = hasEvents
+      ? abiEvents(this.abi).toJS()
+      : []
+
+    const protocolMapping = this.protocol.getMappingScaffold()
+
+    return prettier.format(
+      hasEvents && this.indexEvents
+        ? generateEventIndexingHandlers(
+            events,
+            this.contractName,
+          )
+        : protocolMapping.generatePlaceholderHandlers({
+            ...this,
+            events,
+          }),
+      { parser: 'typescript', semi: false },
+    )
+  }
+
+  generateABIs() {
+    return this.protocol.hasABIs()
+      ? {
+        [`${this.contractName}.json`]: prettier.format(JSON.stringify(this.abi.data), {
+          parser: 'json',
+        }),
+      }
+      : undefined
+  }
+
+  generate() {
+    return {
+      'package.json': this.generatePackageJson(),
+      'subgraph.yaml': this.generateManifest(),
+      'schema.graphql': this.generateSchema(),
+      'tsconfig.json': this.generateTsConfig(),
+      src: { 'mapping.ts': this.generateMapping() },
+      abis: this.generateABIs(),
+    }
+  }
+}

package/src/scaffold/mapping.js

@@ -0,0 +1,49 @@
+const path = require('path')
+
+const util = require('../codegen/util')
+
+const generateFieldAssignment = path =>
+  `entity.${path.join('_')} = event.params.${path.join('.')}`
+
+const generateFieldAssignments = ({ index, input }) =>
+  input.type === 'tuple'
+    ? util
+        .unrollTuple({ value: input, index, path: [input.name || `param${index}`] })
+        .map(({ path }) => generateFieldAssignment(path))
+    : generateFieldAssignment([input.name || `param${index}`])
+
+const generateEventFieldAssignments = event =>
+  event.inputs.reduce(
+    (acc, input, index) => acc.concat(generateFieldAssignments({ input, index })),
+    [],
+  )
+
+const generateEventIndexingHandlers = (events, contractName) =>
+  `
+  import { ${events.map(
+    event => `${event._alias} as ${event._alias}Event`,
+  )}} from '../generated/${contractName}/${contractName}'
+  import { ${events.map(event => event._alias)} } from '../generated/schema'
+
+  ${events
+    .map(
+      event =>
+        `
+  export function handle${event._alias}(event: ${event._alias}Event): void {
+    let entity = new ${
+      event._alias
+    }(event.transaction.hash.toHex() + '-' + event.logIndex.toString())
+    ${generateEventFieldAssignments(event).join('\n')}
+    entity.save()
+  }
+    `,
+    )
+    .join('\n')}
+`
+
+module.exports = {
+  generateFieldAssignment,
+  generateFieldAssignments,
+  generateEventFieldAssignments,
+  generateEventIndexingHandlers,
+}

package/src/scaffold/near.test.js

@@ -0,0 +1,89 @@
+const immutable = require('immutable')
+const Scaffold = require('./')
+const Protocol = require('../protocols')
+
+const protocol = new Protocol('near')
+
+const scaffoldOptions = {
+  protocol,
+  contract: 'abc.def.near',
+  network: 'near-mainnet',
+  contractName: 'Contract',
+}
+
+const scaffold = new Scaffold(scaffoldOptions)
+
+describe('NEAR subgraph scaffolding', () => {
+  test('Manifest', () => {
+    expect(
+      scaffold.generateManifest(),
+    ).toEqual(`\
+specVersion: 0.0.1
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: near
+    name: Contract
+    network: near-mainnet
+    source:
+      account: "abc.def.near"
+    mapping:
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        - ExampleEntity
+      receiptHandlers:
+        - handler: handleReceipt
+      file: ./src/mapping.ts
+`)
+  })
+
+  test('Schema (default)', () => {
+    expect(scaffold.generateSchema()).toEqual(`\
+type ExampleEntity @entity {
+  id: ID!
+  block: Bytes!
+  count: BigInt!
+}
+`)
+  })
+
+  test('Mapping (default)', () => {
+    expect(scaffold.generateMapping()).toEqual(`\
+import { near, BigInt } from "@graphprotocol/graph-ts"
+import { ExampleEntity } from "../generated/schema"
+
+export function handleReceipt(
+  receiptWithOutcome: near.ReceiptWithOutcome
+): 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(receiptWithOutcome.receipt.id.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(receiptWithOutcome.receipt.id.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.block = receiptWithOutcome.block.header.hash
+
+  // 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.
+}
+`)
+  })
+})