Merge pull request #5172 from connext/handle_hub_domain_events

feat: handle hub domain events

Author: wanglonghong

packages/adapters/subgraph/.graphclient/index.ts

@@ -393,6 +393,39 @@ enum staginggoerli_GnosisConnectorMeta_orderBy {
   mirrorConnector
 }
 
+type staginggoerli_HubDomain {
+  id: ID!
+  domain: BigInt
+}
+
+input staginggoerli_HubDomain_filter {
+  id: ID
+  id_not: ID
+  id_gt: ID
+  id_lt: ID
+  id_gte: ID
+  id_lte: ID
+  id_in: [ID!]
+  id_not_in: [ID!]
+  domain: BigInt
+  domain_not: BigInt
+  domain_gt: BigInt
+  domain_lt: BigInt
+  domain_gte: BigInt
+  domain_lte: BigInt
+  domain_in: [BigInt!]
+  domain_not_in: [BigInt!]
+  """Filter for the block changed event."""
+  _change_block: staginggoerli_BlockChangedFilter
+  and: [staginggoerli_HubDomain_filter]
+  or: [staginggoerli_HubDomain_filter]
+}
+
+enum staginggoerli_HubDomain_orderBy {
+  id
+  domain
+}
+
 type staginggoerli_HubOptimisticRootFinalized {
   id: ID!
   aggregateRoot: staginggoerli_Bytes!
@@ -1195,6 +1228,32 @@ type Query {
     """
     subgraphError: _SubgraphErrorPolicy_! = deny
   ): [staginggoerli_AggregateRootSavedSlow!]!
+  staginggoerli_hubDomain(
+    id: ID!
+    """
+    The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.
+    """
+    block: staginggoerli_Block_height
+    """
+    Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.
+    """
+    subgraphError: _SubgraphErrorPolicy_! = deny
+  ): staginggoerli_HubDomain
+  staginggoerli_hubDomains(
+    skip: Int = 0
+    first: Int = 100
+    orderBy: staginggoerli_HubDomain_orderBy
+    orderDirection: staginggoerli_OrderDirection
+    where: staginggoerli_HubDomain_filter
+    """
+    The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.
+    """
+    block: staginggoerli_Block_height
+    """
+    Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.
+    """
+    subgraphError: _SubgraphErrorPolicy_! = deny
+  ): [staginggoerli_HubDomain!]!
   """Access to subgraph metadata"""
   staginggoerli__meta(block: staginggoerli_Block_height): staginggoerli__Meta_
 }
@@ -1941,6 +2000,32 @@ type Subscription {
     """
     subgraphError: _SubgraphErrorPolicy_! = deny
   ): [staginggoerli_AggregateRootSavedSlow!]!
+  staginggoerli_hubDomain(
+    id: ID!
+    """
+    The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.
+    """
+    block: staginggoerli_Block_height
+    """
+    Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.
+    """
+    subgraphError: _SubgraphErrorPolicy_! = deny
+  ): staginggoerli_HubDomain
+  staginggoerli_hubDomains(
+    skip: Int = 0
+    first: Int = 100
+    orderBy: staginggoerli_HubDomain_orderBy
+    orderDirection: staginggoerli_OrderDirection
+    where: staginggoerli_HubDomain_filter
+    """
+    The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.
+    """
+    block: staginggoerli_Block_height
+    """
+    Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.
+    """
+    subgraphError: _SubgraphErrorPolicy_! = deny
+  ): [staginggoerli_HubDomain!]!
   """Access to subgraph metadata"""
   staginggoerli__meta(block: staginggoerli_Block_height): staginggoerli__Meta_
 }

packages/adapters/subgraph/.graphclient/schema.graphql

@@ -392,6 +392,38 @@ export type staginggoerli_GnosisConnectorMeta_orderBy =
   | 'rootManager'
   | 'mirrorConnector';
 
