@bitgo/public-types 6.62.0 → 6.64.0

package/package.json

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

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

@@ -111,3 +111,43 @@ export const EddsaMPCv2KeyGenRound2Response = t.type({
 export type EddsaMPCv2KeyGenRound2Response = t.TypeOf<
   typeof EddsaMPCv2KeyGenRound2Response
 >;
+
+// RedPallas MPCv2 (2-round) keygen codecs
+
+export const RedpallasMPCv2KeyGenRound1Request = t.type({
+  userGpgPublicKey: NonEmptyString,
+  backupGpgPublicKey: NonEmptyString,
+  userMsg1: EddsaMPCv2SignedMessage,
+  backupMsg1: EddsaMPCv2SignedMessage,
+});
+export type RedpallasMPCv2KeyGenRound1Request = t.TypeOf<
+  typeof RedpallasMPCv2KeyGenRound1Request
+>;
+
+export const RedpallasMPCv2KeyGenRound1Response = t.type({
+  sessionId: NonEmptyString,
+  bitgoMsg1: EddsaMPCv2SignedMessage,
+});
+export type RedpallasMPCv2KeyGenRound1Response = t.TypeOf<
+  typeof RedpallasMPCv2KeyGenRound1Response
+>;
+
+export const RedpallasMPCv2KeyGenRound2Request = t.type({
+  sessionId: NonEmptyString,
+  userMsg2: EddsaMPCv2SignedMessage,
+  backupMsg2: EddsaMPCv2SignedMessage,
+  // hex-encoded 32-byte seed; must be identical across user/backup/BitGo DKG parties.
+  derivationSeed: t.string,
+});
+export type RedpallasMPCv2KeyGenRound2Request = t.TypeOf<
+  typeof RedpallasMPCv2KeyGenRound2Request
+>;
+
+export const RedpallasMPCv2KeyGenRound2Response = t.type({
+  sessionId: NonEmptyString,
+  commonPublicKeychain: NonEmptyString,
+  bitgoMsg2: EddsaMPCv2SignedMessage,
+});
+export type RedpallasMPCv2KeyGenRound2Response = t.TypeOf<
+  typeof RedpallasMPCv2KeyGenRound2Response
+>;

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

@@ -2,5 +2,7 @@ export * from "./keygenRound";
 export * from "./keygenState";
 export * from "./eddsaKeygenRound";
 export * from "./eddsaKeygenState";
+export * from "./redpallasKeygenRound";
+export * from "./redpallasKeygenState";
 export * from "./walletType";
 export * from "./dsgType";

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

@@ -0,0 +1,101 @@
+import * as t from "io-ts";
+import { NonEmptyString } from "io-ts-types";
+
+import { EddsaMPCv2SignedMessage } from "../common";
+import { RedpallasKeyCreationMPCv2State } from "./redpallasKeygenState";
+import { OVCIndexEnum } from "./keygenRound";
+import { WalletType } from "./walletType";
+
+const BaseRoundPayload = t.type({
+  state: RedpallasKeyCreationMPCv2State,
+  tssVersion: NonEmptyString,
+  walletType: WalletType,
+  coin: NonEmptyString,
+});
+
+type BaseRoundPayload = t.TypeOf<typeof BaseRoundPayload>;
+
+export const RedpallasOVC1ToBitgoRound1Payload = 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 RedpallasOVC1ToBitgoRound1Payload = t.TypeOf<
+  typeof RedpallasOVC1ToBitgoRound1Payload
+>;
+
+export const RedpallasPlatformRound1Payload = t.type({
+  sessionId: NonEmptyString,
+  bitgoMsg1: EddsaMPCv2SignedMessage,
+});
+
+export type RedpallasPlatformRound1Payload = t.TypeOf<
+  typeof RedpallasPlatformRound1Payload
+>;
+
+export const RedpallasBitgoToOVC1Round1Response = t.intersection([
+  RedpallasOVC1ToBitgoRound1Payload,
+  t.type({ platform: RedpallasPlatformRound1Payload }),
+]);
+
+export type RedpallasBitgoToOVC1Round1Response = t.TypeOf<
+  typeof RedpallasBitgoToOVC1Round1Response
+>;
+
+export const RedpallasOVC2ToBitgoRound2Payload = 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: RedpallasPlatformRound1Payload,
+    // hex-encoded 32-byte seed; must be identical across user/backup/BitGo DKG parties.
+    derivationSeed: t.string,
+  }),
+]);
+
+export type RedpallasOVC2ToBitgoRound2Payload = t.TypeOf<
+  typeof RedpallasOVC2ToBitgoRound2Payload
+>;
+
+export const RedpallasPlatformRound2Payload = t.intersection([
+  RedpallasPlatformRound1Payload,
+  t.type({
+    commonPublicKeychain: NonEmptyString,
+    bitgoMsg2: EddsaMPCv2SignedMessage,
+  }),
+]);
+
+export type RedpallasPlatformRound2Payload = t.TypeOf<
+  typeof RedpallasPlatformRound2Payload
+>;
+
+export const RedpallasBitgoToOVC1Round2Response = t.intersection([
+  t.type({ bitGoKeyId: NonEmptyString }),
+  RedpallasOVC2ToBitgoRound2Payload,
+  t.type({ platform: RedpallasPlatformRound2Payload }),
+]);
+
+export type RedpallasBitgoToOVC1Round2Response = t.TypeOf<
+  typeof RedpallasBitgoToOVC1Round2Response
+>;

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

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

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

