Merge.

Author: Van Gulck Rik

generated/schema.ts

@@ -600,6 +600,23 @@ export class Node extends Entity {
   constructor(id: string) {
     super();
     this.set("id", Value.fromString(id));
+
+    this.set("timezone", Value.fromString(""));
+    this.set("rplStaked", Value.fromBigInt(BigInt.zero()));
+    this.set("effectiveRPLStaked", Value.fromBigInt(BigInt.zero()));
+    this.set("totalRPLSlashed", Value.fromBigInt(BigInt.zero()));
+    this.set("totalClaimedRPLRewards", Value.fromBigInt(BigInt.zero()));
+    this.set("minimumRPLNeededForMinipools", Value.fromBigInt(BigInt.zero()));
+    this.set("maximumRPLNeededForMinipools", Value.fromBigInt(BigInt.zero()));
+    this.set("queuedMinipools", Value.fromBigInt(BigInt.zero()));
+    this.set("stakingMinipools", Value.fromBigInt(BigInt.zero()));
+    this.set("stakingUnbondedMinipools", Value.fromBigInt(BigInt.zero()));
+    this.set("withdrawableMinipools", Value.fromBigInt(BigInt.zero()));
+    this.set("totalFinalizedMinipools", Value.fromBigInt(BigInt.zero()));
+    this.set("averageFeeForActiveMinipools", Value.fromBigInt(BigInt.zero()));
+    this.set("minipools", Value.fromStringArray(new Array(0)));
+    this.set("block", Value.fromBigInt(BigInt.zero()));
+    this.set("blockTime", Value.fromBigInt(BigInt.zero()));
   }
 
   save(): void {
@@ -760,6 +777,15 @@ export class Node extends Entity {
     }
   }
 
+  get minipools(): Array<string> {
+    let value = this.get("minipools");
+    return value!.toStringArray();
+  }
+
+  set minipools(value: Array<string>) {
+    this.set("minipools", Value.fromStringArray(value));
+  }
+
   get block(): BigInt {
     let value = this.get("block");
     return value.toBigInt();
@@ -1606,3 +1632,117 @@ export class NodeBalanceCheckpoint extends Entity {
     this.set("blockTime", Value.fromBigInt(value));
   }
 }
+
+export class Minipool extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+
+    this.set("node", Value.fromString(""));
+    this.set("fee", Value.fromBigInt(BigInt.zero()));
+    this.set("queuedBlockTime", Value.fromBigInt(BigInt.zero()));
+    this.set("dequeuedBlockTime", Value.fromBigInt(BigInt.zero()));
+    this.set("destroyedBlockTime", Value.fromBigInt(BigInt.zero()));
+    this.set("stakingBlockTime", Value.fromBigInt(BigInt.zero()));
+    this.set("withdrawableBlockTime", Value.fromBigInt(BigInt.zero()));
+    this.set("finalizedBlockTime", Value.fromBigInt(BigInt.zero()));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save Minipool entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        "Cannot save Minipool entity with non-string ID. " +
+          'Considering using .toHex() to convert the "id" to a string.'
+      );
+      store.set("Minipool", id.toString(), this);
+    }
+  }
+
+  static load(id: string): Minipool | null {
+    return changetype<Minipool | null>(store.get("Minipool", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    return value!.toString();
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+
+  get node(): string {
+    let value = this.get("node");
+    return value!.toString();
+  }
+
+  set node(value: string) {
+    this.set("node", Value.fromString(value));
+  }
+
+  get fee(): BigInt {
+    let value = this.get("fee");
+    return value!.toBigInt();
+  }
+
+  set fee(value: BigInt) {
+    this.set("fee", Value.fromBigInt(value));
+  }
+
+  get queuedBlockTime(): BigInt {
+    let value = this.get("queuedBlockTime");
+    return value!.toBigInt();
+  }
+
+  set queuedBlockTime(value: BigInt) {
+    this.set("queuedBlockTime", Value.fromBigInt(value));
+  }
+
+  get dequeuedBlockTime(): BigInt {
+    let value = this.get("dequeuedBlockTime");
+    return value!.toBigInt();
+  }
+
+  set dequeuedBlockTime(value: BigInt) {
+    this.set("dequeuedBlockTime", Value.fromBigInt(value));
+  }
+
+  get destroyedBlockTime(): BigInt {
+    let value = this.get("destroyedBlockTime");
+    return value!.toBigInt();
+  }
+
+  set destroyedBlockTime(value: BigInt) {
+    this.set("destroyedBlockTime", Value.fromBigInt(value));
+  }
+
+  get stakingBlockTime(): BigInt {
+    let value = this.get("stakingBlockTime");
+    return value!.toBigInt();
+  }
+
+  set stakingBlockTime(value: BigInt) {
+    this.set("stakingBlockTime", Value.fromBigInt(value));
+  }
+
+  get withdrawableBlockTime(): BigInt {
+    let value = this.get("withdrawableBlockTime");
+    return value!.toBigInt();
+  }
+
+  set withdrawableBlockTime(value: BigInt) {
+    this.set("withdrawableBlockTime", Value.fromBigInt(value));
+  }
+
+  get finalizedBlockTime(): BigInt {
+    let value = this.get("finalizedBlockTime");
+    return value!.toBigInt();
+  }
+
+  set finalizedBlockTime(value: BigInt) {
+    this.set("finalizedBlockTime", Value.fromBigInt(value));
+  }
+}

schema.graphql

@@ -195,6 +195,9 @@ type Node @entity {
   # Last node balance checkpoint for this node.
   lastNodeBalanceCheckpoint: NodeBalanceCheckpoint
 
+  # Associated minipools for this node.
+  minipools: [Minipool!]!
+
   # Block number at which this node was first registered with the protocol.
   block: BigInt!
 
@@ -442,4 +445,34 @@ type NodeBalanceCheckpoint @entity {
 
   # Block timestamp that was associated with this checkpoint.
   blockTime: BigInt!
+}
+
+# Entity representing a minipool for a node.
+type Minipool @entity {
+  # Address of the minipool
+  id: ID! 
+
+  # Node that is associated with this minipool
+  node: Node!
+
+  # Fee that is associated with this minipool
+  fee: BigInt! 
+
+  # Block timestamp that was associated with the creation of this minipool.
+  queuedBlockTime: BigInt!
+
+  # Block timestamp that was associated with the dequeue of the minipool that will (most of the time) lead to staking.
+  dequeuedBlockTime: BigInt!
+
+  # Block timestamp that was associated with the destruction of this minipool.
+  destroyedBlockTime: BigInt!
+
+  # Block number that was associated with this minipool transitioning to the staking state.
+  stakingBlockTime: BigInt!
+
+  # Block timestamp that was associated with this minipool being marked as withdrawable.
+  withdrawableBlockTime: BigInt!
+
+  # Block timestamp that was associated with this minipool being marked as finalized.
+  finalizedBlockTime: BigInt!
 }

src/entityfactory.ts

@@ -357,6 +357,28 @@ class RocketPoolEntityFactory {
 
     return checkpoint;
   }
+
+  /**
+   * Attempts to create a new minipool.
+   */
+  public createMinipool(
+    id: string,
+    node: Node,
+    fee: BigInt,
+    blockTime: BigInt) {
+
+      let minipool = new Minipool(id)
+      minipool.node = node.id
+      minipool.fee = fee;
+      minipool.queuedBlockTime = blockTime
+      minipool.dequeuedBlockTime = BigInt.fromI32(0)
+      minipool.destroyedBlockTime = BigInt.fromI32(0)
+      minipool.stakingBlockTime = BigInt.fromI32(0)
+      minipool.withdrawableBlockTime = BigInt.fromI32(0)
+      minipool.finalizedBlockTime = BigInt.fromI32(0)
+  
+      return minipool
+  }
 }
 
 export let rocketPoolEntityFactory = new RocketPoolEntityFactory();

src/mappings/rocketDAONodeTrustedMapping.ts

@@ -0,0 +1,74 @@
+import { BigInt } from '@graphprotocol/graph-ts'
+import { rocketStorage } from '../../generated/rocketDAONodeTrusted/rocketStorage';
+import { DecrementMemberUnbondedValidatorCountCall, IncrementMemberUnbondedValidatorCountCall } from '../../generated/rocketDAONodeTrusted/rocketDAONodeTrusted'
+import { Minipool, Node } from '../../generated/schema'
+import { ROCKET_MINIPOOL_MANAGER_CONTRACT_NAME, ROCKET_STORAGE_ADDRESS } from '../constants/contractconstants';
+import { generalUtilities } from '../utilities/generalUtilities';
+
+/**
+ * Occurs after a trusted node operator creates a minipool, via the RocketMinipoolManager.
+ */
+export function handleIncrementMemberUnbondedValidatorCount(call: IncrementMemberUnbondedValidatorCountCall) : void {
+    // Preliminary null checks.
+    if(call === null || call.from === null || call.inputs === null || call.inputs._nodeAddress === null) return;
+
+    // Calling address should be something.
+    let callingAddress = call.from.toHexString();
+    if(callingAddress == null) return;
+
+    // Calling address should be the rocketMinipoolManager
+    let rocketStorageContract = rocketStorage.bind(ROCKET_STORAGE_ADDRESS);
+    let rocketMinipoolManagerContractAddress = rocketStorageContract.getAddress(generalUtilities.getRocketVaultContractAddressKey(ROCKET_MINIPOOL_MANAGER_CONTRACT_NAME))
+    if (rocketMinipoolManagerContractAddress === null ||
+        rocketMinipoolManagerContractAddress.toHexString() != callingAddress) return
+
+    // Retrieve the parent node. It has to exist.
+    let node = Node.load(call.inputs._nodeAddress.toHexString())
+    if (node === null) return
+ 
+    // TODO: Change naming.
+    // Increment total unbonded minipools
+    node.stakingUnbondedMinipools = node.stakingUnbondedMinipools.plus(BigInt.fromI32(1));
+   
+    // RPL Effective balances don't need to be updated; this will be done in the finalize call of the RocketMiniPoolManager.
+
+    // Index the minipool and the associated node.
+    node.save();     
+}
+
+/**
+ * Occurs after a minipool finalizes his unbonded validator.
+ */
+ export function handleDecrementMemberUnbondedValidatorCount(call: DecrementMemberUnbondedValidatorCountCall) : void {
+    // Preliminary null checks.
+    if(call === null || call.from === null || call.inputs === null || call.inputs._nodeAddress === null) return;
+
+    // Calling address should be something.
+    let callingAddress = call.from.toHexString();
+    if(callingAddress == null) return;
+
+    // There must be a minipool with the same address as the calling address.
+    // If a minipool, it shouldn't be finalized or destroyed.
+    // If a minipool, it should've been queued, staking and set withdrawable before this.
+    let minipool = Minipool.load(callingAddress)
+    if (minipool !== null ||
+        minipool.queuedBlockTime == BigInt.fromI32(0) ||
+        minipool.stakingBlockTime == BigInt.fromI32(0) ||    
+        minipool.withdrawableBlockTime == BigInt.fromI32(0) ||
+        minipool.finalizedBlockTime != BigInt.fromI32(0) || 
+        minipool.destroyedBlockTime != BigInt.fromI32(0)) return
+
+    // Retrieve the parent node. It has to exist.
+    let node = Node.load(call.inputs._nodeAddress.toHexString())
+    if (node === null) return
+ 
+    // TODO: Change naming.
+    // Decrement total unbonded minipools
+    node.stakingUnbondedMinipools = node.stakingUnbondedMinipools.minus(BigInt.fromI32(1));
+    if(node.stakingUnbondedMinipools < BigInt.fromI32(0)) node.stakingUnbondedMinipools = BigInt.fromI32(0);
+
+    // RPL Effective balances don't need to be updated; this will be done in the finalize call of the RocketMiniPoolManager.
+
+    // Index the minipool and the associated node.
+    node.save();     
+}