@bitgo/public-types 2.32.1 → 2.33.0

package/dist/src/schema/webhook/webhookType.d.ts

@@ -1,44 +1,47 @@
 import * as t from "io-ts";
-export declare const WebhookType: t.KeyofC<{
-    txRequest: number;
-    txRequestTransaction: number;
-    transfer: number;
-    transaction: number;
-    transactionRemoved: number;
-    transactionExpire: number;
-    pendingapproval: number;
-    block: number;
-    admin: number;
-    address_confirmation: number;
-    lowFee: number;
-    circuitBreaker: number;
-    wallet_confirmation: number;
-    wireWithdrawal: number;
-    bankAccount: number;
-    userKycState: number;
-    enterpriseKycState: number;
-    identityStatus: number;
-    accessToken: number;
-}>;
+export declare enum WebhookTypeEnum {
+    "txRequest" = "txRequest",
+    "txRequestTransaction" = "txRequestTransaction",
+    "transfer" = "transfer",
+    "transaction" = "transaction",
+    "transactionRemoved" = "transactionRemoved",
+    "transactionExpire" = "transactionExpire",
+    "pendingapproval" = "pendingapproval",
+    "block" = "block",
+    "admin" = "admin",
+    "address_confirmation" = "address_confirmation",
+    "lowFee" = "lowFee",
+    "circuitBreaker" = "circuitBreaker",
+    "wallet_confirmation" = "wallet_confirmation",
+    "wireWithdrawal" = "wireWithdrawal",
+    "bankAccount" = "bankAccount",
+    "userKycState" = "userKycState",
+    "enterpriseKycState" = "enterpriseKycState",
+    "identityStatus" = "identityStatus",
+    "accessToken" = "accessToken"
+}
+export declare const WebhookType: t.KeyofC<typeof WebhookTypeEnum>;
 export type WebhookType = t.TypeOf<typeof WebhookType>;
-export declare const WalletWebhookType: t.KeyofC<{
-    txRequest: number;
-    txRequestTransaction: number;
-    transfer: number;
-    transaction: number;
-    transactionRemoved: number;
-    transactionExpire: number;
-    pendingapproval: number;
-    block: number;
-    admin: number;
-    address_confirmation: number;
-    lowFee: number;
-    circuitBreaker: number;
-    wireWithdrawal: number;
-}>;
+export declare enum WalletWebhookTypeEnum {
+    "txRequest" = "txRequest",
+    "txRequestTransaction" = "txRequestTransaction",
+    "transfer" = "transfer",
+    "transaction" = "transaction",
+    "transactionRemoved" = "transactionRemoved",
+    "transactionExpire" = "transactionExpire",
+    "pendingapproval" = "pendingapproval",
+    "block" = "block",
+    "admin" = "admin",
+    "address_confirmation" = "address_confirmation",
+    "lowFee" = "lowFee",
+    "circuitBreaker" = "circuitBreaker",
+    "wireWithdrawal" = "wireWithdrawal"
+}
+export declare const WalletWebhookType: t.KeyofC<typeof WalletWebhookTypeEnum>;
 export type WalletWebhookType = t.TypeOf<typeof WalletWebhookType>;
-export declare const EnterpriseWebhookType: t.KeyofC<{
-    bankAccount: number;
-    accessToken: number;
-}>;
+export declare enum EnterpriseWebhookTypeEnum {
+    "bankAccount" = "bankAccount",
+    "accessToken" = "accessToken"
+}
+export declare const EnterpriseWebhookType: t.KeyofC<typeof EnterpriseWebhookTypeEnum>;
 export type EnterpriseWebhookType = t.TypeOf<typeof EnterpriseWebhookType>;

package/dist/src/schema/webhook/webhookType.js

@@ -23,46 +23,52 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnterpriseWebhookType = exports.WalletWebhookType = exports.WebhookType = void 0;
+exports.EnterpriseWebhookType = exports.EnterpriseWebhookTypeEnum = exports.WalletWebhookType = exports.WalletWebhookTypeEnum = exports.WebhookType = exports.WebhookTypeEnum = void 0;
 const t = __importStar(require("io-ts"));
