@bitgo/public-types 2.32.2 → 2.33.0

package/src/schema/mpcv2/smc/keygenRound.ts

@@ -0,0 +1,260 @@
+import * as t from "io-ts";
+import { NonEmptyString } from "io-ts-types";
+
+import { KeyCreationMPCv2State } from "./keygenState";
+import { WalletType } from "./walletType";
+import { AuthBroadcastMessage } from "./messages/broadcast";
+import { AuthEncP2PMessage } from "./messages/p2p";
+
+export enum OVCIndexEnum {
+  ONE = 1,
+  TWO = 2,
+}
+
+const BaseRoundPayload = t.type({
+  tssVersion: NonEmptyString,
+  walletType: WalletType,
+  coin: NonEmptyString,
+  state: KeyCreationMPCv2State,
+});
+
+type BaseRoundPayload = t.TypeOf<typeof BaseRoundPayload>;
+
+export const OVC1ToOVC2Round1Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+      }),
+    }),
+  }),
+]);
+
+export type OVC1ToOVC2Round1Payload = t.TypeOf<typeof OVC1ToOVC2Round1Payload>;
+
+export const OVC2ToBitgoRound1Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+      }),
+    }),
+  }),
+]);
+
+export type OVC2ToBitgoRound1Payload = t.TypeOf<
+  typeof OVC2ToBitgoRound1Payload
+>;
+
+export const PlatformRound1Payload = t.type({
+  walletGpgPubKeySigs: NonEmptyString,
+  sessionId: NonEmptyString,
+  bitgoMsg1: AuthBroadcastMessage,
+  ovc: t.type({
+    [OVCIndexEnum.ONE]: t.type({
+      bitgoToOvcMsg2: AuthEncP2PMessage,
+    }),
+    [OVCIndexEnum.TWO]: t.type({
+      bitgoToOvcMsg2: AuthEncP2PMessage,
+    }),
+  }),
+});
+
+export type PlatformRound1Payload = t.TypeOf<typeof PlatformRound1Payload>;
+
+export const BitgoToOVC1Round1Response = t.type({
+  wallet: t.intersection([
+    OVC2ToBitgoRound1Payload,
+    t.type({ platform: PlatformRound1Payload }),
+  ]),
+});
+
+export type BitgoToOVC1Round1Response = t.TypeOf<
+  typeof BitgoToOVC1Round1Response
+>;
+
+export const OVC1ToOVC2Round2Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+      }),
+    }),
+  }),
+]);
+
+export type OVC1ToOVC2Round2Payload = t.TypeOf<typeof OVC1ToOVC2Round2Payload>;
+
+export const OVC2ToBitgoRound2Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+      }),
+    }),
+    platform: PlatformRound1Payload,
+  }),
+]);
+
+export type OVC2ToBitgoRound2Payload = t.TypeOf<
+  typeof OVC2ToBitgoRound2Payload
+>;
+
+export const PlatformRound2Payload = t.type({
+  sessionId: NonEmptyString,
+  bitgoMsg1: AuthBroadcastMessage,
+  bitgoCommitment2: NonEmptyString,
+  ovc: t.type({
+    [OVCIndexEnum.ONE]: t.type({
+      bitgoToOvcMsg2: AuthEncP2PMessage,
+      bitgoToOvcMsg3: AuthEncP2PMessage,
+    }),
+    [OVCIndexEnum.TWO]: t.type({
+      bitgoToOvcMsg2: AuthEncP2PMessage,
+      bitgoToOvcMsg3: AuthEncP2PMessage,
+    }),
+  }),
+});
+
+export const BitgoToOVC1Round2Response = t.type({
+  wallet: t.intersection([
+    OVC2ToBitgoRound2Payload,
+    t.type({ platform: PlatformRound2Payload }),
+  ]),
+});
+
+export type BitgoToOVC1Round2Response = t.TypeOf<
+  typeof BitgoToOVC1Round2Response
+>;
+
+export const OVC1ToOVC2Round3Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+        ovcToBitgoMsg3: AuthEncP2PMessage,
+        ovcToOvcMsg3: AuthEncP2PMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+      }),
+    }),
+    platform: PlatformRound2Payload,
+  }),
+]);
+
+export type OVC1ToOVC2Round3Payload = t.TypeOf<typeof OVC1ToOVC2Round3Payload>;
+
+export const OVC2ToOVC1Round3Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+        ovcToBitgoMsg3: AuthEncP2PMessage,
+        ovcToOvcMsg3: AuthEncP2PMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+        ovcToBitgoMsg3: AuthEncP2PMessage,
+        ovcToOvcMsg3: AuthEncP2PMessage,
+        ovcMsg4: AuthBroadcastMessage,
+      }),
+    }),
+    platform: PlatformRound2Payload,
+  }),
+]);
+
+export type OVC2ToOVC1Round3Payload = t.TypeOf<typeof OVC2ToOVC1Round3Payload>;
+
+export const OVC1ToBitgoRound3Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+        ovcToBitgoMsg3: AuthEncP2PMessage,
+        ovcToOvcMsg3: AuthEncP2PMessage,
+        ovcMsg4: AuthBroadcastMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: AuthBroadcastMessage,
+        ovcToBitgoMsg2: AuthEncP2PMessage,
+        ovcToOvcMsg2: AuthEncP2PMessage,
+        ovcToBitgoMsg3: AuthEncP2PMessage,
+        ovcToOvcMsg3: AuthEncP2PMessage,
+        ovcMsg4: AuthBroadcastMessage,
+      }),
+    }),
+    platform: PlatformRound2Payload,
+  }),
+]);
+
+export type OVC1ToBitgoRound3Payload = t.TypeOf<
+  typeof OVC1ToBitgoRound3Payload
+>;
+
+export const PlatformRound3Payload = t.intersection([
+  PlatformRound2Payload,
+  t.type({
+    commonKeychain: NonEmptyString,
+    bitgoMsg4: AuthBroadcastMessage,
+  }),
+]);
+
+export type PlatformRound3Payload = t.TypeOf<typeof PlatformRound3Payload>;
+
+export const BitgoToOVC1Round3Response = t.type({
+  bitGoKeyId: NonEmptyString,
+  wallet: t.intersection([
+    OVC1ToBitgoRound3Payload,
+    t.type({ platform: PlatformRound3Payload }),
+  ]),
+});
+
+export type BitgoToOVC1Round3Response = t.TypeOf<
+  typeof BitgoToOVC1Round3Response
+>;