+export type staginggoerli_HubDomain = {
+  id: Scalars['ID'];
+  domain?: Maybe<Scalars['BigInt']>;
+};
+
+export type staginggoerli_HubDomain_filter = {
+  id?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  domain?: InputMaybe<Scalars['BigInt']>;
+  domain_not?: InputMaybe<Scalars['BigInt']>;
+  domain_gt?: InputMaybe<Scalars['BigInt']>;
+  domain_lt?: InputMaybe<Scalars['BigInt']>;
+  domain_gte?: InputMaybe<Scalars['BigInt']>;
+  domain_lte?: InputMaybe<Scalars['BigInt']>;
+  domain_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  domain_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<staginggoerli_BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<staginggoerli_HubDomain_filter>>>;
+  or?: InputMaybe<Array<InputMaybe<staginggoerli_HubDomain_filter>>>;
+};
+
+export type staginggoerli_HubDomain_orderBy =
+  | 'id'
+  | 'domain';
+
 export type staginggoerli_HubOptimisticRootFinalized = {
   id: Scalars['ID'];
   aggregateRoot: Scalars['staginggoerli_Bytes'];
@@ -798,6 +830,8 @@ export type Query = {
   staginggoerli_rootMessageProcesseds: Array<staginggoerli_RootMessageProcessed>;
   staginggoerli_aggregateRootSavedSlow?: Maybe<staginggoerli_AggregateRootSavedSlow>;
   staginggoerli_aggregateRootSavedSlows: Array<staginggoerli_AggregateRootSavedSlow>;
+  staginggoerli_hubDomain?: Maybe<staginggoerli_HubDomain>;
+  staginggoerli_hubDomains: Array<staginggoerli_HubDomain>;
   /** Access to subgraph metadata */
   staginggoerli__meta?: Maybe<staginggoerli__Meta_>;
 };
@@ -1091,6 +1125,24 @@ export type Querystaginggoerli_aggregateRootSavedSlowsArgs = {
 };
 
 
+export type Querystaginggoerli_hubDomainArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<staginggoerli_Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type Querystaginggoerli_hubDomainsArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<staginggoerli_HubDomain_orderBy>;
+  orderDirection?: InputMaybe<staginggoerli_OrderDirection>;
+  where?: InputMaybe<staginggoerli_HubDomain_filter>;
+  block?: InputMaybe<staginggoerli_Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
 export type Querystaginggoerli__metaArgs = {
   block?: InputMaybe<staginggoerli_Block_height>;
 };
@@ -1448,6 +1500,8 @@ export type Subscription = {
   staginggoerli_rootMessageProcesseds: Array<staginggoerli_RootMessageProcessed>;
   staginggoerli_aggregateRootSavedSlow?: Maybe<staginggoerli_AggregateRootSavedSlow>;
   staginggoerli_aggregateRootSavedSlows: Array<staginggoerli_AggregateRootSavedSlow>;
+  staginggoerli_hubDomain?: Maybe<staginggoerli_HubDomain>;
+  staginggoerli_hubDomains: Array<staginggoerli_HubDomain>;
   /** Access to subgraph metadata */
   staginggoerli__meta?: Maybe<staginggoerli__Meta_>;
 };
@@ -1741,6 +1795,24 @@ export type Subscriptionstaginggoerli_aggregateRootSavedSlowsArgs = {
 };
 
 
+export type Subscriptionstaginggoerli_hubDomainArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<staginggoerli_Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type Subscriptionstaginggoerli_hubDomainsArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<staginggoerli_HubDomain_orderBy>;
+  orderDirection?: InputMaybe<staginggoerli_OrderDirection>;
+  where?: InputMaybe<staginggoerli_HubDomain_filter>;
+  block?: InputMaybe<staginggoerli_Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
 export type Subscriptionstaginggoerli__metaArgs = {
   block?: InputMaybe<staginggoerli_Block_height>;
 };
@@ -1919,6 +1991,10 @@ export type _SubgraphErrorPolicy_ =
   staginggoerli_aggregateRootSavedSlow: InContextSdkMethod<Query['staginggoerli_aggregateRootSavedSlow'], Querystaginggoerli_aggregateRootSavedSlowArgs, MeshContext>,
   /** null **/
   staginggoerli_aggregateRootSavedSlows: InContextSdkMethod<Query['staginggoerli_aggregateRootSavedSlows'], Querystaginggoerli_aggregateRootSavedSlowsArgs, MeshContext>,
+  /** null **/
+  staginggoerli_hubDomain: InContextSdkMethod<Query['staginggoerli_hubDomain'], Querystaginggoerli_hubDomainArgs, MeshContext>,
+  /** null **/
+  staginggoerli_hubDomains: InContextSdkMethod<Query['staginggoerli_hubDomains'], Querystaginggoerli_hubDomainsArgs, MeshContext>,
   /** Access to subgraph metadata **/
   staginggoerli__meta: InContextSdkMethod<Query['staginggoerli__meta'], Querystaginggoerli__metaArgs, MeshContext>
   };
