@bitgo/public-types 6.78.4 → 6.80.0

package/package.json

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

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

@@ -2,3 +2,4 @@ export * from "./mpcv2SigningState";
 export * from "./signingRound";
 export * from "./eddsaSigningRound";
 export * from "./redpallasSigningRound";
+export * from "./redpallasRerandRound";

package/src/schema/mpcv2/signing/redpallasRerandRound.ts

@@ -0,0 +1,100 @@
+import * as t from "io-ts";
+import { EddsaMPCv2SignedMessage } from "../common";
+import { MPCv2SignatureShareBase } from "./signingRound";
+
+/**
+ * RedPallas MPCv2 rerand — User to BitGo round 1
+ *
+ * RedPallas DSG rerand exchanges signed messages over two wire rounds:
+ * the producer's `getFirstMessage()` yields the round 1 payload and
+ * `handleIncomingMessages` in `WaitMsg1` yields the round 2 payload, each
+ * carrying WASM-serialized bytes with a rerand prefix. Round 0 is computed
+ * locally and never crosses the wire, and there is no round 3.
+ *
+ * The wire literals reuse the shared signing-round states; disambiguation
+ * from DSG signing is by which codec is passed to `decodeWithCodec`, not by
+ * the payload. Like DSG signing, the envelope is the shared
+ * `EddsaMPCv2SignedMessage` GPG material.
+ */
+export const RedpallasMPCv2RerandShareRound1Input = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round1Input"),
+      data: t.type({
+        msg1: EddsaMPCv2SignedMessage,
+      }),
+    },
+    "RedpallasMPCv2RerandShareRound1Input",
+  ),
+]);
+
+export type RedpallasMPCv2RerandShareRound1Input = t.TypeOf<
+  typeof RedpallasMPCv2RerandShareRound1Input
+>;
+
+/**
+ * RedPallas MPCv2 rerand — BitGo to User round 1
+ *
+ * BitGo returns its first rerand message.
+ */
+export const RedpallasMPCv2RerandShareRound1Output = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round1Output"),
+      data: t.type({
+        msg1: EddsaMPCv2SignedMessage,
+      }),
+    },
+    "RedpallasMPCv2RerandShareRound1Output",
+  ),
+]);
+
+export type RedpallasMPCv2RerandShareRound1Output = t.TypeOf<
+  typeof RedpallasMPCv2RerandShareRound1Output
+>;
+
+/**
+ * RedPallas MPCv2 rerand — User to BitGo round 2
+ *
+ * User sends their second rerand message.
+ */
+export const RedpallasMPCv2RerandShareRound2Input = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round2Input"),
+      data: t.type({
+        msg2: EddsaMPCv2SignedMessage,
+      }),
+    },
+    "RedpallasMPCv2RerandShareRound2Input",
+  ),
+]);
+
+export type RedpallasMPCv2RerandShareRound2Input = t.TypeOf<
+  typeof RedpallasMPCv2RerandShareRound2Input
+>;
+
+/**
+ * RedPallas MPCv2 rerand — BitGo to User round 2
+ *
+ * BitGo returns its second rerand message.
+ */
+export const RedpallasMPCv2RerandShareRound2Output = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round2Output"),
+      data: t.type({
+        msg2: EddsaMPCv2SignedMessage,
+      }),
+    },
+    "RedpallasMPCv2RerandShareRound2Output",
+  ),
+]);
+
+export type RedpallasMPCv2RerandShareRound2Output = t.TypeOf<
+  typeof RedpallasMPCv2RerandShareRound2Output
+>;

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

@@ -147,6 +147,7 @@ export * from "./solStakeIntent";
 export * from "./solStakingType";
 export * from "./solUnstakeIntent";
 export * from "./solVersionedCustomTxIntent";
+export * from "./stacksRegisterForBondIntent";
 export * from "./stakeClaimRewardsIntent";
 export * from "./stakeIntent";
 export * from "./stakeSwitchValidatorIntent";

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

@@ -102,6 +102,7 @@ import { DotConsolidateIntent } from "./dotConsolidateIntent";
 import { SolCloseAssociatedTokenAccountIntent } from "./solCloseAssociatedTokenAccountIntent";
 import { BaseStakeIntentWithCalldata } from "./baseStakeIntentWithCalldata";
 import { StakeWithCallDataIntent } from "./stakeWithCallDataIntent";
