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

package/src/codegen/types/index.ts

@@ -1,111 +0,0 @@
-import immutable from 'immutable';
-import TYPE_CONVERSIONS from './conversions';
-
-// Conversion utilities
-
-const conversionsForTypeSystems = (fromTypeSystem: string, toTypeSystem: string) => {
-  const conversions = TYPE_CONVERSIONS.getIn([fromTypeSystem, toTypeSystem]);
-  if (conversions === undefined) {
-    throw new Error(`Conversions from '${fromTypeSystem}' to '${toTypeSystem}' are not supported`);
-  }
-  return conversions as immutable.Collection<any, any>;
-};
-
-const objectifyConversion = (
-  fromTypeSystem: string,
-  toTypeSystem: string,
-  conversion: immutable.Collection<any, any>,
-) => {
-  return immutable.fromJS({
-    from: {
-      typeSystem: fromTypeSystem,
-      type: conversion.get(0),
-    },
-    to: {
-      typeSystem: toTypeSystem,
-      type: conversion.get(1),
-    },
-    convert: conversion.get(2),
-  });
-};
-
-const findConversionFromType = (
-  fromTypeSystem: string,
-  toTypeSystem: string,
-  fromType: string,
-): immutable.Collection<any, any> => {
-  const conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem);
-
-  const conversion = conversions.find(conversion =>
-    typeof conversion.get(0) === 'string'
-      ? conversion.get(0) === fromType
-      : !!fromType.match(conversion.get(0)),
-  );
-
-  if (conversion === undefined) {
-    throw new Error(
-      `Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
-        `source type '${fromType}' is not supported`,
-    );
-  }
-
-  return objectifyConversion(fromTypeSystem, toTypeSystem, conversion);
-};
-
-const findConversionToType = (
-  fromTypeSystem: string,
-  toTypeSystem: string,
-  toType: string,
-): immutable.Collection<any, any> => {
-  const conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem);
-
-  const conversion = conversions.find(conversion =>
-    typeof conversion.get(1) === 'string'
-      ? conversion.get(1) === toType
-      : !!toType.match(conversion.get(1)),
-  );
-
-  if (conversion === undefined) {
-    throw new Error(
-      `Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
-        `target type '${toType}' is not supported`,
-    );
-  }
-
-  return objectifyConversion(fromTypeSystem, toTypeSystem, conversion);
-};
-
-// High-level type system API
-
-export const ascTypeForProtocol = (protocol: string, protocolType: string) =>
-  findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type']) as string;
-
-// TODO: this can be removed/replaced by the function above
-export const ascTypeForEthereum = (ethereumType: string) =>
-  ascTypeForProtocol('ethereum', ethereumType);
-
-export const ethereumTypeForAsc = (ascType: string) =>
-  findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type']) as
-    | string
-    | RegExp;
-
-export const ethereumToAsc = (code: string, ethereumType: string, internalType?: string) =>
-  findConversionFromType('ethereum', 'AssemblyScript', ethereumType).get('convert')(
-    code,
-    internalType,
-  );
-
-export const ethereumFromAsc = (code: string, ethereumType: string) =>
-  findConversionToType('AssemblyScript', 'ethereum', ethereumType).get('convert')(code);
-
-export const ascTypeForValue = (valueType: string) =>
-  findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type']);
-
-export const valueTypeForAsc = (ascType: string) =>
-  findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type']);
-
-export const valueToAsc = (code: string, valueType: string) =>
-  findConversionFromType('Value', 'AssemblyScript', valueType).get('convert')(code);
-
-export const valueFromAsc = (code: string, valueType: string) =>
-  findConversionToType('AssemblyScript', 'Value', valueType).get('convert')(code);

package/src/codegen/typescript.ts

