@did-btcr2/method 0.13.1

package/src/bitcoin/taproot.ts

@@ -0,0 +1,237 @@
+import * as tinysecp from 'tiny-secp256k1';
+import { payments, script, opcodes } from 'bitcoinjs-lib';
+import { PublicKey } from '@did-btcr2/keypair';
+
+/**
+ * Aggregate an array of public keys by point addition
+ */
+function aggregatePubkeys(pubkeys: Uint8Array[]): Uint8Array {
+  if (pubkeys.length === 1) return pubkeys[0];
+  return pubkeys.reduce((sum: Uint8Array, pk: Uint8Array) => {
+    const added = tinysecp.pointAdd(sum, pk);
+    if (!added) throw new Error('Point addition failed');
+    return added;
+  }, pubkeys[0]);
+}
+
+/**
+ * Build a P2TR script leaf for a k-of-n multisig with optional locktime/sequence
+ */
+function buildTapLeafScript(
+  pubkeys: Uint8Array[],
+  k: number,
+  locktime?: number,
+  sequence?: number
+): Uint8Array {
+  const ops: (Uint8Array | number)[] = [];
+
+  // absolute timelock
+  if (locktime !== undefined) {
+    ops.push(script.number.encode(locktime));
+    ops.push(opcodes.OP_CHECKLOCKTIMEVERIFY);
+    ops.push(opcodes.OP_DROP);
+  }
+  // relative timelock
+  if (sequence !== undefined) {
+    ops.push(script.number.encode(sequence));
+    ops.push(opcodes.OP_CHECKSEQUENCEVERIFY);
+    ops.push(opcodes.OP_DROP);
+  }
+
+  // push each key as x-only pubkey
+  for (const pk of pubkeys) {
+    const [xOnly] = PublicKey.xOnly(pk);
+    ops.push(xOnly);
+  }
+  // push threshold k and total keys n
+  ops.push(script.number.encode(k));
+  ops.push(script.number.encode(pubkeys.length));
+  ops.push(opcodes.OP_CHECKMULTISIG);
+
+  return script.compile(ops);
+}
+
+/**
+ * Build a P2TR script leaf for a aggregated MuSig key (key-path only)
+ */
+function buildMusigLeafScript(pubkeys: Uint8Array[]): Uint8Array {
+  const agg = aggregatePubkeys(pubkeys);
+  const [xOnly] = PublicKey.xOnly(agg);
+  // In a taproot script path, OP_CHECKSIG runs schnorr
+  return script.compile([xOnly, opcodes.OP_CHECKSIG]);
+}
+
+/**
+ * Recursively combine an array of leaves into a balanced Merkle tree structure
+ */
+function buildMerkleTree(nodes: Uint8Array[]): any {
+  if (nodes.length === 1) return { output: nodes[0] };
+  const next: any[] = [];
+  for (let i = 0; i < nodes.length; i += 2) {
+    if (i + 1 === nodes.length) {
+      next.push({ output: nodes[i] });
+    } else {
+      next.push([
+        { output: nodes[i] },
+        { output: nodes[i + 1] },
+      ]);
+    }
+  }
+  return buildMerkleTree(next);
+}
+
+/**
+ * Generate combinations of length k from an array
+ */
+function* combinations<T>(array: T[], k: number): Generator<T[]> {
+  const n = array.length;
+  if (k > n || k < 0) return;
+  const indices = Array.from({ length: k }, (_, i) => i);
+  while (true) {
+    yield indices.map(i => array[i]!);
+    let i = k - 1;
+    while (i >= 0 && indices[i] === i + n - k) {
+      i--;
+    }
+    if (i < 0) break;
+    indices[i]++;
+    for (let j = i + 1; j < k; j++) {
+      indices[j] = indices[j - 1] + 1;
+    }
+  }
+}
+
+/**
+ * TapRootMultiSig: builds Taproot outputs and trees for multisig and MuSig branches
+ */
+export class TapRootMultiSig {
+  public readonly points: Uint8Array[];
+  public readonly k: number;
+  public readonly defaultInternalPubkey: Uint8Array;
+
+  constructor(points: Uint8Array[], k: number) {
+    if (points.length < k || k < 1) {
+      throw new Error(`${k} is invalid for ${points.length} keys`);
+    }
+    this.points = points;
+    this.k = k;
+    // MuSig aggregation for default internal key
+    this.defaultInternalPubkey = aggregatePubkeys(points);
+  }
+
+  /**
+   * Single multisig leaf as the only script path
+   */
+  singleLeaf(locktime?: number, sequence?: number) {
+    const leaf = buildTapLeafScript(this.points, this.k, locktime, sequence);
+    return payments.p2tr({
+      internalPubkey : this.defaultInternalPubkey,
+      scriptTree     : { output: leaf },
+    });
+  }
+
+  /**
+   * All k-of-n multisig combinations as separate leaf scripts, combined into one tree
+   */
+  multiLeafTree(locktime?: number, sequence?: number) {
+    const leaves: Uint8Array[] = [];
+    for (const combo of combinations(this.points, this.k)) {
+      leaves.push(buildTapLeafScript(combo, this.k, locktime, sequence));
+    }
+    const tree = buildMerkleTree(leaves);
+    return payments.p2tr({
+      internalPubkey : this.defaultInternalPubkey,
+      scriptTree     : tree,
+    });
+  }
+
+  /**
+   * MuSig key-path scripts for each k-of-n combination in the script tree
+   */
+  musigTree() {
+    const leaves: Uint8Array[] = [];
+    for (const combo of combinations(this.points, this.k)) {
+      leaves.push(buildMusigLeafScript(combo));
+    }
+    const tree = buildMerkleTree(leaves);
+    return payments.p2tr({
+      internalPubkey : this.defaultInternalPubkey,
+      scriptTree     : tree,
+    });
+  }
+
+  /**
+   * A two-branch tree: one branch is the singleLeaf script, the other is the muSig tree
+   */
+  musigAndSingleLeafTree(locktime?: number, sequence?: number) {
+    const single = buildTapLeafScript(this.points, this.k, locktime, sequence);
+    const musigLeaves: Uint8Array[] = [];
+    for (const combo of combinations(this.points, this.k)) {
+      musigLeaves.push(buildMusigLeafScript(combo));
+    }
+    const tree = {
+      output     : single,
+      scriptTree : buildMerkleTree(musigLeaves),
+    };
+    return payments.p2tr({
+      internalPubkey : this.defaultInternalPubkey,
+      scriptTree     : tree,
+    });
+  }
+
+  /**
+   * Nested tree of singleLeaf, multiLeafTree, and musigTree
+   */
+  everythingTree(locktime?: number, sequence?: number) {
+    const single = buildTapLeafScript(this.points, this.k, locktime, sequence);
+
+    const multiLeaves: Uint8Array[] = [];
+    for (const combo of combinations(this.points, this.k)) {
+      multiLeaves.push(buildTapLeafScript(combo, this.k, locktime, sequence));
+    }
+    const multiTree = buildMerkleTree(multiLeaves);
+
+    const musigLeaves: Uint8Array[] = [];
+    for (const combo of combinations(this.points, this.k)) {
+      musigLeaves.push(buildMusigLeafScript(combo));
+    }
+    const musigTree = buildMerkleTree(musigLeaves);
+
+    const tree = {
+      output     : single,
+      scriptTree : [multiTree, musigTree],
+    };
+    return payments.p2tr({
+      internalPubkey : this.defaultInternalPubkey,
+      scriptTree     : tree,
+    });
+  }
+
+  /**
+   * Degrading multisig: k-of-n initially, then (k-1)-of-n after delay, ... until 1-of-n
+   */
+  degradingMultisigTree(
+    sequenceBlockInterval?: number,
+    sequenceTimeInterval?: number
+  ) {
+    const leaves: Uint8Array[] = [];
+    for (let num = this.k; num >= 1; num--) {
+      let seq: number | undefined;
+      if (num === this.k) {
+        seq = undefined;
+      } else if (sequenceBlockInterval != null) {
+        seq = sequenceBlockInterval * (this.k - num);
+      } else if (sequenceTimeInterval != null) {
+        seq = sequenceTimeInterval * (this.k - num);
+      }
+      for (const combo of combinations(this.points, num)) {
+        leaves.push(buildTapLeafScript(combo, num, undefined, seq));
+      }
+    }
+    const tree = buildMerkleTree(leaves);
+    return payments.p2tr({
+      internalPubkey : this.defaultInternalPubkey,
+      scriptTree     : tree,
+    });
+  }
+}

