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

package/dist/scaffold/ethereum.test.js

@@ -0,0 +1,505 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abi_1 = __importDefault(require("../protocols/ethereum/abi"));
+const immutable_1 = __importDefault(require("immutable"));
+const _1 = __importDefault(require("./"));
+const protocols_1 = __importDefault(require("../protocols"));
+const TEST_EVENT = {
+    name: 'ExampleEvent',
+    type: 'event',
+    inputs: [
+        { name: 'a', type: 'uint256', indexed: true },
+        { name: 'b', type: 'bytes[4]' },
+        { type: 'string' },
+        {
+            name: 'c',
+            type: 'tuple',
+            components: [
+                { name: 'c1', type: 'uint256' },
+                { type: 'bytes32' },
+                { type: 'string' },
+                {
+                    name: 'c3',
+                    type: 'tuple',
+                    components: [
+                        { name: 'c31', type: 'uint96' },
+                        { type: 'string' },
+                        { type: 'bytes32' },
+                    ],
+                },
+            ],
+        },
+        { name: 'd', type: 'string', indexed: true },
+    ],
+};
+const OVERLOADED_EVENT = {
+    name: 'ExampleEvent',
+    type: 'event',
+    inputs: [{ name: 'a', type: 'bytes32' }],
+};
+const TEST_CONTRACT = {
+    name: 'ExampleContract',
+    type: 'contract',
+};
+const TEST_CALLABLE_FUNCTIONS = [
+    {
+        name: 'someVariable',
+        type: 'function',
+        stateMutability: 'view',
+        outputs: [{ type: 'uint256' }],
+    },
+    {
+        name: 'getSomeValue',
+        type: 'function',
+        stateMutability: 'pure',
+        outputs: [{ type: 'tuple', components: [{ type: 'uint256' }] }],
+    },
+];
+const TEST_ABI = new abi_1.default('Contract', undefined, immutable_1.default.fromJS([
+    TEST_EVENT,
+    OVERLOADED_EVENT,
+    TEST_CONTRACT,
+    ...TEST_CALLABLE_FUNCTIONS,
+]));
+const protocol = new protocols_1.default('ethereum');
+const scaffoldOptions = {
+    protocol,
+    abi: TEST_ABI,
+    contract: '0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d',
+    network: 'kovan',
+    contractName: 'Contract',
+};
+const scaffold = new _1.default(scaffoldOptions);
+const scaffoldWithIndexEvents = new _1.default({
+    ...scaffoldOptions,
+    indexEvents: true,
+});
+describe('Ethereum subgraph scaffolding', () => {
+    test('Manifest', () => {
+        expect(scaffold.generateManifest()).toEqual(`\
+specVersion: 0.0.5
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum
+    name: Contract
+    network: kovan
+    source:
+      address: "0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - ExampleEvent
+        - ExampleEvent1
+      abis:
+        - name: Contract
+          file: ./abis/Contract.json
+      eventHandlers:
+        - event: ExampleEvent(indexed uint256,bytes[4],string,(uint256,bytes32,string,(uint96,string,bytes32)),indexed string)
+          handler: handleExampleEvent
+        - event: ExampleEvent(bytes32)
+          handler: handleExampleEvent1
+      file: ./src/contract.ts
+`);
+    });
+    test('Schema (default)', () => {
+        expect(scaffold.generateSchema()).toEqual(`\
+type ExampleEntity @entity {
+  id: Bytes!
+  count: BigInt!
+  a: BigInt! # uint256
+  b: [Bytes]! # bytes[4]
+}
+`);
+    });
+    test('Schema (for indexing events)', () => {
+        expect(scaffoldWithIndexEvents.generateSchema()).toEqual(`\
+type ExampleEvent @entity(immutable: true) {
+  id: Bytes!
+  a: BigInt! # uint256
+  b: [Bytes]! # bytes[4]
+  param2: String! # string
+  c_c1: BigInt! # uint256
+  c_value1: Bytes! # bytes32
+  c_value2: String! # string
+  c_c3_c31: BigInt! # uint96
+  c_c3_value1: String! # string
+  c_c3_value2: Bytes! # bytes32
+  d: String! # string
+  blockNumber: BigInt!
+  blockTimestamp: BigInt!
+  transactionHash: Bytes!
+}
+
+type ExampleEvent1 @entity(immutable: true) {
+  id: Bytes!
+  a: Bytes! # bytes32
+  blockNumber: BigInt!
+  blockTimestamp: BigInt!
+  transactionHash: Bytes!
+}
+`);
+    });
+    test('Mapping (default)', () => {
+        expect(scaffold.generateMapping()).toEqual(`\
+import { BigInt } from "@graphprotocol/graph-ts"
+import {
+  Contract,
+  ExampleEvent,
+  ExampleEvent1
+} from "../generated/Contract/Contract"
+import { ExampleEntity } from "../generated/schema"
+
+export function handleExampleEvent(event: ExampleEvent): 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
+  entity.a = event.params.a
+  entity.b = event.params.b
+
+  // 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:
+  //
+  // - contract.someVariable(...)
+  // - contract.getSomeValue(...)
+}
+
+export function handleExampleEvent1(event: ExampleEvent1): void {}
+`);
+    });
+    test('Mapping (for indexing events)', () => {
+        expect(scaffoldWithIndexEvents.generateMapping()).toEqual(`\
+import {
+  ExampleEvent as ExampleEventEvent,
+  ExampleEvent1 as ExampleEvent1Event
+} from "../generated/Contract/Contract"
+import { ExampleEvent, ExampleEvent1 } from "../generated/schema"
+
+export function handleExampleEvent(event: ExampleEventEvent): void {
+  let entity = new ExampleEvent(
+    event.transaction.hash.concatI32(event.logIndex.toI32())
+  )
+  entity.a = event.params.a
+  entity.b = event.params.b
+  entity.param2 = event.params.param2
+  entity.c_c1 = event.params.c.c1
+  entity.c_value1 = event.params.c.value1
+  entity.c_value2 = event.params.c.value2
+  entity.c_c3_c31 = event.params.c.c3.c31
+  entity.c_c3_value1 = event.params.c.c3.value1
+  entity.c_c3_value2 = event.params.c.c3.value2
+  entity.d = event.params.d
+
+  entity.blockNumber = event.block.number
+  entity.blockTimestamp = event.block.timestamp
+  entity.transactionHash = event.transaction.hash
+
+  entity.save()
+}
+
+export function handleExampleEvent1(event: ExampleEvent1Event): void {
+  let entity = new ExampleEvent1(
+    event.transaction.hash.concatI32(event.logIndex.toI32())
+  )
+  entity.a = event.params.a
+
+  entity.blockNumber = event.block.number
+  entity.blockTimestamp = event.block.timestamp
+  entity.transactionHash = event.transaction.hash
+
+  entity.save()
+}
+`);
+    });
+    test('Test Files (default)', () => {
+        const files = scaffoldWithIndexEvents.generateTests();
+        const testFile = files['contract.test.ts'];
+        const utilsFile = files['contract-utils.ts'];
+        expect(testFile).toEqual(`\
+import {
+  assert,
+  describe,
+  test,
+  clearStore,
+  beforeAll,
+  afterAll
+} from \"matchstick-as/assembly/index\"
+import { BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent } from \"../generated/schema\"
+import { ExampleEvent as ExampleEventEvent } from \"../generated/Contract/Contract\"
+import { handleExampleEvent } from \"../src/contract\"
+import { createExampleEventEvent } from \"./contract-utils\"
+
+// Tests structure (matchstick-as >=0.5.0)
+// https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+describe(\"Describe entity assertions\", () => {
+  beforeAll(() => {
+    let a = BigInt.fromI32(234)
+    let b = [Bytes.fromI32(1234567890)]
+    let param2 = \"Example string value\"
+    let c = \"ethereum.Tuple Not implemented\"
+    let d = \"Example string value\"
+    let newExampleEventEvent = createExampleEventEvent(a, b, param2, c, d)
+    handleExampleEvent(newExampleEventEvent)
+  })
+
+  afterAll(() => {
+    clearStore()
+  })
+
+  // For more test scenarios, see:
+  // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+  test(\"ExampleEvent created and stored\", () => {
+    assert.entityCount(\"ExampleEvent\", 1)
+
+    // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"a\",
+      \"234\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"b\",
+      \"[1234567890]\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"param2\",
+      \"Example string value\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"c\",
+      \"ethereum.Tuple Not implemented\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"d\",
+      \"Example string value\"
+    )
+
+    // More assert options:
+    // https://thegraph.com/docs/en/developer/matchstick/#asserts
+  })
+})
+`);
+        expect(utilsFile).toEqual(`\
+import { newMockEvent } from \"matchstick-as\"
+import { ethereum, BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent, ExampleEvent1 } from \"../generated/Contract/Contract\"
+
+export function createExampleEventEvent(
+  a: BigInt,
+  b: Array<Bytes>,
+  param2: string,
+  c: ethereum.Tuple,
+  d: string
+): ExampleEvent {
+  let exampleEventEvent = changetype<ExampleEvent>(newMockEvent())
+
+  exampleEventEvent.parameters = new Array()
+
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromUnsignedBigInt(a))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"b\", ethereum.Value.fromBytesArray(b))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"param2\", ethereum.Value.fromString(param2))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"c\", ethereum.Value.fromTuple(c))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"d\", ethereum.Value.fromString(d))
+  )
+
+  return exampleEventEvent
+}
+
+export function createExampleEvent1Event(a: Bytes): ExampleEvent1 {
+  let exampleEvent1Event = changetype<ExampleEvent1>(newMockEvent())
+
+  exampleEvent1Event.parameters = new Array()
+
+  exampleEvent1Event.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromFixedBytes(a))
+  )
+
+  return exampleEvent1Event
+}
+`);
+    });
+    test('Test Files (for indexing events)', () => {
+        const files = scaffoldWithIndexEvents.generateTests();
+        const testFile = files['contract.test.ts'];
+        const utilsFile = files['contract-utils.ts'];
+        expect(testFile).toEqual(`\
+import {
+  assert,
+  describe,
+  test,
+  clearStore,
+  beforeAll,
+  afterAll
+} from \"matchstick-as/assembly/index\"
+import { BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent } from \"../generated/schema\"
+import { ExampleEvent as ExampleEventEvent } from \"../generated/Contract/Contract\"
+import { handleExampleEvent } from \"../src/contract\"
+import { createExampleEventEvent } from \"./contract-utils\"
+
+// Tests structure (matchstick-as >=0.5.0)
+// https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+describe(\"Describe entity assertions\", () => {
+  beforeAll(() => {
+    let a = BigInt.fromI32(234)
+    let b = [Bytes.fromI32(1234567890)]
+    let param2 = \"Example string value\"
+    let c = \"ethereum.Tuple Not implemented\"
+    let d = \"Example string value\"
+    let newExampleEventEvent = createExampleEventEvent(a, b, param2, c, d)
+    handleExampleEvent(newExampleEventEvent)
+  })
+
+  afterAll(() => {
+    clearStore()
+  })
+
+  // For more test scenarios, see:
+  // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+  test(\"ExampleEvent created and stored\", () => {
+    assert.entityCount(\"ExampleEvent\", 1)
+
+    // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"a\",
+      \"234\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"b\",
+      \"[1234567890]\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"param2\",
+      \"Example string value\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"c\",
+      \"ethereum.Tuple Not implemented\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"d\",
+      \"Example string value\"
+    )
+
+    // More assert options:
+    // https://thegraph.com/docs/en/developer/matchstick/#asserts
+  })
+})
+`);
+        expect(utilsFile).toEqual(`\
+import { newMockEvent } from \"matchstick-as\"
+import { ethereum, BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent, ExampleEvent1 } from \"../generated/Contract/Contract\"
+
+export function createExampleEventEvent(
+  a: BigInt,
+  b: Array<Bytes>,
+  param2: string,
+  c: ethereum.Tuple,
+  d: string
+): ExampleEvent {
+  let exampleEventEvent = changetype<ExampleEvent>(newMockEvent())
+
+  exampleEventEvent.parameters = new Array()
+
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromUnsignedBigInt(a))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"b\", ethereum.Value.fromBytesArray(b))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"param2\", ethereum.Value.fromString(param2))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"c\", ethereum.Value.fromTuple(c))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"d\", ethereum.Value.fromString(d))
+  )
+
+  return exampleEventEvent
+}
+
+export function createExampleEvent1Event(a: Bytes): ExampleEvent1 {
+  let exampleEvent1Event = changetype<ExampleEvent1>(newMockEvent())
+
+  exampleEvent1Event.parameters = new Array()
+
+  exampleEvent1Event.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromFixedBytes(a))
+  )
+
+  return exampleEvent1Event
+}
+`);
+    });
+});