package/src/schema/mpcv2/smc/keygenState.ts

@@ -0,0 +1,35 @@
+import * as t from "io-ts";
+
+export enum KeyCreationMPCv2StateEnum {
+  WaitingForOVC1Round1Data = -1,
+  WaitingForOVC2Round1Data,
+  WaitingForBitgoRound1Data,
+  WaitingForOVC1Round2Data,
+  WaitingForOVC2Round2Data,
+  WaitingForBitgoRound2Data,
+  WaitingForOVC1Round3aData,
+  WaitingForOVC2Round3Data,
+  WaitingForOVC1Round3bData,
+  WaitingForBitgoRound3Data,
+  WaitingForOVC1GenerateKey,
+  WaitingForOVC2GenerateKey,
+  KeyGenerationComplete,
+}
+
+export const KeyCreationMPCv2State = t.union([
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC1Round1Data),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC2Round1Data),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC2Round2Data),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC1Round3aData),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC2Round3Data),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC1Round3bData),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForBitgoRound3Data),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC1GenerateKey),
+  t.literal(KeyCreationMPCv2StateEnum.WaitingForOVC2GenerateKey),
+  t.literal(KeyCreationMPCv2StateEnum.KeyGenerationComplete),
+]);
+
+export type KeyCreationMPCv2State = t.TypeOf<typeof KeyCreationMPCv2State>;

package/src/schema/mpcv2/smc/messages/broadcast.ts

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+
+import { MPCv2PartyFromStringOrNumber } from "../../common";
+
+const AuthMessage = t.type({
+  message: t.string,
+  signature: t.string,
+});
+
+type AuthMessage = t.TypeOf<typeof AuthMessage>;
+
+export const AuthBroadcastMessage = t.intersection([
+  t.type({
+    payload: AuthMessage,
+    from: MPCv2PartyFromStringOrNumber,
+  }),
+  t.partial({
+    signatureR: t.string,
+  }),
+]);
+
+export type AuthBroadcastMessage = t.TypeOf<typeof AuthBroadcastMessage>;

package/src/schema/mpcv2/smc/messages/p2p.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+import { NonEmptyString } from "io-ts-types";
+
+import { MPCv2PartyFromStringOrNumber } from "../../common";
+
+const AuthEncMessage = t.type({
+  encryptedMessage: NonEmptyString,
+  signature: NonEmptyString,
+});
+
+type AuthEncMessage = t.TypeOf<typeof AuthEncMessage>;
+
+export const AuthEncP2PMessage = t.intersection([
+  t.type({
+    payload: AuthEncMessage,
+    from: MPCv2PartyFromStringOrNumber,
+    to: MPCv2PartyFromStringOrNumber,
+  }),
+  t.partial({
+    commitment: NonEmptyString,
+  }),
+]);
+
+export type AuthEncP2PMessage = t.TypeOf<typeof AuthEncP2PMessage>;

package/src/schema/mpcv2/smc/walletType.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+
+export enum WalletTypeEnum {
+  TSS = "tss",
+  CUSTODIAL = "custodial",
+  COLD = "cold",
+}
+
+export const WalletType = t.keyof(WalletTypeEnum, "WalletType");
+
+export type WalletType = t.TypeOf<typeof WalletType>;