Implement the TACo API module (#263)

src/agents/coordinator.ts

@@ -1,5 +1,5 @@
-import { SessionStaticKey } from '@nucypher/nucypher-core';
-import { ethers } from 'ethers';
+import { DkgPublicKey, SessionStaticKey } from '@nucypher/nucypher-core';
+import { BigNumberish, ethers } from 'ethers';
 
 import {
  Coordinator,
@@ -13,12 +13,16 @@ import { DEFAULT_WAIT_N_CONFIRMATIONS, getContract } from './contracts';
 
 export interface CoordinatorRitual {
  initiator: string;
- dkgSize: number;
  initTimestamp: number;
+ endTimestamp: number;
  totalTranscripts: number;
  totalAggregations: number;
- publicKey: BLS12381.G1PointStructOutput;
+ authority: string;
+ dkgSize: number;
+ threshold: number;
  aggregationMismatch: boolean;
+ accessController: string;
+ publicKey: BLS12381.G1PointStructOutput;
  aggregatedTranscript: string;
 }
 
@@ -59,10 +63,18 @@ export class DkgCoordinatorAgent {
  public static async initializeRitual(
  provider: ethers.providers.Provider,
  signer: ethers.Signer,
- providers: ChecksumAddress[]
+ providers: ChecksumAddress[],
+ authority: string,
+ duration: BigNumberish,
+ accessController: string
  ): Promise<number> {
  const Coordinator = await this.connectReadWrite(provider, signer);
- const tx = await Coordinator.initiateRitual(providers);
+ const tx = await Coordinator.initiateRitual(
+ providers,
+ authority,
+ duration,
+ accessController
+ );
  const txReceipt = await tx.wait(DEFAULT_WAIT_N_CONFIRMATIONS);
  const [ritualStartEvent] = txReceipt.events ?? [];
  if (!ritualStartEvent) {
@@ -95,16 +107,25 @@ export class DkgCoordinatorAgent {
  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) => {
+ const eventFilter = Coordinator.filters.EndRitual(ritualId, undefined);
+ Coordinator.once(eventFilter, (_ritualId, successful) => {
  callback(successful);
  });
  }
 
+ public static async getRitualIdFromPublicKey(
+ provider: ethers.providers.Provider,
+ dkgPublicKey: DkgPublicKey
+ ): Promise<number> {
+ const Coordinator = await this.connectReadOnly(provider);
+ const dkgPublicKeyBytes = dkgPublicKey.toBytes();
+ const pointStruct: BLS12381.G1PointStruct = {
+ word0: dkgPublicKeyBytes.slice(0, 32),
+ word1: dkgPublicKeyBytes.slice(32, 48),
+ };
+ return await Coordinator.getRitualIdFromPublicKey(pointStruct);
+ }
+
  private static async connectReadOnly(provider: ethers.providers.Provider) {
  return await this.connect(provider);
  }

src/characters/cbd-recipient.ts

@@ -14,7 +14,6 @@ import { ethers } from 'ethers';
 
 import { DkgCoordinatorAgent, DkgParticipant } from '../agents/coordinator';
 import { ConditionContext } from '../conditions';
-import { DkgRitual } from '../dkg';
 import { PorterClient } from '../porter';
 import { fromJSON, objectEquals, toJSON } from '../utils';
 
@@ -31,22 +30,22 @@ export class ThresholdDecrypter {
  private readonly threshold: number
  ) {}
 
- public static create(porterUri: string, dkgRitual: DkgRitual) {
+ public static create(porterUri: string, ritualId: number, threshold: number) {
  return new ThresholdDecrypter(
  new PorterClient(porterUri),
- dkgRitual.id,
- dkgRitual.dkgParams.threshold
+ ritualId,
+ threshold
  );
  }
 
  // Retrieve and decrypt ciphertext using provider and condition expression
  public async retrieveAndDecrypt(
- provider: ethers.providers.Provider,
+ web3Provider: ethers.providers.Provider,
  thresholdMessageKit: ThresholdMessageKit,
  signer?: ethers.Signer
  ): Promise<Uint8Array> {
  const decryptionShares = await this.retrieve(
- provider,
+ web3Provider,
  thresholdMessageKit,
  signer
  );

src/conditions/context/context.ts

@@ -51,7 +51,7 @@ export class ConditionContext {
  );
  if (conditionRequiresSigner && !this.signer) {
  throw new Error(
- `Condition contains ${USER_ADDRESS_PARAM} context variable and requires a signer to populate`
+ `Signer required to satisfy ${USER_ADDRESS_PARAM} context variable in condition`
  );
  }
 

src/dkg.ts

@@ -1,49 +1,49 @@
 import { DkgPublicKey } from '@nucypher/nucypher-core';
-import { ethers } from 'ethers';
+import { BigNumberish, ethers } from 'ethers';
 
 import { DkgCoordinatorAgent, DkgRitualState } from './agents/coordinator';
 import { ChecksumAddress } from './types';
-import { fromHexString, objectEquals } from './utils';
-
-export type DkgRitualParameters = {
- sharesNum: number;
- threshold: number;
-};
+import { fromHexString } from './utils';
 
 export interface DkgRitualJSON {
  id: number;
  dkgPublicKey: Uint8Array;
- dkgParams: DkgRitualParameters;
+ sharesNum: number;
+ threshold: number;
  state: DkgRitualState;
 }
 
 export class DkgRitual {
  constructor(
  public readonly id: number,
  public readonly dkgPublicKey: DkgPublicKey,
- public readonly dkgParams: DkgRitualParameters,
+ public readonly sharesNum: number,
+ public readonly threshold: number,
  public readonly state: DkgRitualState
  ) {}
 
  public toObj(): DkgRitualJSON {
  return {
  id: this.id,
  dkgPublicKey: this.dkgPublicKey.toBytes(),
- dkgParams: this.dkgParams,
+ sharesNum: this.sharesNum,
+ threshold: this.threshold,
  state: this.state,
  };
  }
 
  public static fromObj({
  id,
  dkgPublicKey,
- dkgParams,
+ sharesNum,
+ threshold,
  state,
  }: DkgRitualJSON): DkgRitual {
  return new DkgRitual(
  id,
  DkgPublicKey.fromBytes(dkgPublicKey),
- dkgParams,
+ sharesNum,
+ threshold,
  state
  );
  }
@@ -52,28 +52,30 @@ export class DkgRitual {
  return [
  this.id === other.id,
  this.dkgPublicKey.equals(other.dkgPublicKey),
- objectEquals(this.dkgParams, other.dkgParams),
+ this.sharesNum === other.sharesNum,
+ this.threshold === other.threshold,
  this.state === other.state,
  ].every(Boolean);
  }
 }
 
-// TODO: Currently, we're assuming that the threshold is always `floor(sharesNum / 2) + 1`.
-// https://github.com/nucypher/nucypher/issues/3095
-const assumedThreshold = (sharesNum: number): number =>
- Math.floor(sharesNum / 2) + 1;
-
 export class DkgClient {
  public static async initializeRitual(
  provider: ethers.providers.Provider,
  signer: ethers.Signer,
  ursulas: ChecksumAddress[],
+ authority: string,
+ duration: BigNumberish,
+ accessController: string,
  waitUntilEnd = false
  ): Promise<number | undefined> {
  const ritualId = await DkgCoordinatorAgent.initializeRitual(
  provider,
  signer,
- ursulas.sort()
+ ursulas.sort(),
+ authority,
+ duration,
+ accessController
  );
 
  if (waitUntilEnd) {
@@ -111,7 +113,7 @@ export class DkgClient {
  });
  };
 
- public static async getExistingRitual(
+ public static async getRitual(
  provider: ethers.providers.Provider,
  ritualId: number
  ): Promise<DkgRitual> {
@@ -127,14 +129,25 @@ export class DkgClient {
  return new DkgRitual(
  ritualId,
  DkgPublicKey.fromBytes(dkgPkBytes),
- {
- sharesNum: ritual.dkgSize,
- threshold: assumedThreshold(ritual.dkgSize),
- },
+ ritual.dkgSize,
+ ritual.threshold,
  ritualState
  );
  }
 
+ public static async getFinalizedRitual(
+ provider: ethers.providers.Provider,
+ ritualId: number
+ ): Promise<DkgRitual> {
+ const ritual = await DkgClient.getRitual(provider, ritualId);
+ if (ritual.state !== DkgRitualState.FINALIZED) {
+ throw new Error(
+ `Ritual ${ritualId} is not finalized. State: ${ritual.state}`
+ );
+ }
+ return ritual;
+ }
+
  // TODO: Without Validator public key in Coordinator, we cannot verify the
  // transcript. We need to add it to the Coordinator (nucypher-contracts #77).
  // public async verifyRitual(ritualId: number): Promise<boolean> {

src/sdk/strategy/cbd-strategy.ts

@@ -44,7 +44,7 @@ export class CbdStrategy {
  // // Given that we just initialized the ritual, this should never happen
  // throw new Error('Ritual ID is undefined');
  // }
- const dkgRitual = await DkgClient.getExistingRitual(provider, ritualId);
+ const dkgRitual = await DkgClient.getRitual(provider, ritualId);
  return DeployedCbdStrategy.create(dkgRitual, this.cohort.porterUri);
  }
 
@@ -78,7 +78,11 @@ export class DeployedCbdStrategy {
  ) {}
 
  public static create(dkgRitual: DkgRitual, porterUri: string) {
- const decrypter = ThresholdDecrypter.create(porterUri, dkgRitual);
+ const decrypter = ThresholdDecrypter.create(
+ porterUri,
+ dkgRitual.id,
+ dkgRitual.threshold
+ );
  return new DeployedCbdStrategy(decrypter, dkgRitual.dkgPublicKey);
  }
 
@@ -88,7 +92,7 @@ export class DeployedCbdStrategy {
  porterUri: string,
  ritualId: number
  ): Promise<DeployedCbdStrategy> {
- const dkgRitual = await DkgClient.getExistingRitual(provider, ritualId);
+ const dkgRitual = await DkgClient.getRitual(provider, ritualId);
  return DeployedCbdStrategy.create(dkgRitual, porterUri);
  }
 

src/taco.ts

@@ -0,0 +1,55 @@
+import { DkgPublicKey, ThresholdMessageKit } from '@nucypher/nucypher-core';
+import { ethers } from 'ethers';
+
+import { DkgCoordinatorAgent } from './agents/coordinator';
+import { ThresholdDecrypter } from './characters/cbd-recipient';
+import { Enrico } from './characters/enrico';
+import { Condition, ConditionExpression } from './conditions';
+import { DkgClient } from './dkg';
+import { getPorterUri } from './porter';
+import { toBytes } from './utils';
+
+export const encrypt = async (
+ provider: ethers.providers.Provider,
+ message: string,
+ condition: Condition,
+ ritualId: number
+): Promise<ThresholdMessageKit> => {
+ const dkgRitual = await DkgClient.getFinalizedRitual(provider, ritualId);
+ return await encryptLight(message, condition, dkgRitual.dkgPublicKey);
+};
+
+export const encryptLight = async (
+ message: string,
+ condition: Condition,
+ dkgPublicKey: DkgPublicKey
+): Promise<ThresholdMessageKit> => {
+ const encrypter = new Enrico(dkgPublicKey);
+ const conditionExpr = new ConditionExpression(condition);
+ return encrypter.encryptMessageCbd(toBytes(message), conditionExpr);
+};
+
+export const decrypt = async (
+ provider: ethers.providers.Provider,
+ messageKit: ThresholdMessageKit,
+ signer?: ethers.Signer,
+ porterUri = getPorterUri('tapir')
+): Promise<Uint8Array> => {
+ const ritualId = await DkgCoordinatorAgent.getRitualIdFromPublicKey(
+ provider,
+ messageKit.acp.publicKey
+ );
+ const ritual = await DkgClient.getFinalizedRitual(provider, ritualId);
+ const decrypter = ThresholdDecrypter.create(
+ porterUri,
+ ritualId,
+ ritual.threshold
+ );
+ return decrypter.retrieveAndDecrypt(provider, messageKit, signer);
+};
+
+export const taco = {
+ encrypt,
+ encryptLight,
+ decrypt,
+};