+import { StacksRegisterForBondIntent } from "./stacksRegisterForBondIntent";
 import { SwitchValidatorWithCallDataIntent } from "./switchValidatorWithCallDataIntent";
 import { CoreDaoDelegateIntent } from "./coredaoDelegateIntent";
 import { CoreDaoUndelegateIntent } from "./coredaoUndelegateIntent";
@@ -314,6 +315,7 @@ export const TransactionIntent = t.union([
   XdcProposeIntent,
   XdcResignIntent,
   XdcWithdrawIntent,
+  StacksRegisterForBondIntent,
 
   /**
    * Catch all for past intents that have not been converted to codecs

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

@@ -129,6 +129,11 @@ export const intentTypes = {
   finalizeUnwrap: t.literal("finalizeUnwrap"),
   delegateResource: t.literal("delegateResource"),
   undelegateResource: t.literal("undelegateResource"),
+  /**
+   * TXN 2 of Stacks PoX-5 staking: submit `register-for-bond` against the STX
+   * wallet that signs the registration (the BTC lock is TXN 1).
+   */
+  stacksRegisterForBond: t.literal("stacksRegisterForBond"),
   /**
    * Cross-chain export transaction (e.g. C-chain → P-chain or P-chain → C-chain on Flare/Avalanche).
    */

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

@@ -0,0 +1,57 @@
+import * as t from "io-ts";
+import { intentTypes } from "./intentType";
+import { BaseStakeIntent } from "./baseStakeIntent";
+import { optionalString } from "../../../utils";
+
+/**
+ * @title Stacks Register For Bond Intent
+ *
+ * @description TXN 2 of the Stacks PoX-5 BTC staking flow: submit `register-for-bond`
+ * against the STX wallet that signs and broadcasts the registration. The BTC-family
+ * staking wallet only carries the lock (TXN 1).
+ *
+ * The caller builds the Clarity arguments, so `functionArgs` carries **hex-encoded
+ * Clarity values in contract-argument order**. Wallet Platform decodes them into Clarity
+ * values and calls the contract — it does not need to know the `register-for-bond` ABI.
+ *
+ * ```clarity
+ * (register-for-bond
+ *   (bond-index uint)
+ *   (signer-manager <signer-manager-trait>)
+ *   (amount-ustx uint)
+ *   (btc-lockup (ok { outputs: (list 10 {...}), staker-unlock-bytes: (buff 683) }))
+ *   (signer-calldata (optional (buff 500))))
+ * ```
+ *
+ * @param {string} intentType - The type of intent (always set to stacksRegisterForBond)
+ * @param {string} stxWalletId - The Stacks wallet that signs and submits the registration
+ * @param {string} stxAddress - The resolved STX staker address (also the allowlist/membership key)
+ * @param {string | number} bondIndex - Bond index to register for
+ * @param {string} signerManager - The signer-manager contract principal
+ * @param {string | number} amountUstx - Stake amount in uSTX (the Clarity args carry the authoritative value)
+ * @param {string} contractName - Stacks contract name (e.g. "pox-5")
+ * @param {string} functionName - Contract function name (e.g. "register-for-bond")
+ * @param {string[]} functionArgs - Hex-encoded Clarity values in contract-argument order
+ * @param {string} [signerCalldata] - Optional `(buff 500)` calldata for the signer-manager's `validate-stake!`
+ */
+export const StacksRegisterForBondIntent = t.intersection([
+  BaseStakeIntent,
+  t.type({
+    intentType: intentTypes.stacksRegisterForBond,
+    stxWalletId: t.string,
+    stxAddress: t.string,
+    bondIndex: t.union([t.string, t.number]),
+    signerManager: t.string,
+    amountUstx: t.union([t.string, t.number]),
+    contractName: t.string,
+    functionName: t.string,
+    functionArgs: t.array(t.string),
+  }),
+  t.partial({
+    signerCalldata: optionalString,
+  }),
+]);
+
+export type StacksRegisterForBondIntent = t.TypeOf<
+  typeof StacksRegisterForBondIntent
+>;