package/src/btcr2/beacon/aggregation/coordinator.ts

@@ -0,0 +1,135 @@
+import { Base } from './messages/base.js';
+import { OptInMessage } from './messages/opt-in.js';
+import { OPT_IN, SUBSCRIBE, SUBSCRIBE_ACCEPT } from './messages/keygen.js';
+import { Musig2Cohort } from './models/cohort/index.js';
+import { NostrAdapter } from './protocol/nostr.js';
+import { ProtocolService } from './protocol/service.js';
+import { NONCE_CONTRIBUTION, REQUEST_SIGNATURE, SIGNATURE_AUTHORIZATION } from './messages/sign.js';
+
+/**
+ * The BeaconCoordinator class is responsible for managing the coordination of beacon aggregation.
+ * @class BeaconCoordinator
+ * @type {BeaconCoordinator}
+ */
+export class BeaconCoordinator {
+  /**
+   * The name of the BeaconCoordinator service.
+   * @type {string}
+   */
+  public name: string = 'BeaconCoordinator';
+
+  /**
+   * The DID of the BeaconCoordinator.
+   * @type {Array<string>}
+   */
+  public did: string = '';
+
+  /**
+   * The protocol service used for communication.
+   * @type {ProtocolService}
+   */
+  public protocol: ProtocolService;
+
+  /**
+   * List of subscribers to the BeaconCoordinator service.
+   * @type {Array<string>}
+   */
+  public cohorts: Array<Musig2Cohort> = [];
+
+  /**
+   * List of subscribers to the BeaconCoordinator service.
+   * @type {Array<string>}
+   */
+  private subscribers: string[] = [];
+
+  /**
+   * Constructs a new BeaconCoordinator instance.
+   * @param {ProtocolService} protocol The protocol service used for communication.
+   * @param {string} [did] Optional DID to use for the coordinator. If not provided, a new DID will be generated.
+   */
+
+  constructor(protocol: ProtocolService, did?: string) {
+    this.protocol = protocol ?? new NostrAdapter();
+    this.setup(did);
+  }
+
+  /**
+   * Sets up the BeaconCoordinator by registering message handlers and optionally generating a DID.
+   * @returns {void}
+   */
+  public setup(did?: string): void {
+    this.did = did || this.protocol.generateIdentity();
+    this.protocol.registerMessageHandler(SUBSCRIBE, this._handleSubscribe.bind(this));
+    this.protocol.registerMessageHandler(OPT_IN, this._handleOptIn.bind(this));
+    this.protocol.registerMessageHandler(REQUEST_SIGNATURE, this._handleSubscribe.bind(this));
+    this.protocol.registerMessageHandler(NONCE_CONTRIBUTION, this._handleSubscribe.bind(this));
+    this.protocol.registerMessageHandler(SIGNATURE_AUTHORIZATION, this._handleSubscribe.bind(this));
+  }
+
+  /**
+   * Initializes the BeaconCoordinator by setting up the protocol and starting it.
+   * @param {string} [did] Optional DID to use for the coordinator. If not provided, the existing DID will be used.
+   */
+  async initialize(did?: string): Promise<void> {
+    this.setup(did);
+    await this.protocol.start();
+  }
+
+  /**
+   * Handles subscription requests from other participants.
+   * @param {Base} message The message containing the subscription request.
+   * @returns {Promise<void>}
+   */
+  private async _handleSubscribe(message: Base): Promise<void> {
+    const sender = message.from;
+    if (!this.subscribers.includes(sender)) {
+      this.subscribers.push(sender);
+      await this.acceptSubscription(sender);
+    }
+  }
+
+  /**
+   * Handles opt-in requests from participants to join a cohort.
+   * @param {any} message The message containing the opt-in request.
+   * @returns {Promise<void>}
+   */
+  private async _handleOptIn(message: any): Promise<void> {
+    const optIn = OptInMessage.fromJSON(message);
+    const cohortId = optIn.cohortId;
+    const participant = optIn.from;
+    const participantPk = optIn.participantPk;
+    const cohort = this.cohorts.find(c => c.id === cohortId);
+    if (cohort && !cohort.participants.includes(participant)) {
+      cohort.participants.push(participant);
+      cohort.cohortKeys.push(participantPk);
+      await this.acceptSubscription(participant);
+      if (cohort.participants.length >= cohort.minParticipants) {
+        await this._startKeyGeneration(cohort);
+      }
+    }
+  }
+
+  /**
+   * Starts the key generation process for a cohort once it has enough participants.
+   * @param {Musig2Cohort} cohort The cohort for which to start key generation.
+   * @returns {Promise<void>}
+   */
+  private async _startKeyGeneration(cohort: Musig2Cohort): Promise<void> {
+    cohort.finalize();
+  }
+
+  /**
+   * Accepts a subscription request from a participant.
+   * @param {string} sender The DID of the participant requesting the subscription.
+   * @returns {Promise<void>}
+   */
+  public async acceptSubscription(sender: string): Promise<void> {
+    console.log(`Accepting subscription from ${sender}`);
+    const response = {
+      type : SUBSCRIBE_ACCEPT,
+      to   : sender,
+      from : this.did
+    };
+    await this.protocol.sendMessage(response, sender, this.did);
+  }
+}