@@ -1,224 +0,0 @@
-class Param {
-  constructor(public name: string, public type: string | NamedType | NullableType) {
-    this.name = name;
-    this.type = type;
-  }
-
-  toString() {
-    return `${this.name}: ${this.type.toString()}`;
-  }
-}
-
-class Method {
-  constructor(
-    public name: string,
-    public params: Param[],
-    public returnType: string | NamedType | null | undefined,
-    public body: string,
-  ) {
-    this.name = name;
-    this.params = params || [];
-    this.returnType = returnType;
-    this.body = body || '';
-  }
-
-  toString() {
-    return `
-  ${this.name}(${this.params.map(param => param.toString()).join(', ')})${
-      this.returnType ? `: ${this.returnType.toString()}` : ''
-    } {${this.body}
-  }
-`;
-  }
-}
-
-class StaticMethod {
-  constructor(
-    public name: string,
-    public params: Param[],
-    public returnType: NamedType | NullableType,
-    public body: string,
-  ) {
-    this.name = name;
-    this.params = params || [];
-    this.returnType = returnType || 'void';
-    this.body = body || '';
-  }
-
-  toString() {
-    return `
-  static ${this.name}(${this.params.map(param => param.toString()).join(', ')})${
-      this.returnType ? `: ${this.returnType.toString()}` : ''
-    } {${this.body}
-  }
-`;
-  }
-}
-
-interface ClassOptions {
-  extends?: string;
-  export?: boolean;
-}
-
-class Class {
-  public extends: string | undefined;
-  public methods: string[];
-  public members: any[];
-  public export: boolean;
-
-  constructor(public name: string, options: ClassOptions) {
-    this.name = name;
-    this.extends = options.extends;
-    this.methods = [];
-    this.members = [];
-    this.export = options.export || false;
-  }
-
-  addMember(member: any) {
-    this.members.push(member);
-  }
-
-  addMethod(method: any) {
-    this.methods.push(method);
-  }
-
-  toString() {
-    return `
-${this.export ? 'export' : ''} class ${this.name}${this.extends ? ` extends ${this.extends}` : ''} {
-${this.members.map(member => member.toString()).join('\n')}
-${this.methods.map(method => method.toString()).join('')}
-}
-`;
-  }
-}
-
-class ClassMember {
-  constructor(public name: string, public type: string) {
-    this.name = name;
-    this.type = type;
-  }
-
-  toString() {
-    return `  ${this.name}: ${this.type.toString()}`;
-  }
-}
-
-class NamedType {
-  constructor(public name: string) {
-    this.name = name;
-  }
-
-  toString() {
-    return this.name;
-  }
-
-  capitalize() {
-    this.name = this.name.charAt(0).toUpperCase() + this.name.slice(1);
-    return this;
-  }
-
-  isPrimitive() {
-    const primitives = [
-      'boolean',
-      'u8',
-      'i8',
-      'u16',
-      'i16',
-      'u32',
-      'i32',
-      'u64',
-      'i64',
-      'f32',
-      'f64',
-      'usize',
-      'isize',
-    ];
-    return primitives.includes(this.name);
-  }
-}
-
-class ArrayType {
-  public name: string;
-
-  constructor(public inner: NamedType) {
-    this.inner = inner;
-    this.name = `Array<${inner.toString()}>`;
-  }
-
-  toString() {
-    return this.name;
-  }
-}
-
-class NullableType {
-  constructor(public inner: NamedType | ArrayType) {
-    this.inner = inner;
-  }
-
-  toString() {
-    return `${this.inner.toString()} | null`;
-  }
-}
-
-class ModuleImports {
-  constructor(public nameOrNames: string | string[], public module: string) {
-    this.nameOrNames = nameOrNames;
-    this.module = module;
-  }
-
-  toString() {
-    return `import { ${
-      typeof this.nameOrNames === 'string' ? this.nameOrNames : this.nameOrNames.join(',')
-    } } from "${this.module}"`;
-  }
-}
-
-const namedType = (name: string) => new NamedType(name);
-const arrayType = (name: NamedType) => new ArrayType(name);
-const param = (name: string, type: string | NamedType) => new Param(name, type);
-const method = (
-  name: string,
-  params: Param[],
-  returnType: string | NamedType | null | undefined,
-  body: string,
-) => new Method(name, params, returnType, body);
-const staticMethod = (
-  name: string,
-  params: Param[],
-  returnType: NamedType | NullableType,
-  body: string,
-) => new StaticMethod(name, params, returnType, body);
-const klass = (name: string, options: ClassOptions) => new Class(name, options);
-const klassMember = (name: string, type: string) => new ClassMember(name, type);
-const nullableType = (type: NamedType | ArrayType) => new NullableType(type);
-const moduleImports = (nameOrNames: string | string[], module: string) =>
-  new ModuleImports(nameOrNames, module);
-
-const GENERATED_FILE_NOTE = `
-// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-`;
-
-export {
-  ArrayType,
-  arrayType,
-  Class,
-  ClassMember,
-  // Utilities
-  GENERATED_FILE_NOTE,
-  klass,
-  klassMember,
-  Method,
-  method,
-  ModuleImports,
-  moduleImports,
-  NamedType,
-  // Code generators
-  namedType,
-  NullableType,
-  nullableType,
-  // Types
-  Param,
-  param,
-  StaticMethod,
-  staticMethod,
-};

