Implement Bytes as ID, block/tx data and @immutable

Author: schmidsi

src/protocols/ethereum/scaffold/mapping.js

@@ -14,12 +14,12 @@ const generatePlaceholderHandlers = ({ abi, events, contractName }) =>
     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.toHex())
+      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.toHex())
+        entity = new ExampleEntity(event.transaction.from)
 
         // Entity fields can be set using simple assignments
         entity.count = BigInt.fromI32(0)

src/scaffold/ethereum.test.js

@@ -145,7 +145,6 @@ type ExampleEvent @entity(immutable: true) {
   c_c3_value1: String! # string
   c_c3_value2: Bytes! # bytes32
   d: String! # string
-
   # Block & transaction info
   blockNumber: BigInt!
   blockHash: Bytes!
@@ -159,7 +158,6 @@ type ExampleEvent1 @entity(immutable: true) {
 
   # Event params
   a: Bytes! # bytes32
-
   # Block & transaction info
   blockNumber: BigInt!
   blockHash: Bytes!
@@ -237,7 +235,7 @@ import { ExampleEvent, ExampleEvent1 } from "../generated/schema"
 
 export function handleExampleEvent(event: ExampleEventEvent): void {
   let entity = new ExampleEvent(
-    event.transaction.hash.concatI32(event.logIndex.toI32()),
+    event.transaction.hash.concatI32(event.logIndex.toI32())
   )
   entity.a = event.params.a
   entity.b = event.params.b
@@ -261,7 +259,7 @@ export function handleExampleEvent(event: ExampleEventEvent): void {
 
 export function handleExampleEvent1(event: ExampleEvent1Event): void {
   let entity = new ExampleEvent1(
-    event.transaction.hash.concatI32(event.logIndex.toI32()),
+    event.transaction.hash.concatI32(event.logIndex.toI32())
   )
   entity.a = event.params.a
 

src/scaffold/mapping.js

@@ -32,8 +32,15 @@ const generateEventIndexingHandlers = (events, contractName) =>
   export function handle${event._alias}(event: ${event._alias}Event): void {
     let entity = new ${
       event._alias
-    }(event.transaction.hash.toHex() + '-' + event.logIndex.toString())
+    }(event.transaction.hash.concatI32(event.logIndex.toI32()))
     ${generateEventFieldAssignments(event).join('\n')}
+
+    entity.blockNumber = event.block.number
+    entity.blockHash = event.block.hash
+    entity.blockTimestamp = event.block.timestamp
+    entity.transactionHash = event.transaction.hash
+    entity.logIndex = event.logIndex
+
     entity.save()
   }
     `,

src/scaffold/schema.js

@@ -20,36 +20,59 @@ const generateEventFields = ({ index, input, protocolName }) =>
   input.type == 'tuple'
     ? util
         .unrollTuple({ value: input, path: [input.name || `param${index}`], index })
-        .map(({ path, type }) => generateField({ name: path.join('_'), type, protocolName }))
-    : [generateField({ name: input.name || `param${index}`, type: input.type, protocolName })]
+        .map(({ path, type }) =>
+          generateField({ name: path.join('_'), type, protocolName }),
+        )
+    : [
+        generateField({
+          name: input.name || `param${index}`,
+          type: input.type,
+          protocolName,
+        }),
+      ]
+
+const generateEventType = (event, protocolName) => `type ${
+  event._alias
+} @entity(immutable: true) {
+      id: Bytes!
 
-const generateEventType = (event, protocolName) => `type ${event._alias} @entity {
-      id: ID!
+      # Event params
       ${event.inputs
         .reduce(
-          (acc, input, index) => acc.concat(generateEventFields({ input, index, protocolName })),
+          (acc, input, index) =>
+            acc.concat(generateEventFields({ input, index, protocolName })),
           [],
         )
-        .join('\n')}
+        .join('\n')}  
+      # Block & transaction info
+      blockNumber: BigInt!
+      blockHash: Bytes!
+      blockTimestamp: BigInt!
+      transactionHash: Bytes!
+      logIndex: BigInt!
     }`
 
 const generateExampleEntityType = (protocol, events) => {
-    if (protocol.hasABIs() && events.length > 0) {
-      return `type ExampleEntity @entity {
-  id: ID!
+  if (protocol.hasABIs() && events.length > 0) {
+    return `type ExampleEntity @entity {
+  id: Bytes!
   count: BigInt!
   ${events[0].inputs
-    .reduce((acc, input, index) => acc.concat(generateEventFields({ input, index, protocolName: protocol.name })), [])
+    .reduce(
+      (acc, input, index) =>
+        acc.concat(generateEventFields({ input, index, protocolName: protocol.name })),
+      [],
+    )
     .slice(0, 2)
     .join('\n')}
 }`
-    } else {
-      return `type ExampleEntity @entity {
+  } else {
+    return `type ExampleEntity @entity {
   id: ID!
   block: Bytes!
   count: BigInt!
 }`
-    }
+  }
 }
 
 module.exports = {