package/src/btcr2/beacon/aggregation/messages/advert.ts

@@ -0,0 +1,36 @@
+import { BaseMessage } from './base.js';
+
+export type Advert = {
+  type?: 'BEACON_ADVERT';
+  to: string;
+  from: string;
+  cohortId: string;
+  cohortSize: number;
+  network: string;
+  threadId?: string
+}
+
+export class AdvertMessage extends BaseMessage {
+  public cohortId: string;
+  public cohortSize: number;
+  public network: string = 'signet';
+
+  constructor({ type = 'BEACON_ADVERT', to, from, threadId, cohortId, cohortSize, network }: Advert) {
+    super({ type, to, from, threadId, body: { cohortId, cohortSize, network }});
+    this.cohortId = cohortId;
+    this.cohortSize = cohortSize;
+    this.network = network;
+  }
+
+  /**
+   * Initializes an AdvertMessage from a given Advert object.
+   * @param {Advert} data - The Advert object to initialize the AdvertMessage.
+   * @returns {object} The serialized AdvertMessage.
+   */
+  public static initialize(data: Advert): AdvertMessage {
+    if (data.type != 'BEACON_ADVERT'){
+      throw new Error(`Invalid type: ${data.type}`);
+    }
+    return new AdvertMessage(data);
+  }
+}