package/src/codegen/util.test.ts

@@ -1,112 +0,0 @@
-import { disambiguateNames, unrollTuple } from './util';
-
-describe('Codegen utilities', () => {
-  test('Name disambiguation', () => {
-    expect(
-      disambiguateNames({
-        values: ['a', 'b', 'c'],
-        getName: x => x,
-        setName: (_x, name) => name,
-      }),
-    ).toEqual(['a', 'b', 'c']);
-
-    expect(
-      disambiguateNames({
-        values: ['a', 'a', 'a'],
-        getName: x => x,
-        setName: (_x, name) => name,
-      }),
-    ).toEqual(['a', 'a1', 'a2']);
-
-    expect(
-      disambiguateNames({
-        values: [
-          { name: 'ExampleEvent', inputs: [] },
-          { name: 'ExampleEvent', inputs: [{ type: 'uint256' }] },
-          { name: 'ExampleEvent', inputs: [{ type: 'uint96' }] },
-        ],
-        getName: event => event.name,
-        setName: (event, name) => {
-          event.name = name;
-          return event;
-        },
-      }),
-    ).toEqual([
-      { name: 'ExampleEvent', inputs: [] },
-      { name: 'ExampleEvent1', inputs: [{ type: 'uint256' }] },
-      { name: 'ExampleEvent2', inputs: [{ type: 'uint96' }] },
-    ]);
-  });
-
-  test('Tuple unrolling', () => {
-    expect(
-      unrollTuple({
-        value: { type: 'tuple', name: 'value', components: [] },
-        path: ['value'],
-        index: 0,
-      }),
-    ).toEqual([]);
-
-    expect(
-      unrollTuple({
-        value: {
-          type: 'tuple',
-          name: 'value',
-          components: [{ name: 'a', type: 'string' }],
-        },
-        path: ['value'],
-        index: 0,
-      }),
-    ).toEqual([{ path: ['value', 'a'], type: 'string' }]);
-
-    expect(
-      unrollTuple({
-        value: {
-          type: 'tuple',
-          name: 'value',
-          components: [
-            { name: 'a', type: 'string' },
-            { name: 'b', type: 'uint256' },
-          ],
-        },
-        path: ['value'],
-        index: 0,
-      }),
-    ).toEqual([
-      { path: ['value', 'a'], type: 'string' },
-      { path: ['value', 'b'], type: 'uint256' },
-    ]);
-
-    expect(
-      unrollTuple({
-        value: {
-          type: 'tuple',
-          name: 'value',
-          components: [
-            { name: 'a', type: 'string' },
-            { name: 'b', type: 'uint256' },
-            {
-              name: 'c',
-              type: 'tuple',
-              components: [
-                { type: 'bytes32' },
-                {
-                  name: 'd',
-                  type: 'tuple',
-                  components: [{ name: 'd1', type: 'uint72' }],
-                },
-              ],
-            },
-          ],
-        },
-        path: ['value'],
-        index: 1,
-      }),
-    ).toEqual([
-      { path: ['value', 'a'], type: 'string' },
-      { path: ['value', 'b'], type: 'uint256' },
-      { path: ['value', 'c', 'value0'], type: 'bytes32' },
-      { path: ['value', 'c', 'd', 'd1'], type: 'uint72' },
-    ]);
-  });
-});