@@ -0,0 +1,26 @@
+import * as t from "io-ts";
+import { BaseStakeIntent } from "./baseStakeIntent";
+import { intentTypes } from "./intentType";
+
+/**
+ * @title ADA RealFi sUSDr Cancel Intent
+ *
+ * @description Cancel a pending RealFi order (`intentType: cancel`, `stakingType: REALFI_SUSDR`).
+ * Lives in this coin-level file so a native ADA cancel can be added later.
+ *
+ * @param {string} orderTxHash Order output transaction hash
+ * @param {number} orderOutputIndex Order UTxO output index
+ * @param {string} destinationAddress Address that receives reclaimed funds
+ */
+export const AdaRealFiCancelIntent = t.intersection([
+  BaseStakeIntent,
+  t.type({
+    intentType: intentTypes.cancel,
+    stakingType: t.literal("REALFI_SUSDR"),
+    orderTxHash: t.string,
+    orderOutputIndex: t.number,
+    destinationAddress: t.string,
+  }),
+]);
+
+export type AdaRealFiCancelIntent = t.TypeOf<typeof AdaRealFiCancelIntent>;

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

@@ -2,11 +2,13 @@ import * as t from "io-ts";
 import { StakeIntent } from "./stakeIntent";
 import { Amount } from "./amount";
 import { Optional } from "../../../utils";
+import { AdaStakingType } from "./adaStakingType";
+import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
  * @title ADA Stake Intent
  *
- * @description The intent to stake ADA
+ * @description The intent to stake ADA. Omit `stakingType` or set `NATIVE` for pool + dRep.
  *
  * @param {string} poolKeyHash The key hash for the staking pool
  * @param {string} dRepId The identifier for a DRep
@@ -20,7 +22,32 @@ export const AdaStakeIntent = t.intersection([
   }),
   t.partial({
     amount: Optional(Amount),
+    stakingType: Optional(AdaStakingType),
   }),
 ]);
 
 export type AdaStakeIntent = t.TypeOf<typeof AdaStakeIntent>;
+
+/**
+ * @title ADA RealFi sUSDr Stake Intent
+ *
+ * @description Stake USDr into RealFi sUSDr (`intentType: stake`, `stakingType: REALFI_SUSDR`).
+ * Extends `StakeIntent` (not `AdaStakeIntent`) — RealFi has no `poolKeyHash` / `dRepId`.
+ *
+ * @param {Amount} amount USDr amount (`ada:usdr`)
+ * @param {string} destinationAddress Order output address
+ * @param {number} slippageToleranceBps Optional; staking-service default 50
+ */
+export const AdaRealFiStakeIntent = t.intersection([
+  StakeIntent,
+  BaseIntentWithAmount,
+  t.type({
+    stakingType: t.literal("REALFI_SUSDR"),
+    destinationAddress: t.string,
+  }),
+  t.partial({
+    slippageToleranceBps: Optional(t.number),
+  }),
+]);
+
+export type AdaRealFiStakeIntent = t.TypeOf<typeof AdaRealFiStakeIntent>;

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+
+/** Cardano staking provider. Omit/`NATIVE` = pool + dRep; `REALFI_SUSDR` = RealFi sUSDr. */
+export enum AdaStakingTypeEnum {
+  NATIVE = "NATIVE",
+  REALFI_SUSDR = "REALFI_SUSDR",
+}
+
+export const AdaStakingType = t.keyof(AdaStakingTypeEnum);
+
+export type AdaStakingType = t.TypeOf<typeof AdaStakingType>;

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

@@ -2,9 +2,13 @@ import * as t from "io-ts";
 import { Amount } from "./amount";
 import { Optional } from "../../../utils";
 import { UnstakeIntent } from "./unstakeIntent";
+import { AdaStakingType } from "./adaStakingType";
+import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
  * @title ADA Unstake Intent
