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

package/src/protocols/ethereum/abi.ts

@@ -1,153 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import immutable from 'immutable';
-import AbiCodeGenerator from './codegen/abi';
-
-const TUPLE_ARRAY_PATTERN = /^tuple\[([0-9]*)\]$/;
-const TUPLE_MATRIX_PATTERN = /^tuple\[([0-9]*)\]\[([0-9]*)\]$/;
-
-const buildOldSignatureParameter = (input: immutable.Map<any, any>) => {
-  return input.get('type') === 'tuple'
-    ? `(${input
-        .get('components')
-        .map((component: any) => buildSignatureParameter(component))
-        .join(',')})`
-    : String(input.get('type'));
-};
-
-const buildSignatureParameter = (input: immutable.Map<any, any>) => {
-  if (input.get('type') === 'tuple') {
-    return `(${input.get('indexed') ? 'indexed ' : ''}${input
-      .get('components')
-      .map((component: any) => buildSignatureParameter(component))
-      .join(',')})`;
-  }
-  if (input.get('type').match(TUPLE_ARRAY_PATTERN)) {
-    const length = input.get('type').match(TUPLE_ARRAY_PATTERN)[1];
-    return `(${input.get('indexed') ? 'indexed ' : ''}${input
-      .get('components')
-      .map((component: any) => buildSignatureParameter(component))
-      .join(',')})[${length ? length : ''}]`;
-  }
-  if (input.get('type').match(TUPLE_MATRIX_PATTERN)) {
-    const length1 = input.get('type').match(TUPLE_MATRIX_PATTERN)[1];
-    const length2 = input.get('type').match(TUPLE_MATRIX_PATTERN)[2];
-    return `(${input.get('indexed') ? 'indexed ' : ''}${input
-      .get('components')
-      .map((component: any) => buildSignatureParameter(component))
-      .join(',')})[${length1 ? length1 : ''}][${length2 ? length2 : ''}]`;
-  }
-  return `${input.get('indexed') ? 'indexed ' : ''}${input.get('type')}`;
-};
-
-export default class ABI {
-  constructor(
-    public name: string,
-    public file: string | undefined,
-    public data: immutable.Collection<any, any>,
-  ) {
-    this.name = name;
-    this.file = file;
-    this.data = data;
-  }
-
-  codeGenerator() {
-    return new AbiCodeGenerator(this);
-  }
-
-  static oldEventSignature(event: immutable.Map<any, any>) {
-    return `${event.get('name')}(${event
-      .get('inputs', [])
-      .map(buildOldSignatureParameter)
-      .join(',')})`;
-  }
-
-  static eventSignature(event: immutable.Map<any, any>) {
-    return `${event.get('name')}(${event
-      .get('inputs', [])
-      .map(buildSignatureParameter)
-      .join(',')})`;
-  }
-
-  /**
-   * For the ABI of a function, returns a string function signature compatible
-   * with the Rust `ethabi` library. It is of the form
-   *
-   *     <function>([<input-type-1>, ...])[:(<output-type-1,...)]
-   *
-   * A few examples for a function called `example`:
-   *
-   * - No inputs or outputs: `example()`
-   * - One input and output: `example(uint256):(bool)`
-   * - Multiple inputs and outputs: `example(uint256,(string,bytes32)):(bool,uint256)`
-   */
-  functionSignature(fn: immutable.Map<any, any>) {
-    const inputs = fn.get('inputs', []).map(buildSignatureParameter).join(',');
-    const outputs = fn.get('outputs', []).map(buildSignatureParameter).join(',');
-    return `${fn.get('name')}(${inputs})${outputs.length > 0 ? `:(${outputs})` : ''}`;
-  }
-
-  oldEventSignatures() {
-    return this.data
-      .filter((entry: any) => entry.get('type') === 'event')
-      .map(ABI.oldEventSignature);
-  }
-
-  eventSignatures() {
-    return this.data.filter((entry: any) => entry.get('type') === 'event').map(ABI.eventSignature);
-  }
-
-  callFunctions() {
-    // An entry is a function if its type is not set or if it is one of
-    // 'constructor', 'function' or 'fallback'
-    const functionTypes = immutable.Set(['constructor', 'function', 'fallback']);
-    const functions = this.data.filter(
-      (entry: any) => !entry.has('type') || functionTypes.includes(entry.get('type')),
-    );
-
-    // A function is a call function if it is nonpayable, payable or
-    // not constant
-    const mutabilityTypes = immutable.Set(['nonpayable', 'payable']);
-    return functions.filter(
-      (entry: any) =>
-        mutabilityTypes.includes(entry.get('stateMutability')) || entry.get('constant') === false,
-    );
-  }
-
-  callFunctionSignatures() {
-    return this.callFunctions()
-      .filter((entry: any) => entry.get('type') !== 'constructor')
-      .map((entry: any) => {
-        const name = entry.get('name', '<default>');
-        const inputs = entry
-          .get('inputs', immutable.List())
-          .map((input: any) => buildSignatureParameter(input));
-
-        return `${name}(${inputs.join(',')})`;
-      });
-  }
-
-  static normalized(json: any) {
-    if (Array.isArray(json)) {
-      return json;
-    }
-    if (json.abi !== undefined) {
-      return json.abi;
-    }
-    if (json.compilerOutput?.abi) {
-      return json.compilerOutput.abi;
-    }
-    return undefined;
-  }
-
-  static load(name: string, file: string) {
-    const data = JSON.parse(fs.readFileSync(file).toString());
-    const abi = ABI.normalized(data);
-
-    if (abi === null || abi === undefined) {
-      throw Error(`No valid ABI in file: ${path.relative(process.cwd(), file)}`);
-    }
-
-    return new ABI(name, file, immutable.fromJS(abi));
-  }
-}