-exports.WebhookType = t.keyof({
-    txRequest: 1,
-    txRequestTransaction: 1,
-    transfer: 1,
-    transaction: 1,
-    transactionRemoved: 1,
-    transactionExpire: 1,
-    pendingapproval: 1,
-    block: 1,
-    admin: 1,
-    address_confirmation: 1,
-    lowFee: 1,
-    circuitBreaker: 1,
-    wallet_confirmation: 1,
-    wireWithdrawal: 1,
-    bankAccount: 1,
-    userKycState: 1,
-    enterpriseKycState: 1,
-    identityStatus: 1,
-    accessToken: 1,
-}, "WebhookType");
-exports.WalletWebhookType = t.keyof({
-    txRequest: 1,
-    txRequestTransaction: 1,
-    transfer: 1,
-    transaction: 1,
-    transactionRemoved: 1,
-    transactionExpire: 1,
-    pendingapproval: 1,
-    block: 1,
-    admin: 1,
-    address_confirmation: 1,
-    lowFee: 1,
-    circuitBreaker: 1,
-    wireWithdrawal: 1,
-}, "WalletWebhookType");
-exports.EnterpriseWebhookType = t.keyof({
-    bankAccount: 1,
-    accessToken: 1,
-}, "EnterpriseWebhookType");
+var WebhookTypeEnum;
+(function (WebhookTypeEnum) {
+    WebhookTypeEnum["txRequest"] = "txRequest";
+    WebhookTypeEnum["txRequestTransaction"] = "txRequestTransaction";
+    WebhookTypeEnum["transfer"] = "transfer";
+    WebhookTypeEnum["transaction"] = "transaction";
+    WebhookTypeEnum["transactionRemoved"] = "transactionRemoved";
+    WebhookTypeEnum["transactionExpire"] = "transactionExpire";
+    WebhookTypeEnum["pendingapproval"] = "pendingapproval";
+    WebhookTypeEnum["block"] = "block";
+    WebhookTypeEnum["admin"] = "admin";
+    WebhookTypeEnum["address_confirmation"] = "address_confirmation";
+    WebhookTypeEnum["lowFee"] = "lowFee";
+    WebhookTypeEnum["circuitBreaker"] = "circuitBreaker";
+    WebhookTypeEnum["wallet_confirmation"] = "wallet_confirmation";
+    WebhookTypeEnum["wireWithdrawal"] = "wireWithdrawal";
+    WebhookTypeEnum["bankAccount"] = "bankAccount";
+    WebhookTypeEnum["userKycState"] = "userKycState";
+    WebhookTypeEnum["enterpriseKycState"] = "enterpriseKycState";
+    WebhookTypeEnum["identityStatus"] = "identityStatus";
+    WebhookTypeEnum["accessToken"] = "accessToken";
+})(WebhookTypeEnum || (exports.WebhookTypeEnum = WebhookTypeEnum = {}));
+exports.WebhookType = t.keyof(WebhookTypeEnum, "WebhookType");
+var WalletWebhookTypeEnum;
+(function (WalletWebhookTypeEnum) {
+    WalletWebhookTypeEnum["txRequest"] = "txRequest";
+    WalletWebhookTypeEnum["txRequestTransaction"] = "txRequestTransaction";
+    WalletWebhookTypeEnum["transfer"] = "transfer";
+    WalletWebhookTypeEnum["transaction"] = "transaction";
+    WalletWebhookTypeEnum["transactionRemoved"] = "transactionRemoved";
+    WalletWebhookTypeEnum["transactionExpire"] = "transactionExpire";
+    WalletWebhookTypeEnum["pendingapproval"] = "pendingapproval";
+    WalletWebhookTypeEnum["block"] = "block";
+    WalletWebhookTypeEnum["admin"] = "admin";
+    WalletWebhookTypeEnum["address_confirmation"] = "address_confirmation";
+    WalletWebhookTypeEnum["lowFee"] = "lowFee";
+    WalletWebhookTypeEnum["circuitBreaker"] = "circuitBreaker";
+    WalletWebhookTypeEnum["wireWithdrawal"] = "wireWithdrawal";
+})(WalletWebhookTypeEnum || (exports.WalletWebhookTypeEnum = WalletWebhookTypeEnum = {}));
+exports.WalletWebhookType = t.keyof(WalletWebhookTypeEnum, "WalletWebhookType");
+var EnterpriseWebhookTypeEnum;
+(function (EnterpriseWebhookTypeEnum) {
+    EnterpriseWebhookTypeEnum["bankAccount"] = "bankAccount";
+    EnterpriseWebhookTypeEnum["accessToken"] = "accessToken";
+})(EnterpriseWebhookTypeEnum || (exports.EnterpriseWebhookTypeEnum = EnterpriseWebhookTypeEnum = {}));
+exports.EnterpriseWebhookType = t.keyof(EnterpriseWebhookTypeEnum, "EnterpriseWebhookType");
 //# sourceMappingURL=webhookType.js.map

package/dist/src/schema/webhook/webhookType.js.map