package/dist/scaffold/index.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prettier_1 = __importDefault(require("prettier"));
+const pkginfo = require('pkginfo')(module);
+const gluegun_1 = require("gluegun");
+const GRAPH_CLI_VERSION = process.env.GRAPH_CLI_TESTS
+    ? // JSON.stringify should remove this key, we will install the local
+        // graph-cli for the tests using `npm link` instead of fetching from npm.
+        undefined
+    : // For scaffolding real subgraphs
+        `${module.exports.version}`;
+const schema_1 = require("./schema");
+const mapping_1 = require("./mapping");
+const tests_1 = require("./tests");
+const subgraph_1 = require("../command-helpers/subgraph");
+class Scaffold {
+    constructor(options = {}) {
+        this.protocol = options.protocol;
+        this.abi = options.abi;
+        this.indexEvents = options.indexEvents;
+        this.contract = options.contract;
+        this.network = options.network;
+        this.contractName = options.contractName;
+        this.subgraphName = options.subgraphName;
+        this.node = options.node;
+    }
+    generatePackageJson() {
+        return prettier_1.default.format(JSON.stringify({
+            name: (0, subgraph_1.getSubgraphBasename)(this.subgraphName),
+            license: 'UNLICENSED',
+            scripts: {
+                codegen: 'graph codegen',
+                build: 'graph build',
+                deploy: `graph deploy ` + `--node ${this.node} ` + this.subgraphName,
+                'create-local': `graph create --node http://localhost:8020/ ${this.subgraphName}`,
+                'remove-local': `graph remove --node http://localhost:8020/ ${this.subgraphName}`,
+                'deploy-local': `graph deploy ` +
+                    `--node http://localhost:8020/ ` +
+                    `--ipfs http://localhost:5001 ` +
+                    this.subgraphName,
+                test: 'graph test',
+            },
+            dependencies: {
+                '@graphprotocol/graph-cli': GRAPH_CLI_VERSION,
+                '@graphprotocol/graph-ts': `0.29.1`,
+            },
+            devDependencies: this.protocol.hasEvents()
+                ? { 'matchstick-as': `0.5.0` }
+                : undefined,
+        }), { parser: 'json' });
+    }
+    generateManifest() {
+        const protocolManifest = this.protocol.getManifestScaffold();
+        return prettier_1.default.format(`
+specVersion: 0.0.5
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ${this.protocol.name}
+    name: ${this.contractName}
+    network: ${this.network}
+    source: ${protocolManifest.source(this)}
+    mapping: ${protocolManifest.mapping(this)}
+`, { parser: 'yaml' });
+    }
+    generateSchema() {
+        const hasEvents = this.protocol.hasEvents();
+        const events = hasEvents ? (0, schema_1.abiEvents)(this.abi).toJS() : [];
+        return prettier_1.default.format(hasEvents && this.indexEvents
+            ? events.map(event => (0, schema_1.generateEventType)(event, this.protocol.name)).join('\n\n')
+            : (0, schema_1.generateExampleEntityType)(this.protocol, events), {
+            parser: 'graphql',
+        });
+    }
+    generateTsConfig() {
+        return prettier_1.default.format(JSON.stringify({
+            extends: '@graphprotocol/graph-ts/types/tsconfig.base.json',
+            include: ['src'],
+        }), { parser: 'json' });
+    }
+    generateMappings() {
+        return this.protocol.getMappingScaffold()
+            ? { [`${gluegun_1.strings.kebabCase(this.contractName)}.ts`]: this.generateMapping() }
+            : undefined;
+    }
+    generateMapping() {
+        const hasEvents = this.protocol.hasEvents();
+        const events = hasEvents ? (0, schema_1.abiEvents)(this.abi).toJS() : [];
+        const protocolMapping = this.protocol.getMappingScaffold();
+        return prettier_1.default.format(hasEvents && this.indexEvents
+            ? (0, mapping_1.generateEventIndexingHandlers)(events, this.contractName)
+            : protocolMapping.generatePlaceholderHandlers({
+                ...this,
+                events,
+            }), { parser: 'typescript', semi: false });
+    }
+    generateABIs() {
+        return this.protocol.hasABIs()
+            ? {
+                [`${this.contractName}.json`]: prettier_1.default.format(JSON.stringify(this.abi.data), {
+                    parser: 'json',
+                }),
+            }
+            : undefined;
+    }
+    generateTests() {
+        const hasEvents = this.protocol.hasEvents();
+        const events = hasEvents ? (0, schema_1.abiEvents)(this.abi).toJS() : [];
+        return events.length > 0
+            ? (0, tests_1.generateTestsFiles)(this.contractName, events, this.indexEvents)
+            : undefined;
+    }
+    generate() {
+        return {
+            'package.json': this.generatePackageJson(),
+            'subgraph.yaml': this.generateManifest(),
+            'schema.graphql': this.generateSchema(),
+            'tsconfig.json': this.generateTsConfig(),
+            src: this.generateMappings(),
+            abis: this.generateABIs(),
+            tests: this.generateTests(),
+        };
+    }
+}
+exports.default = Scaffold;