package/src/protocols/ethereum/codegen/abi.test.ts

@@ -1,330 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import immutable from 'immutable';
-import * as ts from '../../../codegen/typescript';
-import ABI from '../abi';
-import AbiCodeGenerator from './abi';
-
-let tempdir: string;
-let abi: ABI;
-let generatedTypes: any[];
-
-describe('ABI code generation', () => {
-  beforeAll(async () => {
-    tempdir = await fs.mkdtemp('abi-codegen');
-
-    try {
-      const filename = path.join(tempdir, 'ABI.json');
-      await fs.writeFile(
-        filename,
-        JSON.stringify([
-          {
-            constant: true,
-            inputs: [],
-            name: 'read',
-            outputs: [{ name: '', type: 'bytes32' }],
-            payable: false,
-            type: 'function',
-          },
-          {
-            constant: true,
-            inputs: [
-              {
-                name: 'proposalId',
-                type: 'uint256',
-              },
-              {
-                components: [
-                  {
-                    name: 'foo',
-                    type: 'uint8',
-                  },
-                  {
-                    name: 'bar',
-                    type: 'tuple',
-                    components: [{ name: 'baz', type: 'address' }],
-                  },
-                ],
-                name: '',
-                type: 'tuple',
-              },
-            ],
-            name: 'getProposal',
-            outputs: [
-              {
-                components: [
-                  {
-                    name: 'result',
-                    type: 'uint8',
-                  },
-                  {
-                    name: 'target',
-                    type: 'address',
-                  },
-                  {
-                    name: 'data',
-                    type: 'bytes',
-                  },
-                  {
-                    name: 'proposer',
-                    type: 'address',
-                  },
-                  {
-                    name: 'feeRecipient',
-                    type: 'address',
-                  },
-                  {
-                    name: 'fee',
-                    type: 'uint256',
-                  },
-                  {
-                    name: 'startTime',
-                    type: 'uint256',
-                  },
-                  {
-                    name: 'yesCount',
-                    type: 'uint256',
-                  },
-                  {
-                    name: 'noCount',
-                    type: 'uint256',
-                  },
-                ],
-                name: '',
-                type: 'tuple',
-              },
-            ],
-            payable: false,
-            stateMutability: 'view',
-            type: 'function',
-          },
-          {
-            type: 'function',
-            stateMutability: 'view',
-            payable: 'false',
-            name: 'getProposals',
-            outputs: [
-              {
-                type: 'uint256',
-                name: 'size',
-              },
-              {
-                type: 'tuple[]',
-                components: [
-                  { name: 'first', type: 'uint256' },
-                  { name: 'second', type: 'string' },
-                ],
-              },
-            ],
-          },
-          {
-            type: 'function',
-            stateMutability: 'view',
-            name: 'overloaded',
-            inputs: [
-              {
-                type: 'string',
-              },
-            ],
-            outputs: [
-              {
-                type: 'string',
-              },
-            ],
-          },
-          {
-            type: 'function',
-            stateMutability: 'view',
-            name: 'overloaded',
-            inputs: [
-              {
-                type: 'uint256',
-              },
-            ],
-            outputs: [
-              {
-                type: 'string',
-              },
-            ],
-          },
-          {
-            type: 'function',
-            stateMutability: 'view',
-            name: 'overloaded',
-            inputs: [
-              {
-                type: 'bytes32',
-              },
-            ],
-            outputs: [
-              {
-                type: 'string',
-              },
-            ],
-          },
-        ]),
-        'utf-8',
-      );
-      abi = ABI.load('Contract', filename);
-      const codegen = new AbiCodeGenerator(abi);
-      generatedTypes = codegen.generateTypes();
-    } finally {
-      await fs.remove(tempdir);
-    }
-  });
-
-  afterAll(async () => {
-    await fs.remove(tempdir);
-  });
-
-  describe('Generated types', () => {
-    test('All expected types are generated', () => {
-      expect(generatedTypes.map(type => type.name)).toEqual([
-        'Contract__getProposalResultValue0Struct',
-        'Contract__getProposalInputParam1Struct',
-        'Contract__getProposalInputParam1BarStruct',
-        'Contract__getProposalsResultValue1Struct',
-        'Contract__getProposalsResult',
-        'Contract',
-      ]);
-    });
-  });
-
-  describe('Contract class', () => {
-    test('Exists', () => {
-      expect(generatedTypes.find(type => type.name === 'Contract')).toBeDefined();
-    });
-
-    test('Has methods', () => {
-      const contract = generatedTypes.find(type => type.name === 'Contract');
-      expect(contract.methods).toBeInstanceOf(Array);
-    });
-
-    test('Has `bind` method', () => {
-      const contract = generatedTypes.find(type => type.name === 'Contract');
-      expect(contract.methods.find((method: any) => method.name === 'bind')).toBeDefined();
-    });
-
-    test('Has methods for all callable functions', () => {
-      const contract = generatedTypes.find(type => type.name === 'Contract');
-      expect(contract.methods.map((method: any) => method.name)).toContain('getProposal');
-    });
-  });
-
-  describe('Methods for callable functions', () => {
-    test('Have correct parameters', () => {
-      const contract = generatedTypes.find(type => type.name === 'Contract');
-      expect(contract.methods.map((method: any) => [method.name, method.params])).toEqual([
-        ['bind', immutable.List([ts.param('address', 'Address')])],
-        ['read', immutable.List()],
-        ['try_read', immutable.List()],
-        [
-          'getProposal',
-          immutable.List([
-            ts.param('proposalId', 'BigInt'),
-            ts.param('param1', 'Contract__getProposalInputParam1Struct'),
-          ]),
-        ],
-        [
-          'try_getProposal',
-          immutable.List([
-            ts.param('proposalId', 'BigInt'),
-            ts.param('param1', 'Contract__getProposalInputParam1Struct'),
-          ]),
-        ],
-        ['getProposals', immutable.List()],
-        ['try_getProposals', immutable.List()],
-        ['overloaded', immutable.List([ts.param('param0', 'string')])],
-        ['try_overloaded', immutable.List([ts.param('param0', 'string')])],
-        ['overloaded1', immutable.List([ts.param('param0', 'BigInt')])],
-        ['try_overloaded1', immutable.List([ts.param('param0', 'BigInt')])],
-        ['overloaded2', immutable.List([ts.param('param0', 'Bytes')])],
-        ['try_overloaded2', immutable.List([ts.param('param0', 'Bytes')])],
-      ]);
-    });
-
-    test('Have correct return types', () => {
-      const contract = generatedTypes.find(type => type.name === 'Contract');
-      expect(contract.methods.map((method: any) => [method.name, method.returnType])).toEqual([
-        ['bind', ts.namedType('Contract')],
-        ['read', ts.namedType('Bytes')],
-        ['try_read', 'ethereum.CallResult<Bytes>'],
-        ['getProposal', ts.namedType('Contract__getProposalResultValue0Struct')],
-        ['try_getProposal', 'ethereum.CallResult<Contract__getProposalResultValue0Struct>'],
-        ['getProposals', ts.namedType('Contract__getProposalsResult')],
-        ['try_getProposals', 'ethereum.CallResult<Contract__getProposalsResult>'],
-        ['overloaded', ts.namedType('string')],
-        ['try_overloaded', 'ethereum.CallResult<string>'],
-        ['overloaded1', ts.namedType('string')],
-        ['try_overloaded1', 'ethereum.CallResult<string>'],
-        ['overloaded2', ts.namedType('string')],
-        ['try_overloaded2', 'ethereum.CallResult<string>'],
-      ]);
-    });
-  });
-
-  describe('Tuples', () => {
-    test('Tuple types exist for function parameters', () => {
-      let tupleType = generatedTypes.find(
-        type => type.name === 'Contract__getProposalInputParam1Struct',
-      );
-
-      // Verify that the tuple type has methods
-      expect(tupleType.methods).toBeDefined();
-
-      // Verify that the tuple type has getters for all tuple fields with
-      // the right return types
-      expect(tupleType.methods.map((method: any) => [method.name, method.returnType])).toEqual([
-        ['get foo', 'i32'],
-        ['get bar', 'Contract__getProposalInputParam1BarStruct'],
-      ]);
-
-      // Inner tuple:
-      tupleType = generatedTypes.find(
-        type => type.name === 'Contract__getProposalInputParam1BarStruct',
-      );
-
-      // Verify that the tuple type has methods
-      expect(tupleType.methods).toBeDefined();
-
-      // Verify that the tuple type has getters for all tuple fields with
-      // the right return types
-      expect(tupleType.methods.map((method: any) => [method.name, method.returnType])).toEqual([
-        ['get baz', 'Address'],
-      ]);
-    });
-
-    test('Tuple types exist for function return values', () => {
-      const tupleType = generatedTypes.find(
-        type => type.name === 'Contract__getProposalResultValue0Struct',
-      );
-
-      // Verify that the tuple type has methods
-      expect(tupleType.methods).toBeDefined();
-
-      // Verify that the tuple type has getters for all tuple fields with
-      // the right return types
-      expect(tupleType.methods.map((method: any) => [method.name, method.returnType])).toEqual([
-        ['get result', 'i32'],
-        ['get target', 'Address'],
-        ['get data', 'Bytes'],
-        ['get proposer', 'Address'],
-        ['get feeRecipient', 'Address'],
-        ['get fee', 'BigInt'],
-        ['get startTime', 'BigInt'],
-        ['get yesCount', 'BigInt'],
-        ['get noCount', 'BigInt'],
-      ]);
-    });
-
-    test('Function bodies are generated correctly for tuple arrays', () => {
-      const contract = generatedTypes.find(type => type.name === 'Contract');
-      const getter = contract.methods.find((method: any) => method.name === 'getProposals');
-
-      expect(getter.body).not.toContain('toTupleArray<undefined>');
-      expect(getter.body).toContain(
-        'result[1].toTupleArray<Contract__getProposalsResultValue1Struct>()',
-      );
-    });
-  });
-});