@graphprotocol/graph-cli 0.37.3 → 0.37.4-alpha-20230117095424-b5750b1

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/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/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}`);
-    }
-  }
-}