Basic state change

Author: moose-code

.gitignore

@@ -0,0 +1,3 @@
+node_modules
+build
+generated

package.json

@@ -4,7 +4,7 @@
   "scripts": {
     "codegen": "graph codegen",
     "build": "graph build",
-    "deploy": "graph deploy --node https://api.thegraph.com/deploy/ --ipfs https://api.thegraph.com/ipfs/ avolabs-io/async-subgraph_v2",
+    "deploy": "graph deploy --node https://api.thegraph.com/deploy/ --ipfs https://api.thegraph.com/ipfs/ avolabs-io/async_art_v2",
     "create-local": "graph create --node http://localhost:8020/ avolabs-io/async-subgraph_v2",
     "remove-local": "graph remove --node http://localhost:8020/ avolabs-io/async-subgraph_v2",
     "deploy-local": "graph deploy --node http://localhost:8020/ --ipfs http://localhost:5001 avolabs-io/async-subgraph_v2"

schema.graphql

@@ -4,3 +4,37 @@ type ExampleEntity @entity {
   owner: Bytes! # address
   approved: Bytes! # address
 }
+
+type EventParam @entity {
+  id: ID!
+  index: Int!
+  param: String!
+  paramName: String!
+  paramType: String!
+}
+type EventParams @entity {
+  id: ID!
+  index: Int!
+  eventName: String!
+  params: [EventParam!]!
+}
+
+# For every transaction, list the changes, and stat
+type StateChange @entity {
+  id: ID! # tx
+  timestamp: BigInt!
+  blockNumber: BigInt!
+  contractVersion: Int!
+  txEventList: [String!]! #call event logs or something
+  txEventParamListDeprecated: [String!]!
+  txEventParamList: [EventParams!]
+  ownerChanges: [Owner!]!
+  artworkChanges: [Artwork!]!
+}
+
+type Owner @entity {
+  id: ID!
+}
+type Artwork @entity {
+  id: ID!
+}

src/mapping.ts

@@ -16,75 +16,35 @@ import {
   Transfer
 } from "../generated/Contract/Contract"
 import { ExampleEntity } from "../generated/schema"
+import {
+  saveEventToStateChange,
+} from "./util";
 
 export function handleApproval(event: Approval): 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())
-
-  // Entities only exist after they have been saved to the store;
-  // `null` checks allow to create entities on demand
-  if (entity == null) {
-    entity = new ExampleEntity(event.transaction.from.toHex())
-
-    // 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.owner = event.params.owner
-  entity.approved = event.params.approved
-
-  // 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.artistSecondSalePercentage(...)
-  // - contract.balanceOf(...)
-  // - contract.buyPrices(...)
-  // - contract.controlTokenMapping(...)
-  // - contract.creatorWhitelist(...)
-  // - contract.expectedTokenSupply(...)
-  // - contract.failedTransferCredits(...)
-  // - contract.getApproved(...)
-  // - contract.isApprovedForAll(...)
-  // - contract.minBidIncreasePercent(...)
-  // - contract.name(...)
-  // - contract.ownerOf(...)
-  // - contract.pendingBids(...)
-  // - contract.permissionedControllers(...)
-  // - contract.platformAddress(...)
-  // - contract.platformFirstSalePercentages(...)
-  // - contract.platformSecondSalePercentages(...)
-  // - contract.supportsInterface(...)
-  // - contract.symbol(...)
-  // - contract.tokenByIndex(...)
-  // - contract.tokenDidHaveFirstSale(...)
-  // - contract.tokenOfOwnerByIndex(...)
-  // - contract.tokenURI(...)
-  // - contract.tokenURILocked(...)
-  // - contract.totalSupply(...)
-  // - contract.uniqueTokenCreators(...)
-  // - contract.upgraderAddress(...)
-  // - contract.getNumRemainingControlUpdates(...)
-  // - contract.getControlToken(...)
+
+  let owner = event.params.owner;
+  let ownerString = owner.toHex();
+  let txTimestamp = event.block.timestamp;
+  let blockNumber = event.block.number;
+
+  let eventParamValues: Array<string> = [
+    ownerString,
+  ];
+  let eventParamNames: Array<string> = ["owner"];
+  let eventParamTypes: Array<string> = ["address"];
+
+  saveEventToStateChange(
+    event.transaction.hash,
+    txTimestamp,
+    blockNumber,
+    "Approval",
+    eventParamValues,
+    eventParamNames,
+    eventParamTypes,
+    [],
+    [],
+    0
+  );
 }
 
 export function handleApprovalForAll(event: ApprovalForAll): void {}

src/util/index.ts