package/src/btcr2/beacon/aggregation/messages/base.ts

@@ -0,0 +1,59 @@
+import { Maybe } from '@did-btcr2/common';
+
+export const MESSAGE_PREFIX = 'https://btcr2.tools/';
+
+export type BaseBody = {
+  cohortId: string;
+  cohortSize?: number;
+  network?: string;
+  participantPk?: Uint8Array;
+  beaconAddress?: string;
+  cohortKeys?: Array<Uint8Array>;
+};
+
+export type Base = {
+  type: string;
+  to: string;
+  from: string;
+  threadId?: string;
+  body: BaseBody;
+};
+
+export class BaseMessage {
+  public type: string;
+  public to: string;
+  public from: string;
+  public threadId?: string;
+  public body: BaseBody;
+
+  constructor({ type, to, from, threadId, body }: Base) {
+    this.type = type;
+    this.to = to;
+    this.from = from;
+    this.threadId = threadId;
+    this.body = body;
+  }
+
+  /**
+   * Creates a BaseMessage from a JSON object.
+   * @param {Maybe<Base>} data - The JSON object to initialize the BaseMessage.
+   * @returns {BaseMessage} The initialized BaseMessage.
+   */
+  public static fromJSON(data: Maybe<Base>): BaseMessage {
+    return new BaseMessage(data);
+  }
+
+  /**
+   * Converts a BaseMessage to a JSON object.
+   * @returns {Base} The JSON representation of the BaseMessage.
+   */
+  public json(): Base {
+    return {
+      type     : this.type,
+      to       : this.to,
+      from     : this.from,
+      threadId : this.threadId,
+      body     : this.body ?? {}
+    };
+  }
+}

package/src/btcr2/beacon/aggregation/messages/cohort-set.ts