package/src/codegen/util.ts

@@ -1,54 +0,0 @@
-export function disambiguateNames<T>({
-  values,
-  getName,
-  setName,
-}: {
-  values: T[];
-  getName: (value: T, index: number) => string;
-  setName: (value: T, name: string) => void;
-}) {
-  const collisionCounter = new Map();
-  return values.map((value, index) => {
-    const name = getName(value, index);
-    const counter = collisionCounter.get(name);
-    if (counter === undefined) {
-      collisionCounter.set(name, 1);
-      return setName(value, name);
-    }
-    collisionCounter.set(name, counter + 1);
-    return setName(value, `${name}${counter}`);
-  });
-}
-
-export function isTupleType(t: string) {
-  return t === 'tuple';
-}
-
-export function containsTupleType(t: string) {
-  return isTupleType(t) || isTupleArrayType(t) || isTupleMatrixType(t);
-}
-
-export function isTupleArrayType(t: string) {
-  return t.match(/^tuple\[([0-9]+)?\]$/);
-}
-
-export function isTupleMatrixType(t: string) {
-  return t.match(/^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/);
-}
-
-export const unrollTuple = ({
-  path,
-  value,
-}: {
-  path: string[];
-  index: number; // TODO: index is unused, do we really need it?
-  value: any;
-}) =>
-  value.components.reduce((acc: any[], component: any, index: number) => {
-    const name = component.name || `value${index}`;
-    return acc.concat(
-      component.type === 'tuple'
-        ? unrollTuple({ path: [...path, name], index, value: component })
-        : [{ path: [...path, name], type: component.type }],
-    );
-  }, []);

package/src/command-helpers/abi.ts

@@ -1,99 +0,0 @@
-import immutable from 'immutable';
-import fetch from 'node-fetch';
-import ABI from '../protocols/ethereum/abi';
-import { withSpinner } from './spinner';
-
-export const loadAbiFromEtherscan = async (
-  ABICtor: typeof ABI,
-  network: string,
-  address: string,
-): Promise<ABI> =>
-  await withSpinner(
-    `Fetching ABI from Etherscan`,
-    `Failed to fetch ABI from Etherscan`,
-    `Warnings while fetching ABI from Etherscan`,
-    async () => {
-      const scanApiUrl = getEtherscanLikeAPIUrl(network);
-      const result = await fetch(`${scanApiUrl}?module=contract&action=getabi&address=${address}`);
-      const 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 ABICtor('Contract', undefined, immutable.fromJS(JSON.parse(json.result)));
-      }
-      throw new Error('ABI not found, try loading it from a local file');
-    },
-  );
-
-export const loadAbiFromBlockScout = async (
-  ABICtor: typeof ABI,
-  network: string,
-  address: string,
-) =>
-  await withSpinner(
-    `Fetching ABI from BlockScout`,
-    `Failed to fetch ABI from BlockScout`,
-    `Warnings while fetching ABI from BlockScout`,
-    async () => {
-      const result = await fetch(
-        `https://blockscout.com/${network.replace(
-          '-',
-          '/',
-        )}/api?module=contract&action=getabi&address=${address}`,
-      );
-      const 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 ABICtor('Contract', undefined, immutable.fromJS(JSON.parse(json.result)));
-      }
-      throw new Error('ABI not found, try loading it from a local file');
-    },
-  );
-
-const getEtherscanLikeAPIUrl = (network: string) => {
-  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 'chapel':
-      return `https://api-testnet.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 'optimism':
-      return `https://api-optimistic.etherscan.io/api`;
-    case 'moonbeam':
-      return `https://api-moonbeam.moonscan.io/api`;
-    case 'moonriver':
-      return `https://api-moonriver.moonscan.io/api`;
-    case 'mbase':
-      return `https://api-moonbase.moonscan.io/api`;
-    case 'avalanche':
-      return `https://api.snowtrace.io/api`;
-    case 'fuji':
-      return `https://api-testnet.snowtrace.io/api`;
-    case 'gnosis':
-      return `https://api.gnosisscan.io/api`;
-    case 'fantom':
-      return `https://api.ftmscan.com/api`;
-    case 'fantom-testnet':
-      return `https://api-testnet.ftmscan.com/api`;
-    default:
-      return `https://api-${network}.etherscan.io/api`;
-  }
-};

