@graphprotocol/graph-cli 0.37.3 → 0.37.4

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

@@ -1,41 +0,0 @@
-import immutable from 'immutable';
-import * as tsCodegen from '../../../codegen/typescript';
-
-export default class EthereumTemplateCodeGen {
-  constructor(public template: immutable.Map<any, any>) {
-    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/contract.ts

@@ -1,24 +0,0 @@
-import { Contract } from '../contract';
-
-export default class EthereumContract implements Contract {
-  static identifierName() {
-    return 'address';
-  }
-
-  constructor(private address: string) {
-    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/manifest.graphql

@@ -1,94 +0,0 @@
-# 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
-scalar Boolean
-
-type SubgraphManifest {
-  specVersion: String!
-  features: [String!]
-  schema: Schema!
-  description: String
-  repository: String
-  graft: Graft
-  dataSources: [DataSource!]!
-  templates: [DataSourceTemplate!]
-}
-
-type Schema {
-  file: File!
-}
-
-type DataSource {
-  kind: String!
-  name: String!
-  network: String
-  source: ContractSource!
-  mapping: ContractMapping!
-}
-
-type ContractSource {
-  address: String
-  abi: String!
-  startBlock: BigInt
-}
-
-type ContractMapping {
-  kind: String
-  apiVersion: String!
-  language: String!
-  file: File!
-  entities: [String!]!
-  abis: [ContractAbi!]!
-  blockHandlers: [BlockHandler!]
-  callHandlers: [CallHandler!]
-  eventHandlers: [ContractEventHandler!]
-}
-
-type ContractAbi {
-  name: String!
-  file: File!
-}
-
-type BlockHandler {
-  handler: String!
-  filter: BlockFilter
-}
-
-type BlockFilter {
-  kind: String!
-}
-
-type CallHandler {
-  function: String!
-  handler: String!
-}
-
-type ContractEventHandler {
-  event: String!
-  topic0: String
-  handler: String!
-  receipt: Boolean
-}
-
-type Graft {
-  base: String!
-  block: BigInt!
-}
-
-type DataSourceTemplate {
-  kind: String!
-  name: String!
-  network: String
-  source: ContractSourceTemplate!
-  mapping: ContractMapping!
-}
-
-type ContractSourceTemplate {
-  abi: String!
-}

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

@@ -1,28 +0,0 @@
-import { strings } from 'gluegun';
-import { abiEvents } from '../../../scaffold/schema';
-import ABI from '../abi';
-
-export const source = ({ contract, contractName }: { contract: string; contractName: string }) => `
-      address: '${contract}'
-      abi: ${contractName}`;
-
-export const mapping = ({ abi, contractName }: { abi: ABI; contractName: string }) => `
-      kind: ethereum/events
-      apiVersion: 0.0.7
-      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/${strings.kebabCase(contractName)}.ts`;

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

@@ -1,76 +0,0 @@
-import { generateEventFieldAssignments } from '../../../scaffold/mapping';
-import ABI from '../abi';
-
-export const generatePlaceholderHandlers = ({
-  abi,
-  events,
-  contractName,
-}: {
-  abi: ABI;
-  events: any[];
-  contractName: string;
-}) =>
-  `
-  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)
-
-      // 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)
-
-        // 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: any) => `- contract.${fn.get('name')}(...)`)
-              .join('\n// ')
-      }
-    }
-    `
-        : `
-export function handle${event._alias}(event: ${event._alias}): void {}
-`,
-    )
-    .join('\n')}`;

package/src/protocols/ethereum/subgraph.ts

@@ -1,189 +0,0 @@
-import immutable from 'immutable';
-import * as DataSourcesExtractor from '../../command-helpers/data-sources';
-import { Subgraph, SubgraphOptions } from '../subgraph';
-import ABI from './abi';
-
-export default class EthereumSubgraph implements Subgraph {
-  public manifest: SubgraphOptions['manifest'];
-  public resolveFile: SubgraphOptions['resolveFile'];
-  public protocol: SubgraphOptions['protocol'];
-
-  constructor(options: SubgraphOptions) {
-    this.manifest = options.manifest;
-    this.resolveFile = options.resolveFile;
-    this.protocol = options.protocol;
-  }
-
-  validateManifest() {
-    return this.validateAbis().concat(this.validateEvents()).concat(this.validateCallFunctions());
-  }
-
-  validateAbis() {
-    const dataSourcesAndTemplates = DataSourcesExtractor.fromManifest(this.manifest, this.protocol);
-
-    return dataSourcesAndTemplates.reduce(
-      (errors: any[], dataSourceOrTemplate: any) =>
-        errors.concat(
-          this.validateDataSourceAbis(
-            dataSourceOrTemplate.get('dataSource'),
-            dataSourceOrTemplate.get('path'),
-          ),
-        ),
-      immutable.List(),
-    );
-  }
-
-  validateDataSourceAbis(dataSource: any, path: string) {
-    // Validate that the the "source > abi" reference of all data sources
-    // points to an existing ABI in the data source ABIs
-    const abiName = dataSource.getIn(['source', 'abi']);
-    const abiNames = dataSource.getIn(['mapping', 'abis']).map((abi: any) => abi.get('name'));
-    const 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: string) => `- ${name}`)
-  .join('\n')}`,
-          },
-        ]);
-
-    // Validate that all ABI files are valid
-    const fileErrors = dataSource
-      .getIn(['mapping', 'abis'])
-      .reduce((errors: any[], abi: any, abiIndex: number) => {
-        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);
-  }
-
-  validateEvents() {
-    const dataSourcesAndTemplates = DataSourcesExtractor.fromManifest(this.manifest, this.protocol);
-
-    return dataSourcesAndTemplates.reduce((errors: any[], dataSourceOrTemplate: any) => {
-      return errors.concat(
-        this.validateDataSourceEvents(
-          dataSourceOrTemplate.get('dataSource'),
-          dataSourceOrTemplate.get('path'),
-        ),
-      );
-    }, immutable.List());
-  }
-
-  validateDataSourceEvents(dataSource: any, path: string) {
-    let abi: ABI;
-    try {
-      // Resolve the source ABI name into a real ABI object
-      const abiName = dataSource.getIn(['source', 'abi']);
-      const abiEntry = dataSource
-        .getIn(['mapping', 'abis'])
-        .find((abi: any) => 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
-    const manifestEvents = dataSource
-      .getIn(['mapping', 'eventHandlers'], immutable.List())
-      .map((handler: any) => handler.get('event'));
-
-    // Obtain event signatures from the ABI
-    const abiEvents = abi.eventSignatures();
-
-    // Add errors for every manifest event signature that is not
-    // present in the ABI
-    return manifestEvents.reduce(
-      (errors: any[], manifestEvent: any, index: number) =>
-        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: any) => this.protocol.isValidKindName(dataSource.get('kind')))
-      .reduce((errors: any[], dataSource: any, dataSourceIndex: string) => {
-        const path = ['dataSources', dataSourceIndex, 'callHandlers'];
-
-        let abi: ABI;
-        try {
-          // Resolve the source ABI name into a real ABI object
-          const abiName = dataSource.getIn(['source', 'abi']);
-          const abiEntry = dataSource
-            .getIn(['mapping', 'abis'])
-            .find((abi: any) => 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
-        const manifestFunctions = dataSource
-          .getIn(['mapping', 'callHandlers'], immutable.List())
-          .map((handler: any) => handler.get('function'));
-
-        // Obtain event signatures from the ABI
-        const abiFunctions = abi.callFunctionSignatures();
-
-        // Add errors for every manifest event signature that is not
-        // present in the ABI
-        return manifestFunctions.reduce(
-          (errors: any[], manifestFunction: any, index: number) =>
-            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']);
-  }
-}

package/src/protocols/ethereum/type-generator.ts

@@ -1,191 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import immutable from 'immutable';
-import prettier from 'prettier';
-import { GENERATED_FILE_NOTE } from '../../codegen/typescript';
-import { displayPath } from '../../command-helpers/fs';
-import { Spinner, step, withSpinner } from '../../command-helpers/spinner';
-import { TypeGeneratorOptions } from '../../type-generator';
-import ABI from './abi';
-
-export default class EthereumTypeGenerator {
-  private sourceDir: TypeGeneratorOptions['sourceDir'];
-  private outputDir: TypeGeneratorOptions['outputDir'];
-
-  constructor(options: TypeGeneratorOptions) {
-    this.sourceDir = options.sourceDir;
-    this.outputDir = options.outputDir;
-  }
-
-  async loadABIs(subgraph: immutable.Map<any, any>) {
-    return await withSpinner(
-      'Load contract ABIs',
-      'Failed to load contract ABIs',
-      `Warnings while loading contract ABIs`,
-      async spinner => {
-        try {
-          return subgraph
-            .get('dataSources')
-            .reduce(
-              (abis: any[], dataSource: any) =>
-                dataSource
-                  .getIn(['mapping', 'abis'])
-                  .reduce(
-                    (abis: any[], abi: any) =>
-                      abis.push(
-                        this._loadABI(dataSource, abi.get('name'), abi.get('file'), spinner),
-                      ),
-                    abis,
-                  ),
-              immutable.List(),
-            );
-        } catch (e) {
-          throw Error(`Failed to load contract ABIs: ${e.message}`);
-        }
-      },
-    );
-  }
-
-  _loadABI(dataSource: any, name: string, maybeRelativePath: string, spinner: Spinner) {
-    try {
-      if (this.sourceDir) {
-        const absolutePath = path.resolve(this.sourceDir, maybeRelativePath);
-        step(spinner, `Load contract ABI from`, displayPath(absolutePath));
-        return { dataSource, abi: ABI.load(name, absolutePath) };
-      }
-      return { dataSource, abi: ABI.load(name, maybeRelativePath) };
-    } catch (e) {
-      throw Error(`Failed to load contract ABI: ${e.message}`);
-    }
-  }
-
-  async loadDataSourceTemplateABIs(subgraph: immutable.Map<any, any>) {
-    return await withSpinner(
-      `Load data source template ABIs`,
-      `Failed to load data source template ABIs`,
-      `Warnings while loading data source template ABIs`,
-      async spinner => {
-        const abis = [];
-        for (const template of subgraph.get('templates', immutable.List())) {
-          for (const abi of template.getIn(['mapping', 'abis'])) {
-            abis.push(
-              this._loadDataSourceTemplateABI(template, abi.get('name'), abi.get('file'), spinner),
-            );
-          }
-        }
-        return abis;
-      },
-    );
-  }
-
-  _loadDataSourceTemplateABI(
-    template: any,
-    name: string,
-    maybeRelativePath: string,
-    spinner: Spinner,
-  ) {
-    try {
-      if (this.sourceDir) {
-        const absolutePath = path.resolve(this.sourceDir, maybeRelativePath);
-        step(spinner, `Load data source template ABI from`, displayPath(absolutePath));
-        return { template, abi: ABI.load(name, absolutePath) };
-      }
-      return { template, abi: ABI.load(name, maybeRelativePath) };
-    } catch (e) {
-      throw Error(`Failed to load data source template ABI: ${e.message}`);
-    }
-  }
-
-  generateTypesForABIs(abis: any[]) {
-    return withSpinner(
-      `Generate types for contract ABIs`,
-      `Failed to generate types for contract ABIs`,
-      `Warnings while generating types for contract ABIs`,
-      async spinner => {
-        return await Promise.all(
-          abis.map(async abi => await this._generateTypesForABI(abi, spinner)),
-        );
-      },
-    );
-  }
-
-  async _generateTypesForABI(abi: any, spinner: Spinner) {
-    try {
-      step(
-        spinner,
-        `Generate types for contract ABI:`,
-        `${abi.abi.name} (${displayPath(abi.abi.file)})`,
-      );
-
-      const codeGenerator = abi.abi.codeGenerator();
-      const code = prettier.format(
-        [
-          GENERATED_FILE_NOTE,
-          ...codeGenerator.generateModuleImports(),
-          ...codeGenerator.generateTypes(),
-        ].join('\n'),
-        {
-          parser: 'typescript',
-        },
-      );
-
-      const outputFile = path.join(
-        this.outputDir,
-        abi.dataSource.get('name'),
-        `${abi.abi.name}.ts`,
-      );
-      step(spinner, `Write types to`, displayPath(outputFile));
-      await fs.mkdirs(path.dirname(outputFile));
-      await fs.writeFile(outputFile, code);
-    } catch (e) {
-      throw Error(`Failed to generate types for contract ABI: ${e.message}`);
-    }
-  }
-
-  async generateTypesForDataSourceTemplateABIs(abis: any[]) {
-    return await withSpinner(
-      `Generate types for data source template ABIs`,
-      `Failed to generate types for data source template ABIs`,
-      `Warnings while generating types for data source template ABIs`,
-      async spinner => {
-        return await Promise.all(
-          abis.map(async abi => await this._generateTypesForDataSourceTemplateABI(abi, spinner)),
-        );
-      },
-    );
-  }
-
-  async _generateTypesForDataSourceTemplateABI(abi: any, spinner: Spinner) {
-    try {
-      step(
-        spinner,
-        `Generate types for data source template ABI:`,
-        `${abi.template.get('name')} > ${abi.abi.name} (${displayPath(abi.abi.file)})`,
-      );
-
-      const codeGenerator = abi.abi.codeGenerator();
-      const code = prettier.format(
-        [
-          GENERATED_FILE_NOTE,
-          ...codeGenerator.generateModuleImports(),
-          ...codeGenerator.generateTypes(),
-        ].join('\n'),
-        {
-          parser: 'typescript',
-        },
-      );
-
-      const outputFile = path.join(
-        this.outputDir,
-        'templates',
-        abi.template.get('name'),
-        `${abi.abi.name}.ts`,
-      );
-      step(spinner, `Write types to`, displayPath(outputFile));
-      await fs.mkdirs(path.dirname(outputFile));
-      await fs.writeFile(outputFile, code);
-    } catch (e) {
-      throw Error(`Failed to generate types for data source template ABI: ${e.message}`);
-    }
-  }
-}