@bitgo/public-types 6.15.0 → 6.17.0

package/package.json

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

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

@@ -0,0 +1,148 @@
+import * as t from "io-ts";
+import { NonEmptyString } from "io-ts-types";
+
+import { EddsaMPCv2SignedMessage } from "../common";
+import { EddsaKeyCreationMPCv2State } from "./eddsaKeygenState";
+import { OVCIndexEnum } from "./keygenRound";
+import { WalletType } from "./walletType";
+
+const BaseRoundPayload = t.type({
+  state: EddsaKeyCreationMPCv2State,
+  tssVersion: NonEmptyString,
+  walletType: WalletType,
+  coin: NonEmptyString,
+});
+
+type BaseRoundPayload = t.TypeOf<typeof BaseRoundPayload>;
+
+export const EddsaOVC1ToOVC2Round1Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: EddsaMPCv2SignedMessage,
+      }),
+    }),
+  }),
+]);
+
+export type EddsaOVC1ToOVC2Round1Payload = t.TypeOf<
+  typeof EddsaOVC1ToOVC2Round1Payload
+>;
+
+export const EddsaOVC1ToBitgoRound1Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: EddsaMPCv2SignedMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: EddsaMPCv2SignedMessage,
+      }),
+    }),
+  }),
+]);
+
+export type EddsaOVC1ToBitgoRound1Payload = t.TypeOf<
+  typeof EddsaOVC1ToBitgoRound1Payload
+>;
+
+export const EddsaPlatformRound1Payload = t.type({
+  walletGpgPubKeySigs: NonEmptyString,
+  sessionId: NonEmptyString,
+  bitgoMsg1: EddsaMPCv2SignedMessage,
+});
+
+export type EddsaPlatformRound1Payload = t.TypeOf<
+  typeof EddsaPlatformRound1Payload
+>;
+
+export const EddsaBitgoToOVC1Round1Response = t.intersection([
+  EddsaOVC1ToBitgoRound1Payload,
+  t.type({ platform: EddsaPlatformRound1Payload }),
+]);
+
+export type EddsaBitgoToOVC1Round1Response = t.TypeOf<
+  typeof EddsaBitgoToOVC1Round1Response
+>;
+
+export const EddsaOVC1ToOVC2Round2Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: EddsaMPCv2SignedMessage,
+        ovcMsg2: EddsaMPCv2SignedMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: EddsaMPCv2SignedMessage,
+      }),
+    }),
+    platform: EddsaPlatformRound1Payload,
+  }),
+]);
+
+export type EddsaOVC1ToOVC2Round2Payload = t.TypeOf<
+  typeof EddsaOVC1ToOVC2Round2Payload
+>;
+
+export const EddsaOVC2ToBitgoRound2Payload = t.intersection([
+  BaseRoundPayload,
+  t.type({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: EddsaMPCv2SignedMessage,
+        ovcMsg2: EddsaMPCv2SignedMessage,
+      }),
+      [OVCIndexEnum.TWO]: t.type({
+        gpgPubKey: NonEmptyString,
+        ovcMsg1: EddsaMPCv2SignedMessage,
+        ovcMsg2: EddsaMPCv2SignedMessage,
+      }),
+    }),
+    platform: EddsaPlatformRound1Payload,
+  }),
+]);
+
+export type EddsaOVC2ToBitgoRound2Payload = t.TypeOf<
+  typeof EddsaOVC2ToBitgoRound2Payload
+>;
+
+export const EddsaPlatformRound2Payload = t.intersection([
+  EddsaPlatformRound1Payload,
+  t.type({
+    commonPublicKeychain: NonEmptyString,
+    bitgoMsg2: EddsaMPCv2SignedMessage,
+  }),
+]);
+
+export type EddsaPlatformRound2Payload = t.TypeOf<
+  typeof EddsaPlatformRound2Payload
+>;
+
+export const EddsaBitgoToOVC1Round2Response = t.intersection([
+  t.type({ bitGoKeyId: NonEmptyString }),
+  EddsaOVC2ToBitgoRound2Payload,
+  t.type({ platform: EddsaPlatformRound2Payload }),
+  t.partial({
+    ovc: t.type({
+      [OVCIndexEnum.ONE]: t.partial({
+        commonKeyChainSignature: NonEmptyString,
+      }),
+      [OVCIndexEnum.TWO]: t.partial({
+        commonKeyChainSignature: NonEmptyString,
+      }),
+    }),
+  }),
+]);
+
+export type EddsaBitgoToOVC1Round2Response = t.TypeOf<
+  typeof EddsaBitgoToOVC1Round2Response
+>;

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

@@ -0,0 +1,31 @@
+import * as t from "io-ts";
+
+export enum EddsaKeyCreationMPCv2StateEnum {
+  WaitingForOVC1Round0Data = -1,
+  WaitingForOVC2Round1Data,
+  WaitingForOVC1Round1Data,
+  WaitingForBitgoRound1Data,
+  WaitingForOVC1Round2Data,
+  WaitingForOVC2Round2Data,
+  WaitingForBitgoRound2Data,
+  WaitingForOVC1GenerateKey,
+  WaitingForOVC2GenerateKey,
+  KeyGenerationComplete,
+}
+
+export const EddsaKeyCreationMPCv2State = t.union([
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round0Data),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round1Data),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForOVC2Round1Data),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound1Data),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1Round2Data),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForOVC2Round2Data),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForBitgoRound2Data),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForOVC1GenerateKey),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.WaitingForOVC2GenerateKey),
+  t.literal(EddsaKeyCreationMPCv2StateEnum.KeyGenerationComplete),
+]);
+
+export type EddsaKeyCreationMPCv2State = t.TypeOf<
+  typeof EddsaKeyCreationMPCv2State
+>;

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