@@ -0,0 +1,37 @@
+import { BaseMessage } from './base.js';
+import { COHORT_SET } from './keygen.js';
+
+export type CohortSet = {
+  type?: typeof COHORT_SET;
+  to: string;
+  from: string;
+  cohortId: string;
+  beaconAddress: string;
+  cohortKeys: Array<Uint8Array>;
+  threadId?: string;
+}
+
+export class CohortSetMessage extends BaseMessage {
+  public cohortId: string;
+  public beaconAddress: string;
+  public cohortKeys: Array<Uint8Array>;
+
+  constructor({ type = COHORT_SET, to, from, threadId, cohortId, beaconAddress, cohortKeys }: CohortSet) {
+    super({ type, to, from, threadId, body: { cohortId, beaconAddress, cohortKeys }});
+    this.cohortId = cohortId;
+    this.beaconAddress = beaconAddress;
+    this.cohortKeys = cohortKeys;
+  }
+
+  /**
+   * Initializes an CohortSetMessage from a given OptIn object.
+   * @param {OptIn} data - The OptIn object to initialize the CohortSetMessage.
+   * @returns {object} The serialized CohortSetMessage.
+   */
+  public static fromJSON(data: CohortSet): CohortSetMessage {
+    if (data.type !== COHORT_SET) {
+      throw new Error(`Invalid type: ${data.type}`);
+    }
+    return new CohortSetMessage(data);
+  }
+}

package/src/btcr2/beacon/aggregation/messages/keygen.ts

@@ -0,0 +1,8 @@
+import { MESSAGE_PREFIX } from './base.js';
+
+export const COHORT_ADVERT = `${MESSAGE_PREFIX}musig2/keygen/cohort_advert`;
+export const COHORT_INVITE = `${MESSAGE_PREFIX}musig2/keygen/cohort_invite`;
+export const OPT_IN = `${MESSAGE_PREFIX}musig2/keygen/opt_in`;
+export const COHORT_SET = `${MESSAGE_PREFIX}musig2/keygen/cohort_set`;
+export const SUBSCRIBE = `${MESSAGE_PREFIX}musig2/keygen/subscribe`;
+export const SUBSCRIBE_ACCEPT = `${MESSAGE_PREFIX}musig2/keygen/subscribe_accept`;

package/src/btcr2/beacon/aggregation/messages/opt-in.ts

@@ -0,0 +1,35 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from './base.js';
+import { OPT_IN } from './keygen.js';
+
+export type OptIn = {
+  type: typeof OPT_IN;
+  to: string;
+  from: string;
+  cohortId: string;
+  participantPk: Uint8Array;
+  threadId?: string;
+}
+
+export class OptInMessage extends BaseMessage {
+  public cohortId: string;
+  public participantPk: Uint8Array;
+
+  constructor({ type = OPT_IN, to, from, threadId, cohortId, participantPk }: OptIn) {
+    super({ type, to, from, threadId, body: { cohortId, participantPk }});
+    this.cohortId = cohortId;
+    this.participantPk = participantPk;
+  }
+
+  /**
+   * Initializes an OptInMessage from a given OptIn object.
+   * @param {OptIn} data - The OptIn object to initialize the OptInMessage.
+   * @returns {object} The serialized OptInMessage.
+   */
+  public static fromJSON(data: Maybe<OptIn>): OptInMessage {
+    if (data.type != 'OPT_IN') {
+      throw new Error(`Invalid type: ${data.type}`);
+    }
+    return new OptInMessage(data);
+  }
+}

package/src/btcr2/beacon/aggregation/messages/sign.ts

@@ -0,0 +1,7 @@
+import { MESSAGE_PREFIX } from './base.js';
+
+export const REQUEST_SIGNATURE = `${MESSAGE_PREFIX}musig2/sign/request_signature`;
+export const AUTHORIZATION_REQUEST = `${MESSAGE_PREFIX}musig2/sign/authorization_request`;
+export const NONCE_CONTRIBUTION = `${MESSAGE_PREFIX}musig2/sign/nonce_contribution`;
+export const AGGREGATED_NONCE = `${MESSAGE_PREFIX}musig2/sign/aggregated_nonce`;
+export const SIGNATURE_AUTHORIZATION = `${MESSAGE_PREFIX}musig2/sign/signature_authorization`;

package/src/btcr2/beacon/aggregation/models/cohort/index.ts