package/src/command-helpers/auth.ts

@@ -1,46 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import * as toolbox from 'gluegun';
-import { normalizeNodeUrl } from './node';
-
-const homedir = os.homedir();
-
-const CONFIG_PATH = path.join(homedir, '/.graph-cli.json');
-const getConfig = () => {
-  let config;
-  try {
-    config = JSON.parse(fs.readFileSync(CONFIG_PATH).toString());
-  } catch {
-    config = {};
-  }
-  return config;
-};
-
-export const identifyDeployKey = async (node: string, deployKey: string) => {
-  // Determine the deploy key to use, if any:
-  // - First try using --deploy-key, if provided
-  // - Then see if we have a deploy key set for the Graph node
-  if (deployKey !== undefined) {
-    return deployKey;
-  }
-  try {
-    node = normalizeNodeUrl(node);
-    const config = getConfig();
-    return config[node];
-  } catch (e) {
-    toolbox.print.warning(`Could not get deploy key: ${e.message}`);
-    toolbox.print.info(`Continuing without a deploy key\n`);
-  }
-};
-
-export const saveDeployKey = async (node: string, deployKey: string) => {
-  try {
-    node = normalizeNodeUrl(node);
-    const config = getConfig();
-    config[node] = deployKey;
-    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config));
-  } catch (e) {
-    throw new Error(`Error storing deploy key: ${e.message}`);
-  }
-};

package/src/command-helpers/compiler.ts

@@ -1,60 +0,0 @@
-import { URL } from 'url';
-import * as toolbox from 'gluegun';
-import ipfsHttpClient from 'ipfs-http-client';
-import Compiler from '../compiler';
-import Protocol from '../protocols';
-
-interface CreateCompilerOptions {
-  ipfs: any;
-  headers?: any;
-  outputDir: string;
-  outputFormat: string;
-  skipMigrations: boolean;
-  blockIpfsMethods?: boolean;
-  protocol: Protocol;
-}
-
-// Helper function to construct a subgraph compiler
-export function createCompiler(
-  manifest: string,
-  {
-    ipfs,
-    headers,
-    outputDir,
-    outputFormat,
-    skipMigrations,
-    blockIpfsMethods,
-    protocol,
-  }: CreateCompilerOptions,
-) {
-  // Parse the IPFS URL
-  let url;
-  try {
-    url = ipfs ? new URL(ipfs) : undefined;
-  } catch (e) {
-    toolbox.print.error(`Invalid IPFS URL: ${ipfs}
-The IPFS URL must be of the following format: http(s)://host[:port]/[path]`);
-    return null;
-  }
-
-  // Connect to the IPFS node (if a node address was provided)
-  ipfs = ipfs
-    ? ipfsHttpClient({
-        protocol: url?.protocol.replace(/[:]+$/, ''),
-        host: url?.hostname,
-        port: url?.port,
-        'api-path': url?.pathname.replace(/\/$/, '') + '/api/v0/',
-        headers,
-      })
-    : undefined;
-
-  return new Compiler({
-    ipfs,
-    subgraphManifest: manifest,
-    outputDir,
-    outputFormat,
-    skipMigrations,
-    blockIpfsMethods,
-    protocol,
-  });
-}