@@ -1992,6 +2068,10 @@ export type _SubgraphErrorPolicy_ =
   staginggoerli_aggregateRootSavedSlow: InContextSdkMethod<Subscription['staginggoerli_aggregateRootSavedSlow'], Subscriptionstaginggoerli_aggregateRootSavedSlowArgs, MeshContext>,
   /** null **/
   staginggoerli_aggregateRootSavedSlows: InContextSdkMethod<Subscription['staginggoerli_aggregateRootSavedSlows'], Subscriptionstaginggoerli_aggregateRootSavedSlowsArgs, MeshContext>,
+  /** null **/
+  staginggoerli_hubDomain: InContextSdkMethod<Subscription['staginggoerli_hubDomain'], Subscriptionstaginggoerli_hubDomainArgs, MeshContext>,
+  /** null **/
+  staginggoerli_hubDomains: InContextSdkMethod<Subscription['staginggoerli_hubDomains'], Subscriptionstaginggoerli_hubDomainsArgs, MeshContext>,
   /** Access to subgraph metadata **/
   staginggoerli__meta: InContextSdkMethod<Subscription['staginggoerli__meta'], Subscriptionstaginggoerli__metaArgs, MeshContext>
   };

packages/adapters/subgraph/.graphclient/sources/Hub_Staging_Goerli/introspectionSchema.ts

@@ -11,6 +11,8 @@ import {
   OptimisticModeActivated as OptimisticModeActivatedEvent,
   AggregateRootSavedOptimistic as AggregateRootSavedOptimisticEvent,
   AggregateRootSavedSlow as AggregateRootSavedSlowEvent,
+  HubDomainSet,
+  HubDomainCleared,
 } from "../../../generated/RootManager/RootManager";
 
 import {
@@ -21,12 +23,15 @@ import {
   OptimisticRootProposed,
   HubOptimisticRootFinalized,
   AggregateRootSavedSlow,
+  HubDomain,
 } from "../../../generated/schema";
 
 const ROOT_MANAGER_META_ID = "ROOT_MANAGER_META_ID";
 const ROOT_MANAGER_MODE_ID = "ROOT_MANAGER_MODE_ID";
+const HUB_DOMAIN_ID = "HUB_DOMAIN_ID";
 const OPTIMISTIC_MODE = "OPTIMISTIC_MODE";
 const SLOW_MODE = "SLOW_MODE";
+const DEFUALT_HUB_DOMAIN = 0;
 
 /// MARK - ROOT MANAGER
 // TODO: Needed?
@@ -146,3 +151,19 @@ export function handleOptimisticModeActivated(event: OptimisticModeActivatedEven
 
   instance.save();
 }
+
+export function handleHubDomainSet(event: HubDomainSet): void {
+  let instance = HubDomain.load(HUB_DOMAIN_ID);
+  if (instance == null) {
+    instance = new HubDomain(HUB_DOMAIN_ID);
+  }
+
+  instance.domain = event.params.domain;
+
+  instance.save();
+}
+
+export function handleHubDomainCleared(event: HubDomainCleared): void {
+  const instance = new HubDomain(HUB_DOMAIN_ID);
+  instance.save();
+}

packages/adapters/subgraph/.graphclient/sources/Hub_Staging_Goerli/schema.graphql

@@ -149,3 +149,8 @@ type AggregateRootSavedSlow @entity {
   aggregatedRoots: [Bytes!]
   rootTimestamp: BigInt!
 }
+
+type HubDomain @entity {
+  id: ID! # "HUB_DOMAIN_ID"
+  domain: BigInt
+}

packages/adapters/subgraph/.graphclient/sources/Hub_Staging_Goerli/types.ts

@@ -43,6 +43,10 @@ dataSources:
           handler: handleAggregateRootSavedOptimistic
         - event: AggregateRootSavedSlow(indexed bytes32,uint256,bytes32[],uint256)
           handler: handleAggregateRootSavedSlow
+        - event: HubDomainSet(uint32)
+          handler: handleHubDomainSet
+        - event: HubDomainCleared()
+          handler: handleHubDomainCleared
       file: ./src/amarok-hub-staging/mapping/rootManager.ts
   # MERKLE TREE MANAGER events
   - kind: ethereum/contract