Add ritual initialization to client (#233)

src/agents/coordinator.ts

@@ -1,14 +1,15 @@
-import { SessionStaticKey } from '@nucypher/nucypher-core';
+import { SessionStaticKey, Transcript } from '@nucypher/nucypher-core';
 import { ethers } from 'ethers';
 
 import {
   Coordinator,
   Coordinator__factory,
 } from '../../types/ethers-contracts';
 import { BLS12381 } from '../../types/ethers-contracts/Coordinator';
+import { ChecksumAddress } from '../types';
 import { fromHexString } from '../utils';
 
-import { getContract } from './contracts';
+import { DEFAULT_WAIT_N_CONFIRMATIONS, getContract } from './contracts';
 
 export interface CoordinatorRitual {
   initiator: string;
@@ -24,12 +25,22 @@ export interface CoordinatorRitual {
 export type DkgParticipant = {
   provider: string;
   aggregated: boolean;
+  transcript: Transcript;
   decryptionRequestStaticKey: SessionStaticKey;
 };
 
+export enum DkgRitualState {
+  NON_INITIATED,
+  AWAITING_TRANSCRIPTS,
+  AWAITING_AGGREGATIONS,
+  TIMEOUT,
+  INVALID,
+  FINALIZED,
+}
+
 export class DkgCoordinatorAgent {
   public static async getParticipants(
-    provider: ethers.providers.Provider,
+    provider: ethers.providers.Web3Provider,
     ritualId: number
   ): Promise<DkgParticipant[]> {
     const Coordinator = await this.connectReadOnly(provider);
@@ -39,27 +50,76 @@ export class DkgCoordinatorAgent {
       return {
         provider: participant.provider,
         aggregated: participant.aggregated,
+        transcript: Transcript.fromBytes(fromHexString(participant.transcript)),
         decryptionRequestStaticKey: SessionStaticKey.fromBytes(
           fromHexString(participant.decryptionRequestStaticKey)
         ),
       };
     });
   }
 
+  public static async initializeRitual(
+    provider: ethers.providers.Web3Provider,
+    providers: ChecksumAddress[]
+  ): Promise<number> {
+    const Coordinator = await this.connectReadWrite(provider);
+    const tx = await Coordinator.initiateRitual(providers);
+    const txReceipt = await tx.wait(DEFAULT_WAIT_N_CONFIRMATIONS);
+    const [ritualStartEvent] = txReceipt.events ?? [];
+    if (!ritualStartEvent) {
+      throw new Error('Ritual start event not found');
+    }
+    return ritualStartEvent.args?.ritualId;
+  }
+
   public static async getRitual(
-    provider: ethers.providers.Provider,
+    provider: ethers.providers.Web3Provider,
     ritualId: number
   ): Promise<CoordinatorRitual> {
     const Coordinator = await this.connectReadOnly(provider);
     return Coordinator.rituals(ritualId);
   }
 
-  private static async connectReadOnly(provider: ethers.providers.Provider) {
+  public static async getRitualState(
+    provider: ethers.providers.Web3Provider,
+    ritualId: number
+  ): Promise<DkgRitualState> {
+    const Coordinator = await this.connectReadOnly(provider);
+    return await Coordinator.getRitualState(ritualId);
+  }
+
+  public static async onRitualEndEvent(
+    provider: ethers.providers.Web3Provider,
+    ritualId: number,
+    callback: (successful: boolean) => void
+  ): Promise<void> {
+    const Coordinator = await this.connectReadOnly(provider);
+    // We leave `initiator` undefined because we don't care who the initiator is
+    // We leave `successful` undefined because we don't care if the ritual was successful
+    const eventFilter = Coordinator.filters.EndRitual(
+      ritualId,
+      undefined,
+      undefined
+    );
+    Coordinator.once(eventFilter, (_ritualId, _initiator, successful) => {
+      callback(successful);
+    });
+  }
+
+  private static async connectReadOnly(
+    provider: ethers.providers.Web3Provider
+  ) {
     return await this.connect(provider);
   }
 
+  private static async connectReadWrite(
+    web3Provider: ethers.providers.Web3Provider
+  ) {
+    return await this.connect(web3Provider, web3Provider.getSigner());
+  }
+
   private static async connect(
-    provider: ethers.providers.Provider,
+    provider: ethers.providers.Web3Provider,
     signer?: ethers.providers.JsonRpcSigner
   ): Promise<Coordinator> {
     const network = await provider.getNetwork();

src/agents/subscription-manager.ts

@@ -48,7 +48,7 @@ export class PreSubscriptionManagerAgent {
   }
 
   public static async getPolicyCost(
-    provider: ethers.providers.Provider,
+    provider: ethers.providers.Web3Provider,
     size: number,
     startTimestamp: number,
     endTimestamp: number
@@ -61,7 +61,9 @@ export class PreSubscriptionManagerAgent {
     );
   }
 
-  private static async connectReadOnly(provider: ethers.providers.Provider) {
+  private static async connectReadOnly(
+    provider: ethers.providers.Web3Provider
+  ) {
     return await this.connect(provider);
   }
 
@@ -72,7 +74,7 @@ export class PreSubscriptionManagerAgent {
   }
 
   private static async connect(
-    provider: ethers.providers.Provider,
+    provider: ethers.providers.Web3Provider,
     signer?: ethers.providers.JsonRpcSigner
   ): Promise<SubscriptionManager> {
     const network = await provider.getNetwork();

src/characters/cbd-recipient.ts

@@ -12,9 +12,14 @@ import {
 } from '@nucypher/nucypher-core';
 import { ethers } from 'ethers';
 
-import { DkgCoordinatorAgent, DkgParticipant } from '../agents/coordinator';
+import {
+  DkgCoordinatorAgent,
+  DkgParticipant,
+  DkgRitualState,
+} from '../agents/coordinator';
 import { ConditionExpression } from '../conditions';
 import {
+  DkgClient,
   DkgRitual,
   FerveoVariant,
   getCombineDecryptionSharesFunction,
@@ -43,7 +48,7 @@ export class CbdTDecDecrypter {
     return new CbdTDecDecrypter(
       new Porter(porterUri),
       dkgRitual.id,
-      dkgRitual.threshold
+      dkgRitual.dkgParams.threshold
     );
   }
 
@@ -52,13 +57,15 @@ export class CbdTDecDecrypter {
     provider: ethers.providers.Web3Provider,
     conditionExpr: ConditionExpression,
     variant: FerveoVariant,
-    ciphertext: Ciphertext
+    ciphertext: Ciphertext,
+    verifyRitual = true
   ): Promise<Uint8Array> {
     const decryptionShares = await this.retrieve(
       provider,
       conditionExpr,
       variant,
-      ciphertext
+      ciphertext,
+      verifyRitual
     );
 
     const combineDecryptionSharesFn =
@@ -73,16 +80,39 @@ export class CbdTDecDecrypter {
 
   // Retrieve decryption shares
   public async retrieve(
-    provider: ethers.providers.Web3Provider,
+    web3Provider: ethers.providers.Web3Provider,
     conditionExpr: ConditionExpression,
     variant: number,
-    ciphertext: Ciphertext
+    ciphertext: Ciphertext,
+    verifyRitual = true
   ): Promise<DecryptionSharePrecomputed[] | DecryptionShareSimple[]> {
+    const ritualState = await DkgCoordinatorAgent.getRitualState(
+      web3Provider,
+      this.ritualId
+    );
+    if (ritualState !== DkgRitualState.FINALIZED) {
+      throw new Error(
+        `Ritual with id ${this.ritualId} is not finalized. Ritual state is ${ritualState}.`
+      );
+    }
+
+    if (verifyRitual) {
+      const isLocallyVerified = await DkgClient.verifyRitual(
+        web3Provider,
+        this.ritualId
+      );
+      if (!isLocallyVerified) {
+        throw new Error(
+          `Ritual with id ${this.ritualId} has failed local verification.`
+        );
+      }
+    }
+
     const dkgParticipants = await DkgCoordinatorAgent.getParticipants(
-      provider,
+      web3Provider,
       this.ritualId
     );
-    const contextStr = await conditionExpr.buildContext(provider).toJson();
+    const contextStr = await conditionExpr.buildContext(web3Provider).toJson();
     const { sharedSecrets, encryptedRequests } = this.makeDecryptionRequests(
       this.ritualId,
       variant,