@@ -1,4 +1,6 @@
 export * from "./keygenRound";
 export * from "./keygenState";
+export * from "./eddsaKeygenRound";
+export * from "./eddsaKeygenState";
 export * from "./walletType";
 export * from "./dsgType";

package/src/schema/transactionRequest/intents/cantonCommandIntent.ts

@@ -0,0 +1,80 @@
+import * as t from "io-ts";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+
+/**
+ * @title Canton Command Intent
+ *
+ * Generic intent for executing any allowlisted DAML command on Canton.
+ *
+ * All command-specific fields are grouped under {@link cantonCommandParams} to keep the
+ * top-level intent shape lean
+ *
+ * @param {String} intentType                          - The type of intent (always set to cantonCommand)
+ * @param {Object} cantonCommandParams                 - Canton-specific command payload
+ * @param {Object} cantonCommandParams.command         - The DAML command to execute (CreateCommand or ExerciseCommand)
+ * @param {Array}  cantonCommandParams.actAs           - Canton parties that must sign the transaction
+ * @param {Array}  [cantonCommandParams.readAs]        - Canton parties used for read-only ACS visibility
+ * @param {Array}  [cantonCommandParams.resolveContracts] - ACS resolution specs; each entry resolves a contractId and injects it at injectAs path
+ *
+ * For ExerciseCommand, either supply `contractId` directly or provide `resolveContracts` to inject it via ACS — enforced by IMS at build time, not the codec.
+ * `CantonCommand` uses open codecs per intents layer convention; one-of is enforced by Canton's API at execution time.
+ */
+
+const CreateCommand = t.type({
+  CreateCommand: t.type({
+    templateId: t.string,
+    createArguments: t.record(t.string, t.unknown),
+  }),
+});
+
+const ExerciseCommand = t.type({
+  ExerciseCommand: t.intersection([
+    t.type({
+      templateId: t.string,
+      choice: t.string,
+      choiceArgument: t.record(t.string, t.unknown),
+    }),
+    t.partial({
+      // omit when contractId will be injected via resolveContracts at build time
+      contractId: t.string,
+    }),
+  ]),
+});
+
+const CantonCommand = t.union([CreateCommand, ExerciseCommand]);
+
+const ResolveContractSpec = t.intersection([
+  t.type({
+    templateId: t.string,
+    actAs: t.array(t.string),
+    // dot-notation path where the resolved contractId is written, e.g. "command.ExerciseCommand.contractId"
+    injectAs: t.string,
+  }),
+  t.partial({
+    readAs: t.array(t.string),
+    // if true, resolves all active contracts for the templateId instead of just the first match
+    resolveAll: t.boolean,
+  }),
+]);
+
+const CantonCommandParams = t.intersection([
+  t.type({
+    command: CantonCommand,
+    actAs: t.array(t.string),
+  }),
+  t.partial({
+    readAs: t.array(t.string),
+    resolveContracts: t.array(ResolveContractSpec),
+  }),
+]);
+
+export const CantonCommandIntent = t.intersection([
+  BaseIntent,
+  t.type({
+    intentType: intentTypes.cantonCommand,
+    cantonCommandParams: CantonCommandParams,
+  }),
+]);
+
+export type CantonCommandIntent = t.TypeOf<typeof CantonCommandIntent>;

package/src/schema/transactionRequest/intents/index.ts

@@ -34,6 +34,7 @@ export * from "./bscStakeClaimRewardsIntent";
 export * from "./bscUndelegateIntent";
 export * from "./bscWithdrawUndelegateIntent";
 export * from "./cantonAllocationRequestIntent";
+export * from "./cantonCommandIntent";
 export * from "./cantonCosignDelegationAcceptIntent";
 export * from "./cantonCosignDelegationProposalIntent";
 export * from "./cantonPaymentIntent";

package/src/schema/transactionRequest/intents/intent.ts

@@ -114,6 +114,7 @@ import { VetSignalExitIntent } from "./vetSignalExitIntent";
 import { VetWithdrawStakeIntent } from "./vetWithdrawStakeIntent";
 import { CantonCosignDelegationAcceptIntent } from "./cantonCosignDelegationAcceptIntent";
 import { CantonCosignDelegationProposalIntent } from "./cantonCosignDelegationProposalIntent";
+import { CantonCommandIntent } from "./cantonCommandIntent";
 import { CantonPaymentIntent } from "./cantonPaymentIntent";
 import { CantonTransferAcceptIntent } from "./cantonTransferAcceptIntent";
 import { CantonTransferAcknowledgeIntent } from "./cantonTransferAcknowledgeIntent";
@@ -157,6 +158,7 @@ export const TransactionIntent = t.union([
   BscWithdrawUndelegateIntent,
   CantonCosignDelegationAcceptIntent,
   CantonCosignDelegationProposalIntent,
+  CantonCommandIntent,
   CantonPaymentIntent,
   CantonTransferAcceptIntent,
   CantonTransferAcknowledgeIntent,

package/src/schema/transactionRequest/intents/intentType.ts

@@ -60,6 +60,7 @@ export const intentTypes = {
   cosignDelegationProposal: t.literal("cosignDelegationProposal"),
   cosignDelegationAccept: t.literal("cosignDelegationAccept"),
   allocationRequest: t.literal("allocationRequest"),
+  cantonCommand: t.literal("cantonCommand"),
   /**
    * Deposit assets into a DeFi protocol vault (e.g. Concrete USD1 → ctUSD1cx).
    */