@@ -0,0 +1,112 @@
+import { TapRootMultiSig } from '../../../../../bitcoin/taproot.js';
+import { COHORT_STATUS, COHORT_STATUS_TYPE } from './status.js';
+
+export type Musig2CohortParams = {
+    id?: string;
+    minParticipants: number;
+    status: COHORT_STATUS_TYPE;
+    network: string;
+    coordinatorDid: string;
+}
+
+export class Musig2Cohort {
+  /**
+   * Unique identifier for the cohort.
+   * @type {string}
+   */
+  public id: string;
+
+  /**
+   * DID of the coordinator.
+   * @type {string}
+   */
+  public coordinatorDid: string;
+
+  /**
+   * Minimum number of participants required to finalize the cohort.
+   * @type {number}
+   */
+  public minParticipants: number;
+
+  /**
+   * Status of the cohort.
+   * @type {string}
+   */
+  public status: COHORT_STATUS_TYPE;
+
+  /**
+   * Network on which the cohort operates (e.g., 'mainnet', 'testnet').
+   * @type {string}
+   */
+  public network: string;
+
+  /**
+   * Pending signature requests, mapping participant DIDs to their pending signatures.
+   * @type {Record<string, string>}
+   */
+  public pendingSignatureRequests: Record<string, string> = {};
+
+  /**
+   * List of participant DIDs.
+   * @type {Array<string>}
+   */
+  public participants: Array<string> = new Array<string>();
+
+  /**
+   * List of cohort keys (public keys).
+   * @type {Array<Uint8Array>}
+   */
+  public cohortKeys: Array<Uint8Array> = new Array<Uint8Array>();
+
+  /**
+   * Taproot Merkle root for the cohort.
+   * @type {Uint8Array}
+   */
+  public trMerkleRoot?: Uint8Array;
+
+  /**
+   * Beacon address for the cohort, calculated from the Taproot multisig.
+   * @type {string}
+   */
+  public beaconAddress?: string;
+
+  /**
+   * Creates a new Musig2Cohort instance.
+   * @param {Musig2CohortParams} params Parameters for initializing the cohort.
+   * @param {string} [params.id] Optional unique identifier for the cohort. If not provided, a random UUID will be generated.
+   * @param {number} params.minParticipants Minimum number of participants required to finalize the cohort.
+   * @param {string} params.coordinatorDid DID of the coordinator managing the cohort.
+   * @param {string} params.status Initial status of the cohort (e.g., 'PENDING', 'COHORT_SET').
+   * @param {string} params.network Network on which the cohort operates (e.g., 'mainnet', 'testnet').
+   */
+  constructor(params: Musig2CohortParams) {
+    this.id = params.id || crypto.randomUUID();
+    this.minParticipants = params.minParticipants;
+    this.coordinatorDid = params.coordinatorDid;
+    this.status = params.status as COHORT_STATUS_TYPE || COHORT_STATUS.COHORT_ADVERTISED;
+    this.network = params.network;
+  }
+
+  public finalize(): void {
+    if(this.participants.length < this.minParticipants) {
+      throw new Error('Not enough participants to finalize the cohort');
+    }
+    this.status = COHORT_STATUS.COHORT_SET_STATUS;
+    this.beaconAddress = this.calulateBeaconAddress();
+  }
+
+  /**
+   * Calculates the beacon Taproot multisig address for the cohort using participant keys.
+   * @returns {string} The Taproot address for the cohort.
+   * @throws {Error} If the Taproot address cannot be calculated.
+   */
+  public calulateBeaconAddress(): string {
+    const trMultisig = new TapRootMultiSig(this.cohortKeys, this.cohortKeys.length);
+    const branch = trMultisig.musigTree();
+    this.trMerkleRoot = branch.hash;
+    if(!branch.address) {
+      throw new Error('Failed to calculate Taproot address');
+    }
+    return branch.address;
+  }
+}

package/src/btcr2/beacon/aggregation/models/cohort/status.ts

@@ -0,0 +1,7 @@
+export type COHORT_STATUS_TYPE = 'ADVERTISED' | 'OPTED_IN' | 'COHORT_SET' | 'FAILED';
+export enum COHORT_STATUS {
+  COHORT_ADVERTISED = 'ADVERTISED',
+  COHORT_OPTED_IN = 'OPTED_IN',
+  COHORT_SET_STATUS = 'COHORT_SET',
+  COHORT_FAILED = 'FAILED',
+}