+ *
+ * @description Native ADA unstake. Omit `stakingType` or set `NATIVE`.
  */
 export const AdaUnstakeIntent = t.intersection([
   UnstakeIntent,
@@ -13,7 +17,30 @@ export const AdaUnstakeIntent = t.intersection([
   }),
   t.partial({
     amount: Optional(Amount),
+    stakingType: Optional(AdaStakingType),
   }),
 ]);
 
 export type AdaUnstakeIntent = t.TypeOf<typeof AdaUnstakeIntent>;
+
+/**
+ * @title ADA RealFi sUSDr Unstake Intent
+ *
+ * @description Unstake sUSDr (`intentType: unstake`, `stakingType: REALFI_SUSDR`).
+ * Extends `UnstakeIntent` (not `AdaUnstakeIntent`) — RealFi has no `poolKeyHash`.
+ *
+ * @param {Amount} amount sUSDr amount (`ada:susdr`)
+ * @param {string} destinationAddress Wallet address that receives funds
+ * @param {string} unlockSlot Slot after which funds can be claimed (decimal string; WP/SDK use bigint)
+ */
+export const AdaRealFiUnstakeIntent = t.intersection([
+  UnstakeIntent,
+  BaseIntentWithAmount,
+  t.type({
+    stakingType: t.literal("REALFI_SUSDR"),
+    destinationAddress: t.string,
+    unlockSlot: t.string,
+  }),
+]);
+
+export type AdaRealFiUnstakeIntent = t.TypeOf<typeof AdaRealFiUnstakeIntent>;

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

@@ -3,11 +3,13 @@ export * from "./accountBaseBuildOptions";
 export * from "./accountBaseConsolidateIntent";
 export * from "./accountBaseCreateAccountIntent";
 export * from "./accountBaseUpdateAccountIntent";
+export * from "./adaCancelIntent";
 export * from "./adaConsolidateIntent";
 export * from "./adaPaymentIntent";
 export * from "./adaPledgeIntent";
 export * from "./adaStakeClaimRewardsIntent";
 export * from "./adaStakeIntent";
+export * from "./adaStakingType";
 export * from "./adaUnstakeIntent";
 export * from "./adaVoteDelegationIntent";
 export * from "./address";

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

@@ -1,7 +1,8 @@
 import * as t from "io-ts";
 import { AdaConsolidateIntent } from "./adaConsolidateIntent";
 import { AdaPaymentIntent } from "./adaPaymentIntent";
-import { AdaStakeIntent } from "./adaStakeIntent";
+import { AdaRealFiStakeIntent, AdaStakeIntent } from "./adaStakeIntent";
+import { AdaRealFiCancelIntent } from "./adaCancelIntent";
 import { AdaVoteDelegationIntent } from "./adaVoteDelegationIntent";
 import { AptCustomTxIntent } from "./aptCustomTxIntent";
 import { AtomPaymentIntent } from "./atomPaymentIntent";
@@ -88,7 +89,7 @@ import { WalletRecoveryIntent } from "./walletRecoveryIntent";
 import { SolConsolidateIntent } from "./solConsolidateIntent";
 import { TonConsolidateIntent } from "./tonConsolidateIntent";
 import { AdaStakeClaimRewardsIntent } from "./adaStakeClaimRewardsIntent";
-import { AdaUnstakeIntent } from "./adaUnstakeIntent";
+import { AdaRealFiUnstakeIntent, AdaUnstakeIntent } from "./adaUnstakeIntent";
 import { SuiPaymentIntent } from "./suiPaymentIntent";
 import { SuiConsolidateIntent } from "./suiConsolidateIntent";
 import { MmiSignTransactionIntent } from "./mmiSignTransactionIntent";
@@ -159,8 +160,11 @@ export const TransactionIntent = t.union([
   AdaConsolidateIntent,
   AdaPaymentIntent,
   AdaStakeClaimRewardsIntent,
+  AdaRealFiStakeIntent,
   AdaStakeIntent,
+  AdaRealFiUnstakeIntent,
   AdaUnstakeIntent,
+  AdaRealFiCancelIntent,
   AdaVoteDelegationIntent,
   AptCustomTxIntent,
   AtomPaymentIntent,

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

@@ -8,6 +8,8 @@ export const intentTypes = {
   fanout: t.literal("fanout"),
   stake: t.literal("stake"),
   unstake: t.literal("unstake"),
+  /** Cancel a pending staking order; pair with stakingType (e.g. REALFI_SUSDR). */
+  cancel: t.literal("cancel"),
   delegate: t.literal("delegate"),
   undelegate: t.literal("undelegate"),
   switchValidator: t.literal("switchValidator"),