package/dist/scaffold/mapping.js

@@ -0,0 +1,61 @@
+"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 });
+exports.generateEventIndexingHandlers = exports.generateEventFieldAssignments = exports.generateFieldAssignments = exports.generateFieldAssignment = void 0;
+const path_1 = __importDefault(require("path"));
+const util = __importStar(require("../codegen/util"));
+const generateFieldAssignment = path => `entity.${path.join('_')} = event.params.${path.join('.')}`;
+exports.generateFieldAssignment = generateFieldAssignment;
+const generateFieldAssignments = ({ index, input }) => input.type === 'tuple'
+    ? util
+        .unrollTuple({ value: input, index, path: [input.name || `param${index}`] })
+        .map(({ path }) => generateFieldAssignment(path))
+    : generateFieldAssignment([input.name || `param${index}`]);
+exports.generateFieldAssignments = generateFieldAssignments;
+const generateEventFieldAssignments = event => event.inputs.reduce((acc, input, index) => acc.concat(generateFieldAssignments({ input, index })), []);
+exports.generateEventFieldAssignments = generateEventFieldAssignments;
+const generateEventIndexingHandlers = (events, contractName) => `
+  import { ${events.map(event => `${event._alias} as ${event._alias}Event`)}} from '../generated/${contractName}/${contractName}'
+  import { ${events.map(event => event._alias)} } from '../generated/schema'
+
+  ${events
+    .map(event => `
+  export function handle${event._alias}(event: ${event._alias}Event): void {
+    let entity = new ${event._alias}(event.transaction.hash.concatI32(event.logIndex.toI32()))
+    ${generateEventFieldAssignments(event).join('\n')}
+
+    entity.blockNumber = event.block.number
+    entity.blockTimestamp = event.block.timestamp
+    entity.transactionHash = event.transaction.hash
+
+    entity.save()
+  }
+    `)
+    .join('\n')}
+`;
+exports.generateEventIndexingHandlers = generateEventIndexingHandlers;