@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/dist/protocols/ethereum/codegen/abi.test.js

@@ -0,0 +1,328 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const immutable_1 = __importDefault(require("immutable"));
+const abi_1 = __importDefault(require("../abi"));
+const ts = __importStar(require("../../../codegen/typescript"));
+const abi_2 = __importDefault(require("./abi"));
+let tempdir;
+let abi;
+let generatedTypes;
+describe('ABI code generation', () => {
+    beforeAll(async () => {
+        tempdir = await fs_extra_1.default.mkdtemp('abi-codegen');
+        try {
+            let filename = path_1.default.join(tempdir, 'ABI.json');
+            await fs_extra_1.default.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_1.default.load('Contract', filename);
+            let codegen = new abi_2.default(abi);
+            generatedTypes = codegen.generateTypes();
+        }
+        finally {
+            await fs_extra_1.default.remove(tempdir);
+        }
+    });
+    afterAll(async () => {
+        await fs_extra_1.default.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', () => {
+            let contract = generatedTypes.find(type => type.name === 'Contract');
+            expect(contract.methods).toBeInstanceOf(Array);
+        });
+        test('Has `bind` method', () => {
+            let contract = generatedTypes.find(type => type.name === 'Contract');
+            expect(contract.methods.find(method => method.name === 'bind')).toBeDefined();
+        });
+        test('Has methods for all callable functions', () => {
+            let contract = generatedTypes.find(type => type.name === 'Contract');
+            expect(contract.methods.map(method => method.name)).toContain('getProposal');
+        });
+    });
+    describe('Methods for callable functions', () => {
+        test('Have correct parameters', () => {
+            let contract = generatedTypes.find(type => type.name === 'Contract');
+            expect(contract.methods.map(method => [method.name, method.params])).toEqual([
+                ['bind', immutable_1.default.List([ts.param('address', 'Address')])],
+                ['read', immutable_1.default.List()],
+                ['try_read', immutable_1.default.List()],
+                [
+                    'getProposal',
+                    immutable_1.default.List([
+                        ts.param('proposalId', 'BigInt'),
+                        ts.param('param1', 'Contract__getProposalInputParam1Struct'),
+                    ]),
+                ],
+                [
+                    'try_getProposal',
+                    immutable_1.default.List([
+                        ts.param('proposalId', 'BigInt'),
+                        ts.param('param1', 'Contract__getProposalInputParam1Struct'),
+                    ]),
+                ],
+                ['getProposals', immutable_1.default.List()],
+                ['try_getProposals', immutable_1.default.List()],
+                ['overloaded', immutable_1.default.List([ts.param('param0', 'string')])],
+                ['try_overloaded', immutable_1.default.List([ts.param('param0', 'string')])],
+                ['overloaded1', immutable_1.default.List([ts.param('param0', 'BigInt')])],
+                ['try_overloaded1', immutable_1.default.List([ts.param('param0', 'BigInt')])],
+                ['overloaded2', immutable_1.default.List([ts.param('param0', 'Bytes')])],
+                ['try_overloaded2', immutable_1.default.List([ts.param('param0', 'Bytes')])],
+            ]);
+        });
+        test('Have correct return types', () => {
+            let contract = generatedTypes.find(type => type.name === 'Contract');
+            expect(contract.methods.map(method => [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 => [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 => [method.name, method.returnType])).toEqual([
+                ['get baz', 'Address'],
+            ]);
+        });
+        test('Tuple types exist for function return values', () => {
+            let 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 => [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', () => {
+            let contract = generatedTypes.find(type => type.name === 'Contract');
+            let getter = contract.methods.find(method => method.name === 'getProposals');
+            expect(getter.body).not.toContain('toTupleArray<undefined>');
+            expect(getter.body).toContain('result[1].toTupleArray<Contract__getProposalsResultValue1Struct>()');
+        });
+    });
+});

package/dist/protocols/ethereum/codegen/template.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tsCodegen = __importStar(require("../../../codegen/typescript"));
+class EthereumTemplateCodeGen {
+    constructor(template) {
+        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)
+      `);
+    }
+}
+exports.default = EthereumTemplateCodeGen;

package/dist/protocols/ethereum/contract.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class EthereumContract {
+    static identifierName() {
+        return 'address';
+    }
+    constructor(address) {
+        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,
+        };
+    }
+}
+exports.default = EthereumContract;

package/dist/protocols/ethereum/manifest.graphql

@@ -0,0 +1,94 @@
+# 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/dist/protocols/ethereum/scaffold/manifest.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapping = exports.source = void 0;
+const schema_1 = require("../../../scaffold/schema");
+const gluegun_1 = require("gluegun");
+const abi_1 = __importDefault(require("../abi"));
+const source = ({ contract, contractName }) => `
+      address: '${contract}'
+      abi: ${contractName}`;
+exports.source = source;
+const mapping = ({ abi, contractName }) => `
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        ${(0, schema_1.abiEvents)(abi)
+    .map(event => `- ${event.get('_alias')}`)
+    .join('\n        ')}
+      abis:
+        - name: ${contractName}
+          file: ./abis/${contractName}.json
+      eventHandlers:
+        ${(0, schema_1.abiEvents)(abi)
+    .map(event => `
+        - event: ${abi_1.default.eventSignature(event)}
+          handler: handle${event.get('_alias')}`)
+    .join('')}
+      file: ./src/${gluegun_1.strings.kebabCase(contractName)}.ts`;
+exports.mapping = mapping;

package/dist/protocols/ethereum/scaffold/mapping.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePlaceholderHandlers = void 0;
+const mapping_1 = require("../../../scaffold/mapping");
+const generatePlaceholderHandlers = ({ abi, events, contractName }) => `
+  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
+      ${(0, mapping_1.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 => `- contract.${fn.get('name')}(...)`)
+            .join('\n// ')}
+    }
+    `
+    : `
+export function handle${event._alias}(event: ${event._alias}): void {}
+`)
+    .join('\n')}`;
+exports.generatePlaceholderHandlers = generatePlaceholderHandlers;