feat!: replace variant parameter with a default simple variant

Author: piotr-roslaniec

src/characters/cbd-recipient.ts

@@ -1,7 +1,7 @@
 import {
   Ciphertext,
+  combineDecryptionSharesSimple,
   Context,
-  DecryptionSharePrecomputed,
   DecryptionShareSimple,
   decryptWithSharedSecret,
   EncryptedThresholdDecryptionRequest,
@@ -15,11 +15,7 @@ import { ethers } from 'ethers';
 
 import { DkgCoordinatorAgent, DkgParticipant } from '../agents/coordinator';
 import { ConditionExpression } from '../conditions';
-import {
-  DkgRitual,
-  getCombineDecryptionSharesFunction,
-  getVariantClass,
-} from '../dkg';
+import { DkgRitual } from '../dkg';
 import { PorterClient } from '../porter';
 import { fromJSON, toJSON } from '../utils';
 
@@ -50,19 +46,15 @@ export class ThresholdDecrypter {
   public async retrieveAndDecrypt(
     provider: ethers.providers.Web3Provider,
     conditionExpr: ConditionExpression,
-    variant: FerveoVariant,
     ciphertext: Ciphertext
   ): Promise<Uint8Array> {
     const decryptionShares = await this.retrieve(
       provider,
       conditionExpr,
-      variant,
       ciphertext
     );
 
-    const combineDecryptionSharesFn =
-      getCombineDecryptionSharesFunction(variant);
-    const sharedSecret = combineDecryptionSharesFn(decryptionShares);
+    const sharedSecret = combineDecryptionSharesSimple(decryptionShares);
     return decryptWithSharedSecret(
       ciphertext,
       conditionExpr.asAad(),
@@ -74,17 +66,15 @@ export class ThresholdDecrypter {
   public async retrieve(
     provider: ethers.providers.Web3Provider,
     conditionExpr: ConditionExpression,
-    variant: FerveoVariant,
     ciphertext: Ciphertext
-  ): Promise<DecryptionSharePrecomputed[] | DecryptionShareSimple[]> {
+  ): Promise<DecryptionShareSimple[]> {
     const dkgParticipants = await DkgCoordinatorAgent.getParticipants(
       provider,
       this.ritualId
     );
     const contextStr = await conditionExpr.buildContext(provider).toJson();
     const { sharedSecrets, encryptedRequests } = this.makeDecryptionRequests(
       this.ritualId,
-      variant,
       ciphertext,
       conditionExpr,
       contextStr,
@@ -106,15 +96,13 @@ export class ThresholdDecrypter {
     return this.makeDecryptionShares(
       encryptedResponses,
       sharedSecrets,
-      variant,
       this.ritualId
     );
   }
 
   private makeDecryptionShares(
     encryptedResponses: Record<string, EncryptedThresholdDecryptionResponse>,
     sessionSharedSecret: Record<string, SessionSharedSecret>,
-    variant: FerveoVariant,
     expectedRitualId: number
   ) {
     const decryptedResponses = Object.entries(encryptedResponses).map(
@@ -128,19 +116,13 @@ export class ThresholdDecrypter {
       );
     }
 
-    const decryptionShares = decryptedResponses.map(
-      ({ decryptionShare }) => decryptionShare
-    );
-
-    const DecryptionShareType = getVariantClass(variant);
-    return decryptionShares.map((share) =>
-      DecryptionShareType.fromBytes(share)
+    return decryptedResponses.map(({ decryptionShare }) =>
+      DecryptionShareSimple.fromBytes(decryptionShare)
     );
   }
 
   private makeDecryptionRequests(
     ritualId: number,
-    variant: FerveoVariant,
     ciphertext: Ciphertext,
     conditionExpr: ConditionExpression,
     contextStr: string,
@@ -151,7 +133,7 @@ export class ThresholdDecrypter {
   } {
     const decryptionRequest = new ThresholdDecryptionRequest(
       ritualId,
-      variant,
+      FerveoVariant.simple,
       ciphertext,
       conditionExpr.toWASMConditions(),
       new Context(contextStr)

src/dkg.ts

@@ -1,44 +1,10 @@
-import {
-  combineDecryptionSharesPrecomputed,
-  combineDecryptionSharesSimple,
-  DecryptionSharePrecomputed,
-  DecryptionShareSimple,
-  DkgPublicKey,
-  FerveoVariant,
-  SharedSecret,
-} from '@nucypher/nucypher-core';
+import { DkgPublicKey } from '@nucypher/nucypher-core';
 import { ethers } from 'ethers';
 
 import { DkgCoordinatorAgent, DkgRitualState } from './agents/coordinator';
 import { ChecksumAddress } from './types';
 import { fromHexString, objectEquals } from './utils';
 
-export function getVariantClass(
-  variant: FerveoVariant
-): typeof DecryptionShareSimple | typeof DecryptionSharePrecomputed {
-  if (variant.equals(FerveoVariant.simple)) {
-    return DecryptionShareSimple;
-  } else if (variant.equals(FerveoVariant.precomputed)) {
-    return DecryptionSharePrecomputed;
-  } else {
-    throw new Error(`Invalid FerveoVariant: ${variant}`);
-  }
-}
-
-export function getCombineDecryptionSharesFunction(
-  variant: FerveoVariant
-): (
-  shares: DecryptionShareSimple[] | DecryptionSharePrecomputed[]
-) => SharedSecret {
-  if (variant.equals(FerveoVariant.simple)) {
-    return combineDecryptionSharesSimple;
-  } else if (variant.equals(FerveoVariant.precomputed)) {
-    return combineDecryptionSharesPrecomputed;
-  } else {
-    throw new Error(`Invalid FerveoVariant: ${variant}`);
-  }
-}
-
 export type DkgRitualParameters = {
   sharesNum: number;
   threshold: number;

test/unit/cbd-strategy.test.ts

@@ -112,7 +112,6 @@ describe('CbdDeployedStrategy', () => {
     // Setup mocks for `retrieveAndDecrypt`
     const { decryptionShares } = fakeTDecFlow({
       ...mockedDkg,
-      variant,
       message: toBytes(message),
       aad,
       ciphertext,
@@ -136,7 +135,6 @@ describe('CbdDeployedStrategy', () => {
       await deployedStrategy.decrypter.retrieveAndDecrypt(
         aliceProvider,
         conditionExpr,
-        variant,
         ciphertext
       );
     expect(getUrsulasSpy).toHaveBeenCalled();

test/utils.ts

@@ -8,7 +8,6 @@ import {
   Capsule,
   CapsuleFrag,
   Ciphertext,
-  combineDecryptionSharesPrecomputed,
   combineDecryptionSharesSimple,
   DecryptionSharePrecomputed,
   DecryptionShareSimple,
@@ -287,7 +286,6 @@ interface FakeDkgRitualFlow {
   sharesNum: number;
   threshold: number;
   receivedMessages: ValidatorMessage[];
-  variant: FerveoVariant;
   ciphertext: Ciphertext;
   aad: Uint8Array;
   dkg: Dkg;
@@ -301,7 +299,6 @@ export const fakeTDecFlow = ({
   sharesNum,
   threshold,
   receivedMessages,
-  variant,
   ciphertext,
   aad,
   message,
@@ -319,38 +316,18 @@ export const fakeTDecFlow = ({
       throw new Error('Transcript is invalid');
     }
 
-    let decryptionShare;
-    if (variant.equals(FerveoVariant.precomputed)) {
-      decryptionShare = aggregate.createDecryptionSharePrecomputed(
-        dkg,
-        ciphertext,
-        aad,
-        keypair
-      );
-    } else if (variant.equals(FerveoVariant.simple)) {
-      decryptionShare = aggregate.createDecryptionShareSimple(
-        dkg,
-        ciphertext,
-        aad,
-        keypair
-      );
-    } else {
-      throw new Error(`Invalid variant: ${variant}`);
-    }
+    const decryptionShare = aggregate.createDecryptionShareSimple(
+      dkg,
+      ciphertext,
+      aad,
+      keypair
+    );
     decryptionShares.push(decryptionShare);
   });
 
   // Now, the decryption share can be used to decrypt the ciphertext
   // This part is in the client API
-
-  let sharedSecret;
-  if (variant.equals(FerveoVariant.precomputed)) {
-    sharedSecret = combineDecryptionSharesPrecomputed(decryptionShares);
-  } else if (variant.equals(FerveoVariant.simple)) {
-    sharedSecret = combineDecryptionSharesSimple(decryptionShares);
-  } else {
-    throw new Error(`Invalid variant: ${variant}`);
-  }
+  const sharedSecret = combineDecryptionSharesSimple(decryptionShares);
 
   // The client should have access to the public parameters of the DKG
   const plaintext = decryptWithSharedSecret(ciphertext, aad, sharedSecret);
@@ -374,7 +351,6 @@ export const fakeDkgTDecFlowE2e = (
   const ciphertext = ferveoEncrypt(message, aad, ritual.dkg.publicKey());
   const { decryptionShares } = fakeTDecFlow({
     ...ritual,
-    variant,
     ciphertext,
     aad,
     message,