@@ -0,0 +1,137 @@
+import { Address, BigInt, log, Bytes } from "@graphprotocol/graph-ts";
+import {
+  StateChange,
+  EventParam,
+  EventParams,
+  Owner,
+  Artwork,
+} from "../../generated/schema";
+
+export function getOrInitialiseStateChange(txId: string): StateChange | null {
+    let stateChange = StateChange.load(txId);
+    if (stateChange == null) {
+      stateChange = new StateChange(txId);
+      stateChange.txEventParamList = [];
+      stateChange.ownerChanges = [];
+      stateChange.artworkChanges = [];
+
+      return stateChange;
+    } else {
+      return stateChange;
+    }
+  }
+  function getEventIndex(txHash: Bytes): i32 {
+    let stateChange = StateChange.load(txHash.toHex());
+    if (stateChange == null) {
+      return 0;
+    }
+    return stateChange.txEventParamList.length;
+  }
+  function createEventParams(
+    txHash: Bytes,
+    argValues: Array<string>,
+    argNames: Array<string>,
+    argTypes: Array<string>
+  ): Array<string> {
+    let eventIndex: i32 = getEventIndex(txHash);
+    let eventParamsArr: Array<string> = [];
+    for (let index = 0; index < argValues.length; index++) {
+      let eventParamFund = new EventParam(
+        txHash.toHex() + "-" + eventIndex.toString() + "-" + index.toString()
+      );
+      eventParamFund.index = index;
+      eventParamFund.param = argValues[index];
+      eventParamFund.paramName = argNames[index];
+      eventParamFund.paramType = argTypes[index];
+      eventParamFund.save();
+      eventParamsArr.push(eventParamFund.id);
+    }
+    return eventParamsArr;
+  }
+  function txEventParamsHelper(
+    eventName: string,
+    eventIndex: i32,
+    eventTxHash: Bytes,
+    eventParamsArr: Array<string>
+  ): EventParams {
+    let eventParams = new EventParams(
+      eventTxHash.toHex() + "-" + eventIndex.toString()
+    );
+    eventParams.index = eventIndex;
+    eventParams.eventName = eventName;
+    eventParams.params = eventParamsArr;
+    eventParams.save();
+    return eventParams;
+  }
+  function txStateChangeHelper(
+    txHash: Bytes,
+    timeStamp: BigInt,
+    blockNumber: BigInt,
+    eventName: string,
+    eventParamArray: Array<string>,
+    changedOwners: string[],
+    changedArtworks: string[],
+    contractVersion: i32
+  ): void {
+    let stateChange = getOrInitialiseStateChange(txHash.toHex());
+    if (stateChange == null) {
+      stateChange = new StateChange(txHash.toHex());
+      stateChange.txEventParamList = [];
+    }
+    let eventIndex: i32 = getEventIndex(txHash);
+    // create EventParams
+    let eventParams = txEventParamsHelper(
+      eventName,
+      eventIndex,
+      txHash,
+      eventParamArray
+    );
+    stateChange.timestamp = timeStamp;
+    stateChange.blockNumber = blockNumber;
+    stateChange.txEventParamList = stateChange.txEventParamList.concat([
+      eventParams.id,
+    ]);
+    for (let i = 0, len = changedOwners.length; i < len; i++) {
+      stateChange.ownerChanges =
+        stateChange.ownerChanges.indexOf(changedOwners[i]) === -1
+          ? stateChange.ownerChanges.concat([changedOwners[i]])
+          : stateChange.ownerChanges;
+    }
+    for (let i = 0, len = changedArtworks.length; i < len; i++) {
+      stateChange.artworkChanges =
+        stateChange.artworkChanges.indexOf(changedArtworks[i]) === -1
+          ? stateChange.artworkChanges.concat([changedArtworks[i]])
+          : stateChange.artworkChanges;
+    }
+    stateChange.contractVersion = contractVersion;
+    stateChange.save();
+  }
+  export function saveEventToStateChange(
+    txHash: Bytes,
+    timestamp: BigInt,
+    blockNumber: BigInt,
+    eventName: string,
+    parameterValues: Array<string>,
+    parameterNames: Array<string>,
+    parameterTypes: Array<string>,
+    changedOwners: string[],
+    changedArtworks: string[],
+    version: i32
+  ): void {
+    let eventParamsArr: Array<string> = createEventParams(
+      txHash,
+      parameterValues,
+      parameterNames,
+      parameterTypes
+    );
+    txStateChangeHelper(
+      txHash,
+      timestamp,
+      blockNumber,
+      eventName,
+      eventParamsArr,
+      changedOwners,
+      changedArtworks,
+      version
+    );
+  }

subgraph.yaml

@@ -1,4 +1,4 @@
-specVersion: 0.0.1
+specVersion: 0.0.2
 schema:
   file: ./schema.graphql
 dataSources:
@@ -8,9 +8,10 @@ dataSources:
     source:
       address: "0xb6dAe651468E9593E4581705a09c10A76AC1e0c8"
       abi: Contract
+      startBlock: 8752679
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.2
+      apiVersion: 0.0.3
       language: wasm/assemblyscript
       entities:
         - Approval