@@ -1 +1 @@
-{"version":3,"file":"webhookType.js","sourceRoot":"","sources":["../../../../src/schema/webhook/webhookType.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAEd,QAAA,WAAW,GAAG,CAAC,CAAC,KAAK,CAChC;IAEE,SAAS,EAAE,CAAC;IAEZ,oBAAoB,EAAE,CAAC;IACvB,QAAQ,EAAE,CAAC;IACX,WAAW,EAAE,CAAC;IACd,kBAAkB,EAAE,CAAC;IACrB,iBAAiB,EAAE,CAAC;IACpB,eAAe,EAAE,CAAC;IAClB,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;IACR,oBAAoB,EAAE,CAAC;IACvB,MAAM,EAAE,CAAC;IACT,cAAc,EAAE,CAAC;IAGjB,mBAAmB,EAAE,CAAC;IAEtB,cAAc,EAAE,CAAC;IACjB,WAAW,EAAE,CAAC;IACd,YAAY,EAAE,CAAC;IACf,kBAAkB,EAAE,CAAC;IACrB,cAAc,EAAE,CAAC;IAEjB,WAAW,EAAE,CAAC;CACf,EACD,aAAa,CACd,CAAC;AAIW,QAAA,iBAAiB,GAAG,CAAC,CAAC,KAAK,CACtC;IACE,SAAS,EAAE,CAAC;IACZ,oBAAoB,EAAE,CAAC;IACvB,QAAQ,EAAE,CAAC;IACX,WAAW,EAAE,CAAC;IACd,kBAAkB,EAAE,CAAC;IACrB,iBAAiB,EAAE,CAAC;IACpB,eAAe,EAAE,CAAC;IAClB,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;IACR,oBAAoB,EAAE,CAAC;IACvB,MAAM,EAAE,CAAC;IACT,cAAc,EAAE,CAAC;IACjB,cAAc,EAAE,CAAC;CAClB,EACD,mBAAmB,CACpB,CAAC;AAGW,QAAA,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAC1C;IACE,WAAW,EAAE,CAAC;IACd,WAAW,EAAE,CAAC;CACf,EACD,uBAAuB,CACxB,CAAC"}
+{"version":3,"file":"webhookType.js","sourceRoot":"","sources":["../../../../src/schema/webhook/webhookType.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAE3B,IAAY,eA0BX;AA1BD,WAAY,eAAe;IAEzB,0CAAyB,CAAA;IAEzB,gEAA+C,CAAA;IAC/C,wCAAuB,CAAA;IACvB,8CAA6B,CAAA;IAC7B,4DAA2C,CAAA;IAC3C,0DAAyC,CAAA;IACzC,sDAAqC,CAAA;IACrC,kCAAiB,CAAA;IACjB,kCAAiB,CAAA;IACjB,gEAA+C,CAAA;IAC/C,oCAAmB,CAAA;IACnB,oDAAmC,CAAA;IAGnC,8DAA6C,CAAA;IAE7C,oDAAmC,CAAA;IACnC,8CAA6B,CAAA;IAC7B,gDAA+B,CAAA;IAC/B,4DAA2C,CAAA;IAC3C,oDAAmC,CAAA;IAEnC,8CAA6B,CAAA;AAC/B,CAAC,EA1BW,eAAe,+BAAf,eAAe,QA0B1B;AAEY,QAAA,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;AAGnE,IAAY,qBAcX;AAdD,WAAY,qBAAqB;IAC/B,gDAAyB,CAAA;IACzB,sEAA+C,CAAA;IAC/C,8CAAuB,CAAA;IACvB,oDAA6B,CAAA;IAC7B,kEAA2C,CAAA;IAC3C,gEAAyC,CAAA;IACzC,4DAAqC,CAAA;IACrC,wCAAiB,CAAA;IACjB,wCAAiB,CAAA;IACjB,sEAA+C,CAAA;IAC/C,0CAAmB,CAAA;IACnB,0DAAmC,CAAA;IACnC,0DAAmC,CAAA;AACrC,CAAC,EAdW,qBAAqB,qCAArB,qBAAqB,QAchC;AAEY,QAAA,iBAAiB,GAAG,CAAC,CAAC,KAAK,CACtC,qBAAqB,EACrB,mBAAmB,CACpB,CAAC;AAGF,IAAY,yBAGX;AAHD,WAAY,yBAAyB;IACnC,wDAA6B,CAAA;IAC7B,wDAA6B,CAAA;AAC/B,CAAC,EAHW,yBAAyB,yCAAzB,yBAAyB,QAGpC;AACY,QAAA,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAC1C,yBAAyB,EACzB,uBAAuB,CACxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo/public-types",
-  "version": "2.32.1",
+  "version": "2.33.0",
   "description": "Collection of types exposed externally as part of the BitGo public API",
   "license": "UNLICENSED",
   "author": "",

package/src/schema/mpcv2/index.ts

@@ -1,3 +1,4 @@
 export * from "./common";
 export * from "./keyGen";
 export * from "./signing";
+export * from "./smc";

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

@@ -0,0 +1,3 @@
+export * from "./keygenRound";
+export * from "./keygenState";
+export * from "./walletType";

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>;