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

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

@@ -0,0 +1,325 @@
+"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 path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const immutable_1 = __importDefault(require("immutable"));
+const ts = __importStar(require("../../../codegen/typescript"));
+const abi_1 = __importDefault(require("../abi"));
+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 {
+            const 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);
+            const 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', () => {
+            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) => method.name === 'bind')).toBeDefined();
+        });
+        test('Has methods for all callable functions', () => {
+            const 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', () => {
+            const 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', () => {
+            const 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', () => {
+            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) => [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) => 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,52 @@
+"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 {
+    template;
+    constructor(template) {
+        this.template = 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,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class EthereumContract {
+    address;
+    static identifierName() {
+        return 'address';
+    }
+    constructor(address) {
+        this.address = 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/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 gluegun_1 = require("gluegun");
+const schema_1 = require("../../../scaffold/schema");
+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/{src/protocols/ethereum/scaffold/mapping.ts → dist/protocols/ethereum/scaffold/mapping.js}

@@ -1,25 +1,16 @@
-import { generateEventFieldAssignments } from '../../../scaffold/mapping';
-import ABI from '../abi';
-
-export const generatePlaceholderHandlers = ({
-  abi,
-  events,
-  contractName,
-}: {
-  abi: ABI;
-  events: any[];
-  contractName: string;
-}) =>
-  `
+"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
-        ? `
+    .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
@@ -38,7 +29,7 @@ export const generatePlaceholderHandlers = ({
       entity.count = entity.count + BigInt.fromI32(1)
 
       // Entity fields can be set based on event parameters
-      ${generateEventFieldAssignments(event).slice(0, 2).join('\n')}
+      ${(0, mapping_1.generateEventFieldAssignments)(event).slice(0, 2).join('\n')}
 
       // Entities can be written to the store with \`.save()\`
       entity.save()
@@ -58,19 +49,17 @@ export const generatePlaceholderHandlers = ({
       // 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// ')
-      }
+      // ${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;