@bitgo-beta/sdk-core 8.2.1-beta.21 → 8.2.1-beta.2100

package/dist/src/bitgo/utils/tss/keyVerification.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEddsaUserSigningMaterial = parseEddsaUserSigningMaterial;
+exports.eddsaUserSigningMaterialMatchesCommonKeychain = eddsaUserSigningMaterialMatchesCommonKeychain;
+/**
+ * @prettier
+ */
+const t = __importStar(require("io-ts"));
+const tss_1 = __importDefault(require("../../../account-lib/mpc/tss"));
+const HEX_32_BYTES = /^[0-9a-f]{64}$/i;
+/** 32-byte hex string; every hex field of genuine MPCv1 signing material is fixed-width 32 bytes. */
+const Hex32Bytes = new t.Type('Hex32Bytes', (u) => typeof u === 'string' && HEX_32_BYTES.test(u), (u, c) => (typeof u === 'string' && HEX_32_BYTES.test(u) ? t.success(u) : t.failure(u, c)), t.identity);
+const UShareCodec = t.type({
+    i: t.number,
+    t: t.number,
+    n: t.number,
+    y: Hex32Bytes,
+    seed: Hex32Bytes,
+    chaincode: Hex32Bytes,
+});
+/**
+ * `v` is the optional VSS commitment: absent on shares created without verifiable secret sharing.
+ * It is declared through `t.partial` rather than a union with `undefined` so that decoding an
+ * absent `v` does not materialize it as an own property on the share handed to `keyCombine`.
+ */
+const YShareCodec = t.intersection([
+    t.type({
+        i: t.number,
+        j: t.number,
+        y: Hex32Bytes,
+        u: Hex32Bytes,
+        chaincode: Hex32Bytes,
+    }),
+    t.partial({ v: Hex32Bytes }),
+]);
+const UserSigningMaterialCodec = t.type({
+    uShare: UShareCodec,
+    bitgoYShare: YShareCodec,
+    backupYShare: YShareCodec,
+});
+/**
+ * Maps a decode failure to a constant message. Never interpolates `error.value`: the input is
+ * private key material. This is also why the codecs call `t.failure` without a message and why
+ * the `validationErrors` reporter in `utils/decode.ts` is not used — both embed the failing value.
+ */
+function toInvalidKeyMessage(errors) {
+    const [error] = errors;
+    // the head of the context is the root codec itself, so the remaining keys are the field path.
+    // purely numeric keys are intersection/union member indices rather than field names.
+    const segments = error.context
+        .slice(1)
+        .map((entry) => entry.key)
+        .filter((key) => !/^\d+$/.test(key));
+    if (segments.length === 0) {
+        return 'Invalid user key - signing material is not an object';
+    }
+    if (segments.length === 1 && (error.value === undefined || error.value === null)) {
+        return `Invalid user key - missing ${segments[0]}`;
+    }
+    return `Invalid user key - ${segments[0]} is not a valid share`;
+}
+/**
+ * Parses the user TSS EdDSA signing material that a client passes as `prv` when signing,
+ * and rejects anything that does not decode as user signing material.
+ *
+ * Decoding is a shape check only, but it keeps malformed input away from the combine routine,
+ * which throws raw, input-interpolating errors for malformed shares.
+ *
+ * The input is private key material, so no error message may interpolate any part of it.
+ * In particular, JSON.parse errors on Node >= 20 include the raw input in their message,
+ * which is why parse failures are rethrown with a constant message.
+ *
+ * @param prv - stringified user signing material (`uShare`, `bitgoYShare`, `backupYShare`)
+ */
+function parseEddsaUserSigningMaterial(prv) {
+    let parsed;
+    try {
+        parsed = JSON.parse(prv);
+    }
+    catch (e) {
+        throw new Error('Invalid user key - could not parse signing material');
+    }
+    const decoded = UserSigningMaterialCodec.decode(parsed);
+    if (decoded._tag === 'Left') {
+        throw new Error(toInvalidKeyMessage(decoded.left));
+    }
+    return decoded.right;
+}
+/**
+ * Checks that `uShare.y` is the public point actually derived from `uShare.seed`.
+ *
+ * `keyCombine` derives the private scalar from the seed but reconstructs the common keychain from
+ * the declared `y` fields, so it never compares the two. Without this check a caller who knows
+ * only the wallet's public commonKeychain can submit genuine public fields alongside a seed they
+ * do not own and still verify. Re-running `keyShare` with the share's own seed and chaincode
+ * reproduces the derivation and yields the `y` the seed really commits to.
+ */
+function uShareSeedMatchesY(MPC, uShare) {
+    const seedchain = Buffer.concat([Buffer.from(uShare.seed, 'hex'), Buffer.from(uShare.chaincode, 'hex')]);
+    let derived;
+    try {
+        derived = MPC.keyShare(uShare.i, uShare.t, uShare.n, seedchain).uShare;
+    }
+    catch (e) {
+        // keyShare rejects an out-of-range index or threshold, which makes the share unusable
+        return false;
+    }
+    return derived.y === uShare.y;
+}
+/**
+ * Verifies that user TSS EdDSA signing material (`prv`) recombines to a given commonKeychain.
+ *
+ * Recombines the user's share with the BitGo and backup Y shares — the same computation the
+ * SDK performs when creating the user keychain or signing — and compares the result against
+ * the wallet's commonKeychain. Returns false rather than throwing when the keys do not match.
+ * Shares that pass the shape check but are cryptographically inconsistent are rejected with
+ * a constant message: the combine routine throws raw errors, some of which interpolate
+ * submitter-controlled fields, which must not surface through the API.
+ *
+ * Recombination alone is not proof of possession, so two further checks run first. The seed is
+ * bound to `uShare.y`, and the Y shares must carry their VSS commitment `v` — `keyCombine`
+ * verifies a Y share's secret `u` only when `v` is present, so material without `v` cannot be
+ * verified at all and throws a distinct error rather than being judged a non-match. Genuine
+ * shares produced by `keyShare` always carry `v`.
+ *
+ * A true result is a consistency check for a caller inspecting its own material, not proof of
+ * possession, and must never be used as an authorization signal: a caller who knows only the
+ * wallet's public commonKeychain can construct material that passes — an `uShare` whose seed
+ * matches its `y`, plus Y shares with a chosen secret `u` and the `v` solved from it, whose
+ * `y` values sum to the common key.
+ *
+ * @param params.prv - stringified user signing material, as passed as `prv` when signing
+ * @param params.commonKeychain - the wallet's user keychain commonKeychain
+ */
+async function eddsaUserSigningMaterialMatchesCommonKeychain(params) {
+    const signingMaterial = parseEddsaUserSigningMaterial(params.prv);
+    const MPC = await tss_1.default.initialize();
+    if (!uShareSeedMatchesY(MPC, signingMaterial.uShare)) {
+        return false;
+    }
+    // keyCombine verifies a Y share's secret `u` against its commitment only when `v` is present,
+    // so material without `v` cannot be verified at all; reject it distinctly instead of judging
+    // it a non-match, which would misreport genuine material that lacks the commitment
+    if (signingMaterial.bitgoYShare.v === undefined || signingMaterial.backupYShare.v === undefined) {
+        throw new Error('Unable to verify key - signing material has no VSS commitment');
+    }
+    let combinedKey;
+    try {
+        combinedKey = MPC.keyCombine(signingMaterial.uShare, [signingMaterial.bitgoYShare, signingMaterial.backupYShare]);
+    }
+    catch (e) {
+        throw new Error('Invalid user key - could not combine signing material');
+    }
+    return combinedKey.pShare.y + combinedKey.pShare.chaincode === params.commonKeychain;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyVerification.js","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/keyVerification.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmFA,sEAYC;AAgDD,sGAsBC;AArKD;;GAEG;AACH,yCAA2B;AAC3B,uEAAiE;AAGjE,MAAM,YAAY,GAAG,iBAAiB,CAAC;AAEvC,qGAAqG;AACrG,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,IAAI,CAC3B,YAAY,EACZ,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EACjE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAC1F,CAAC,CAAC,QAAQ,CACX,CAAC;AAEF,MAAM,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC;IACzB,CAAC,EAAE,CAAC,CAAC,MAAM;IACX,CAAC,EAAE,CAAC,CAAC,MAAM;IACX,CAAC,EAAE,CAAC,CAAC,MAAM;IACX,CAAC,EAAE,UAAU;IACb,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,UAAU;CACtB,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC,YAAY,CAAC;IACjC,CAAC,CAAC,IAAI,CAAC;QACL,CAAC,EAAE,CAAC,CAAC,MAAM;QACX,CAAC,EAAE,CAAC,CAAC,MAAM;QACX,CAAC,EAAE,UAAU;QACb,CAAC,EAAE,UAAU;QACb,SAAS,EAAE,UAAU;KACtB,CAAC;IACF,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC;CAC7B,CAAC,CAAC;AAEH,MAAM,wBAAwB,GAAG,CAAC,CAAC,IAAI,CAAC;IACtC,MAAM,EAAE,WAAW;IACnB,WAAW,EAAE,WAAW;IACxB,YAAY,EAAE,WAAW;CAC1B,CAAC,CAAC;AAEH;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,MAAgB;IAC3C,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;IACvB,8FAA8F;IAC9F,qFAAqF;IACrF,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO;SAC3B,KAAK,CAAC,CAAC,CAAC;SACR,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC;SACzB,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACvC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,sDAAsD,CAAC;IAChE,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,EAAE,CAAC;QACjF,OAAO,8BAA8B,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;IACrD,CAAC;IACD,OAAO,sBAAsB,QAAQ,CAAC,CAAC,CAAC,uBAAuB,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,6BAA6B,CAAC,GAAW;IACvD,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACzE,CAAC;IACD,MAAM,OAAO,GAAG,wBAAwB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACxD,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,OAAO,CAAC,KAA4B,CAAC;AAC9C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,kBAAkB,CAAC,GAAU,EAAE,MAAqC;IAC3E,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACzG,IAAI,OAAsC,CAAC;IAC3C,IAAI,CAAC;QACH,OAAO,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,MAAM,CAAC;IACzE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,sFAAsF;QACtF,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACI,KAAK,UAAU,6CAA6C,CAAC,MAGnE;IACC,MAAM,eAAe,GAAG,6BAA6B,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAClE,MAAM,GAAG,GAAG,MAAM,aAAK,CAAC,UAAU,EAAE,CAAC;IACrC,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC;QACrD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,8FAA8F;IAC9F,6FAA6F;IAC7F,mFAAmF;IACnF,IAAI,eAAe,CAAC,WAAW,CAAC,CAAC,KAAK,SAAS,IAAI,eAAe,CAAC,YAAY,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QAChG,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;IACnF,CAAC;IACD,IAAI,WAAuB,CAAC;IAC5B,IAAI,CAAC;QACH,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;IACpH,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,SAAS,KAAK,MAAM,CAAC,cAAc,CAAC;AACvF,CAAC","sourcesContent":["/**\n * @prettier\n */\nimport * as t from 'io-ts';\nimport Eddsa, { KeyCombine } from '../../../account-lib/mpc/tss';\nimport { UserSigningMaterial } from '../../tss/eddsa/types';\n\nconst HEX_32_BYTES = /^[0-9a-f]{64}$/i;\n\n/** 32-byte hex string; every hex field of genuine MPCv1 signing material is fixed-width 32 bytes. */\nconst Hex32Bytes = new t.Type<string, string, unknown>(\n  'Hex32Bytes',\n  (u): u is string => typeof u === 'string' && HEX_32_BYTES.test(u),\n  (u, c) => (typeof u === 'string' && HEX_32_BYTES.test(u) ? t.success(u) : t.failure(u, c)),\n  t.identity\n);\n\nconst UShareCodec = t.type({\n  i: t.number,\n  t: t.number,\n  n: t.number,\n  y: Hex32Bytes,\n  seed: Hex32Bytes,\n  chaincode: Hex32Bytes,\n});\n\n/**\n * `v` is the optional VSS commitment: absent on shares created without verifiable secret sharing.\n * It is declared through `t.partial` rather than a union with `undefined` so that decoding an\n * absent `v` does not materialize it as an own property on the share handed to `keyCombine`.\n */\nconst YShareCodec = t.intersection([\n  t.type({\n    i: t.number,\n    j: t.number,\n    y: Hex32Bytes,\n    u: Hex32Bytes,\n    chaincode: Hex32Bytes,\n  }),\n  t.partial({ v: Hex32Bytes }),\n]);\n\nconst UserSigningMaterialCodec = t.type({\n  uShare: UShareCodec,\n  bitgoYShare: YShareCodec,\n  backupYShare: YShareCodec,\n});\n\n/**\n * Maps a decode failure to a constant message. Never interpolates `error.value`: the input is\n * private key material. This is also why the codecs call `t.failure` without a message and why\n * the `validationErrors` reporter in `utils/decode.ts` is not used — both embed the failing value.\n */\nfunction toInvalidKeyMessage(errors: t.Errors): string {\n  const [error] = errors;\n  // the head of the context is the root codec itself, so the remaining keys are the field path.\n  // purely numeric keys are intersection/union member indices rather than field names.\n  const segments = error.context\n    .slice(1)\n    .map((entry) => entry.key)\n    .filter((key) => !/^\\d+$/.test(key));\n  if (segments.length === 0) {\n    return 'Invalid user key - signing material is not an object';\n  }\n  if (segments.length === 1 && (error.value === undefined || error.value === null)) {\n    return `Invalid user key - missing ${segments[0]}`;\n  }\n  return `Invalid user key - ${segments[0]} is not a valid share`;\n}\n\n/**\n * Parses the user TSS EdDSA signing material that a client passes as `prv` when signing,\n * and rejects anything that does not decode as user signing material.\n *\n * Decoding is a shape check only, but it keeps malformed input away from the combine routine,\n * which throws raw, input-interpolating errors for malformed shares.\n *\n * The input is private key material, so no error message may interpolate any part of it.\n * In particular, JSON.parse errors on Node >= 20 include the raw input in their message,\n * which is why parse failures are rethrown with a constant message.\n *\n * @param prv - stringified user signing material (`uShare`, `bitgoYShare`, `backupYShare`)\n */\nexport function parseEddsaUserSigningMaterial(prv: string): UserSigningMaterial {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(prv);\n  } catch (e) {\n    throw new Error('Invalid user key - could not parse signing material');\n  }\n  const decoded = UserSigningMaterialCodec.decode(parsed);\n  if (decoded._tag === 'Left') {\n    throw new Error(toInvalidKeyMessage(decoded.left));\n  }\n  return decoded.right as UserSigningMaterial;\n}\n\n/**\n * Checks that `uShare.y` is the public point actually derived from `uShare.seed`.\n *\n * `keyCombine` derives the private scalar from the seed but reconstructs the common keychain from\n * the declared `y` fields, so it never compares the two. Without this check a caller who knows\n * only the wallet's public commonKeychain can submit genuine public fields alongside a seed they\n * do not own and still verify. Re-running `keyShare` with the share's own seed and chaincode\n * reproduces the derivation and yields the `y` the seed really commits to.\n */\nfunction uShareSeedMatchesY(MPC: Eddsa, uShare: UserSigningMaterial['uShare']): boolean {\n  const seedchain = Buffer.concat([Buffer.from(uShare.seed, 'hex'), Buffer.from(uShare.chaincode, 'hex')]);\n  let derived: UserSigningMaterial['uShare'];\n  try {\n    derived = MPC.keyShare(uShare.i, uShare.t, uShare.n, seedchain).uShare;\n  } catch (e) {\n    // keyShare rejects an out-of-range index or threshold, which makes the share unusable\n    return false;\n  }\n  return derived.y === uShare.y;\n}\n\n/**\n * Verifies that user TSS EdDSA signing material (`prv`) recombines to a given commonKeychain.\n *\n * Recombines the user's share with the BitGo and backup Y shares — the same computation the\n * SDK performs when creating the user keychain or signing — and compares the result against\n * the wallet's commonKeychain. Returns false rather than throwing when the keys do not match.\n * Shares that pass the shape check but are cryptographically inconsistent are rejected with\n * a constant message: the combine routine throws raw errors, some of which interpolate\n * submitter-controlled fields, which must not surface through the API.\n *\n * Recombination alone is not proof of possession, so two further checks run first. The seed is\n * bound to `uShare.y`, and the Y shares must carry their VSS commitment `v` — `keyCombine`\n * verifies a Y share's secret `u` only when `v` is present, so material without `v` cannot be\n * verified at all and throws a distinct error rather than being judged a non-match. Genuine\n * shares produced by `keyShare` always carry `v`.\n *\n * A true result is a consistency check for a caller inspecting its own material, not proof of\n * possession, and must never be used as an authorization signal: a caller who knows only the\n * wallet's public commonKeychain can construct material that passes — an `uShare` whose seed\n * matches its `y`, plus Y shares with a chosen secret `u` and the `v` solved from it, whose\n * `y` values sum to the common key.\n *\n * @param params.prv - stringified user signing material, as passed as `prv` when signing\n * @param params.commonKeychain - the wallet's user keychain commonKeychain\n */\nexport async function eddsaUserSigningMaterialMatchesCommonKeychain(params: {\n  prv: string;\n  commonKeychain: string;\n}): Promise<boolean> {\n  const signingMaterial = parseEddsaUserSigningMaterial(params.prv);\n  const MPC = await Eddsa.initialize();\n  if (!uShareSeedMatchesY(MPC, signingMaterial.uShare)) {\n    return false;\n  }\n  // keyCombine verifies a Y share's secret `u` against its commitment only when `v` is present,\n  // so material without `v` cannot be verified at all; reject it distinctly instead of judging\n  // it a non-match, which would misreport genuine material that lacks the commitment\n  if (signingMaterial.bitgoYShare.v === undefined || signingMaterial.backupYShare.v === undefined) {\n    throw new Error('Unable to verify key - signing material has no VSS commitment');\n  }\n  let combinedKey: KeyCombine;\n  try {\n    combinedKey = MPC.keyCombine(signingMaterial.uShare, [signingMaterial.bitgoYShare, signingMaterial.backupYShare]);\n  } catch (e) {\n    throw new Error('Invalid user key - could not combine signing material');\n  }\n  return combinedKey.pShare.y + combinedKey.pShare.chaincode === params.commonKeychain;\n}\n"]}

package/dist/src/bitgo/utils/tss/preHashedSignable.d.ts

@@ -0,0 +1,23 @@
+import { IBaseCoin } from '../../baseCoin';
+import { SignableTransaction } from './baseTypes';
+export interface CoinWithPreHashedSignable {
+    /**
+     * Returns true when the signableHex for this transaction is already the
+     * final signing hash (SHA-256 for Avalanche atomic txs), and the MPC
+     * signing flow should use it directly without additional hashing.
+     */
+    isSignablePreHashed(unsignedTx: SignableTransaction): boolean;
+}
+export declare function isCoinWithPreHashedSignable(coin: unknown): coin is CoinWithPreHashedSignable;
+/**
+ * Detect Avalanche atomic cross-chain transactions by codec prefix.
+ *
+ * Avalanche codec type IDs start with 0x00000000 (first 4 hex chars = '0000').
+ * Standard EVM RLP encoding starts with 0xf8xx — overlap is currently impossible.
+ *
+ * Note: The WP strips the '0x' prefix from serializedTxHex before storing,
+ * so we check for '0000' not '0x0000'.
+ */
+export declare function isAvalancheAtomicTx(unsignedTx: SignableTransaction): boolean;
+export declare function shouldUsePreHashedSignable(coin: IBaseCoin, unsignedTx: SignableTransaction): boolean;
+//# sourceMappingURL=preHashedSignable.d.ts.map

package/dist/src/bitgo/utils/tss/preHashedSignable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preHashedSignable.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/preHashedSignable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,mBAAmB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC;CAC/D;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,yBAAyB,CAM5F;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAE5E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAEpG"}

package/dist/src/bitgo/utils/tss/preHashedSignable.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCoinWithPreHashedSignable = isCoinWithPreHashedSignable;
+exports.isAvalancheAtomicTx = isAvalancheAtomicTx;
+exports.shouldUsePreHashedSignable = shouldUsePreHashedSignable;
+function isCoinWithPreHashedSignable(coin) {
+    return (coin !== null &&
+        typeof coin === 'object' &&
+        typeof coin.isSignablePreHashed === 'function');
+}
+/**
+ * Detect Avalanche atomic cross-chain transactions by codec prefix.
+ *
+ * Avalanche codec type IDs start with 0x00000000 (first 4 hex chars = '0000').
+ * Standard EVM RLP encoding starts with 0xf8xx — overlap is currently impossible.
+ *
+ * Note: The WP strips the '0x' prefix from serializedTxHex before storing,
+ * so we check for '0000' not '0x0000'.
+ */
+function isAvalancheAtomicTx(unsignedTx) {
+    return unsignedTx.serializedTxHex.startsWith('0000');
+}
+function shouldUsePreHashedSignable(coin, unsignedTx) {
+    return isCoinWithPreHashedSignable(coin) && coin.isSignablePreHashed(unsignedTx);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/utils/tss/recipientUtils.d.ts

@@ -0,0 +1,42 @@
+import { TransactionParams } from '../../baseCoin';
+import { TxRequest } from './baseTypes';
+/**
+ * Transaction types that legitimately carry no explicit recipients.
+ * These are the intentType strings as stored in TxRequest.intent.intentType by WP.
+ * verifyTransaction handles no-recipient validation for these internally.
+ * Mirrors the bypass list in abstractEthLikeNewCoins.ts verifyTssTransaction.
+ *
+ * ECDSA types: acceleration, fillNonce, transferToken, tokenApproval, consolidate,
+ *              bridgeFunds, enableToken, customTx, wrapApprove, wrap, unwrap,
+ *              finalizeUnwrap, contractCall
+ * BSC/BNB delegation-based staking: delegate, undelegate, switchValidator
+ * CELO/ETH lock-based staking: stake, unstake, stakeWithCallData, unstakeWithCallData,
+ *              transferStake, increaseStake, goUnstake
+ * Claim rewards (BSC, CELO — TRX/SOL use EdDSA and are unaffected): claim, stakeClaimRewards
+ */
+export declare const NO_RECIPIENT_TX_TYPES: Set<string>;
+/**
+ * Resolves the effective txParams for TSS signing recipient verification.
+ *
+ * For smart contract interactions, recipients live in txRequest.intent.recipients
+ * (native amount = 0, so buildParams is empty). Falls back to intent recipients
+ * mapped to ITransactionRecipient shape when txParams.recipients is absent.
+ *
+ * tokenName is derived from tokenData.tokenName when present, otherwise from
+ * amount.symbol when chainName is provided and symbol differs from it.
+ *
+ * Staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) are
+ * identified generically by the presence of `stakingRequestId` on the intent —
+ * a required field on BaseStakeIntent in @bitgo/public-types. These intents
+ * have no txParams recipients by design; validation is done at the coin layer.
+ *
+ * Throws InvalidTransactionError if no recipients can be resolved and the
+ * transaction is not a known no-recipient type.
+ *
+ * @param txRequest - the transaction request containing the persisted intent
+ * @param txParams - the caller-supplied transaction parameters (may be undefined)
+ * @param chainName - the base chain name (e.g. 'sol', 'tsol') used to exclude
+ *   native-coin transfers from tokenName; pass baseCoin.getChain()
+ */
+export declare function resolveEffectiveTxParams(txRequest: TxRequest, txParams: TransactionParams | undefined, chainName?: string): TransactionParams;
+//# sourceMappingURL=recipientUtils.d.ts.map

package/dist/src/bitgo/utils/tss/recipientUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipientUtils.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/recipientUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EAAmB,SAAS,EAAE,MAAM,aAAa,CAAC;AAEzD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,aAsFhC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EACvC,SAAS,CAAC,EAAE,MAAM,GACjB,iBAAiB,CA0DnB"}

package/dist/src/bitgo/utils/tss/recipientUtils.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_RECIPIENT_TX_TYPES = void 0;
+exports.resolveEffectiveTxParams = resolveEffectiveTxParams;
+const errors_1 = require("../../errors");
+/**
+ * Transaction types that legitimately carry no explicit recipients.
+ * These are the intentType strings as stored in TxRequest.intent.intentType by WP.
+ * verifyTransaction handles no-recipient validation for these internally.
+ * Mirrors the bypass list in abstractEthLikeNewCoins.ts verifyTssTransaction.
+ *
+ * ECDSA types: acceleration, fillNonce, transferToken, tokenApproval, consolidate,
+ *              bridgeFunds, enableToken, customTx, wrapApprove, wrap, unwrap,
+ *              finalizeUnwrap, contractCall
+ * BSC/BNB delegation-based staking: delegate, undelegate, switchValidator
+ * CELO/ETH lock-based staking: stake, unstake, stakeWithCallData, unstakeWithCallData,
+ *              transferStake, increaseStake, goUnstake
+ * Claim rewards (BSC, CELO — TRX/SOL use EdDSA and are unaffected): claim, stakeClaimRewards
+ */
+exports.NO_RECIPIENT_TX_TYPES = new Set([
+    // ECDSA types
+    'acceleration',
+    'fillNonce',
+    'transferToken',
+    'tokenApproval',
+    'consolidate',
+    'bridgeFunds',
+    'enableToken',
+    'enabletoken',
+    'disableToken',
+    'disabletoken',
+    'customTx',
+    // DeFi vault operations — recipients/calldata built server-side from defiParams
+    'defiApprove',
+    'defiDeposit',
+    'defiWithdraw',
+    // Native wrap/unwrap (WETH9 deposit()/withdraw()) — calldata and the WETH9
+    // address are resolved server-side from the vault binding, so no recipients.
+    // Registered in BOTH spellings on purpose: this set is matched against
+    // txParams.type, which is buildParams.type (camelCase, from wallet.sendMany),
+    // AND against intent.intentType (kebab-case, as WP persists it). Signing paths
+    // that carry no txParams — notably pendingApproval.approve() →
+    // recreateTxRequest() → signTxRequest() with no txParams — only ever see the
+    // kebab-case spelling.
+    'wrapNative',
+    'wrap-native',
+    'unwrapNative',
+    'unwrap-native',
+    // ERC-7984 shield/unshield: approve/wrap/unwrap calldata is built server-side from the
+    // intent, and finalizeUnwrap txnReqs are WP-created at READY_TO_FINALIZE (client signs
+    // only) — none carry SDK-level recipients.
+    'wrapApprove',
+    'wrap',
+    'unwrap',
+    'finalizeUnwrap',
+    // Smart contract invocations with no explicit SDK-level recipients
+    'contractCall',
+    // BSC/BNB delegation-based staking — intentType strings from TxRequest.intent.intentType.
+    // Note: SOL solDelegateIntent also uses intentType "delegate".
+    'delegate',
+    'undelegate',
+    'switchValidator',
+    // CELO/ETH lock-based staking
+    'stake',
+    'unstake',
+    'stakeWithCallData',
+    'unstakeWithCallData',
+    'transferStake',
+    'increaseStake',
+    'goUnstake',
+    // Claim rewards — BSC and CELO (TRX/SOL/Cosmos use EdDSA, not affected by this guard)
+    'claim',
+    'stakeClaimRewards',
+    'createAccount',
+    // Canton operations with no SDK-level recipients. Canton.verifyTransaction validates these from the transaction itself.
+    'transferAccept',
+    'transferReject',
+    'transferOfferWithdrawn',
+    'cosignDelegationAccept',
+    'allocationAllocate',
+    'allocationOfferWithdrawn',
+    'cantonCommand',
+    'cantonEndInvestorOnboardingOffer',
+    'cantonEndInvestorOnboardingAccept',
+    'cantonEndInvestorOnboardingReject',
+    'cantonParticipantOnboardingRequest',
+    'pledge',
+    // Avalanche / Flare cross-chain atomic imports — recipients are not supplied
+    // by the client because the import consumes UTXOs already owned by the
+    // wallet; the destination address is the wallet itself. WP issues these
+    // with intentType 'import' (P-chain) or 'importtoc' (C-chain).
+    'import',
+    'importtoc',
+    // SOL: deactivate stake account — no on-chain transfer recipient.
+    'deactivate',
+    // SOL: authorize stake account — no transfer recipient.
+    'authorize',
+]);
+/**
+ * Resolves the effective txParams for TSS signing recipient verification.
+ *
+ * For smart contract interactions, recipients live in txRequest.intent.recipients
+ * (native amount = 0, so buildParams is empty). Falls back to intent recipients
+ * mapped to ITransactionRecipient shape when txParams.recipients is absent.
+ *
+ * tokenName is derived from tokenData.tokenName when present, otherwise from
+ * amount.symbol when chainName is provided and symbol differs from it.
+ *
+ * Staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) are
+ * identified generically by the presence of `stakingRequestId` on the intent —
+ * a required field on BaseStakeIntent in @bitgo/public-types. These intents
+ * have no txParams recipients by design; validation is done at the coin layer.
+ *
+ * Throws InvalidTransactionError if no recipients can be resolved and the
+ * transaction is not a known no-recipient type.
+ *
+ * @param txRequest - the transaction request containing the persisted intent
+ * @param txParams - the caller-supplied transaction parameters (may be undefined)
+ * @param chainName - the base chain name (e.g. 'sol', 'tsol') used to exclude
+ *   native-coin transfers from tokenName; pass baseCoin.getChain()
+ */
+function resolveEffectiveTxParams(txRequest, txParams, chainName) {
+    const intentRecipients = txRequest.intent?.recipients?.map((intentRecipient) => {
+        // Prefer tokenData.tokenName; fall back to amount.symbol when chainName is
+        // provided and differs from it. When absent, skip the symbol fallback.
+        const { symbol } = intentRecipient.amount;
+        const tokenName = intentRecipient.tokenData?.tokenName ||
+            (chainName !== undefined && symbol && symbol !== chainName ? symbol : undefined);
+        return {
+            address: intentRecipient.address.address,
+            amount: intentRecipient.amount.value,
+            data: intentRecipient.data,
+            ...(tokenName && { tokenName }),
+        };
+    });
+    const effectiveTxParams = {
+        ...txParams,
+        recipients: txParams?.recipients?.length ? txParams.recipients : intentRecipients,
+    };
+    // Fall back to intent.intentType when txParams.type is not explicitly set.
+    // Staking wallets call signTransaction without txParams, so the type lives only in the intent.
+    const txType = effectiveTxParams.type ?? txRequest.intent?.intentType ?? '';
+    // Propagate the resolved type so downstream callers
+    if (!effectiveTxParams.type && txType) {
+        effectiveTxParams.type = txType;
+    }
+    // Propagate stakingRequestId from intent into effectiveTxParams so verifyTssTransaction
+    // overrides can bypass the no-recipient guard without needing access to txRequest directly.
+    const intentStakingRequestId = txRequest.intent?.stakingRequestId;
+    if (intentStakingRequestId && !effectiveTxParams.stakingRequestId) {
+        effectiveTxParams.stakingRequestId = intentStakingRequestId;
+    }
+    // All staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) carry
+    // stakingRequestId as a required field on BaseStakeIntent (@bitgo/public-types).
+    // Use its presence as a generic staking signal — no need to enumerate every intentType.
+    const isStakingIntent = !!txRequest.intent?.stakingRequestId;
+    // buildParams.type from the wallet UI is PascalCase ('Import'); intent.intentType from WP
+    // is lowercase ('import'). Either may be the source of truth depending on the signing path.
+    const intentType = txRequest.intent?.intentType ?? '';
+    if (!effectiveTxParams.recipients?.length &&
+        !isStakingIntent &&
+        !exports.NO_RECIPIENT_TX_TYPES.has(txType) &&
+        !exports.NO_RECIPIENT_TX_TYPES.has(intentType)) {
+        throw new errors_1.InvalidTransactionError('Recipient details are required to verify this transaction before signing. Pass txParams with at least one recipient.');
+    }
+    return effectiveTxParams;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipientUtils.js","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/recipientUtils.ts"],"names":[],"mappings":";;;AAiIA,4DA8DC;AA9LD,yCAAuD;AAGvD;;;;;;;;;;;;;GAaG;AACU,QAAA,qBAAqB,GAAG,IAAI,GAAG,CAAC;IAC3C,cAAc;IACd,cAAc;IACd,WAAW;IACX,eAAe;IACf,eAAe;IACf,aAAa;IACb,aAAa;IACb,aAAa;IACb,aAAa;IACb,cAAc;IACd,cAAc;IACd,UAAU;IACV,gFAAgF;IAChF,aAAa;IACb,aAAa;IACb,cAAc;IACd,2EAA2E;IAC3E,6EAA6E;IAC7E,uEAAuE;IACvE,8EAA8E;IAC9E,+EAA+E;IAC/E,+DAA+D;IAC/D,6EAA6E;IAC7E,uBAAuB;IACvB,YAAY;IACZ,aAAa;IACb,cAAc;IACd,eAAe;IACf,uFAAuF;IACvF,uFAAuF;IACvF,2CAA2C;IAC3C,aAAa;IACb,MAAM;IACN,QAAQ;IACR,gBAAgB;IAChB,mEAAmE;IACnE,cAAc;IAEd,0FAA0F;IAC1F,+DAA+D;IAC/D,UAAU;IACV,YAAY;IACZ,iBAAiB;IAEjB,8BAA8B;IAC9B,OAAO;IACP,SAAS;IACT,mBAAmB;IACnB,qBAAqB;IACrB,eAAe;IACf,eAAe;IACf,WAAW;IAEX,sFAAsF;IACtF,OAAO;IACP,mBAAmB;IAEnB,eAAe;IACf,wHAAwH;IACxH,gBAAgB;IAChB,gBAAgB;IAChB,wBAAwB;IACxB,wBAAwB;IACxB,oBAAoB;IACpB,0BAA0B;IAC1B,eAAe;IACf,kCAAkC;IAClC,mCAAmC;IACnC,mCAAmC;IACnC,oCAAoC;IAEpC,QAAQ;IAER,6EAA6E;IAC7E,uEAAuE;IACvE,wEAAwE;IACxE,+DAA+D;IAC/D,QAAQ;IACR,WAAW;IAEX,kEAAkE;IAClE,YAAY;IAEZ,wDAAwD;IACxD,WAAW;CACZ,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,wBAAwB,CACtC,SAAoB,EACpB,QAAuC,EACvC,SAAkB;IAElB,MAAM,gBAAgB,GAAI,SAAS,CAAC,MAA0B,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC,eAAe,EAAE,EAAE;QAClG,2EAA2E;QAC3E,uEAAuE;QACvE,MAAM,EAAE,MAAM,EAAE,GAAG,eAAe,CAAC,MAAM,CAAC;QAC1C,MAAM,SAAS,GACb,eAAe,CAAC,SAAS,EAAE,SAAS;YACpC,CAAC,SAAS,KAAK,SAAS,IAAI,MAAM,IAAI,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACnF,OAAO;YACL,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,OAAO;YACxC,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK;YACpC,IAAI,EAAE,eAAe,CAAC,IAAI;YAC1B,GAAG,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC;SAChC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,iBAAiB,GAAsB;QAC3C,GAAG,QAAQ;QACX,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,gBAAgB;KAClF,CAAC;IAEF,2EAA2E;IAC3E,+FAA+F;IAC/F,MAAM,MAAM,GAAG,iBAAiB,CAAC,IAAI,IAAK,SAAS,CAAC,MAA0B,EAAE,UAAU,IAAI,EAAE,CAAC;IAEjG,oDAAoD;IACpD,IAAI,CAAC,iBAAiB,CAAC,IAAI,IAAI,MAAM,EAAE,CAAC;QACtC,iBAAiB,CAAC,IAAI,GAAG,MAAM,CAAC;IAClC,CAAC;IAED,wFAAwF;IACxF,4FAA4F;IAC5F,MAAM,sBAAsB,GAAI,SAAS,CAAC,MAA0B,EAAE,gBAAgB,CAAC;IACvF,IAAI,sBAAsB,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,CAAC;QAClE,iBAAiB,CAAC,gBAAgB,GAAG,sBAAsB,CAAC;IAC9D,CAAC;IAED,gFAAgF;IAChF,iFAAiF;IACjF,wFAAwF;IACxF,MAAM,eAAe,GAAG,CAAC,CAAE,SAAS,CAAC,MAA0B,EAAE,gBAAgB,CAAC;IAElF,0FAA0F;IAC1F,4FAA4F;IAC5F,MAAM,UAAU,GAAI,SAAS,CAAC,MAA0B,EAAE,UAAU,IAAI,EAAE,CAAC;IAE3E,IACE,CAAC,iBAAiB,CAAC,UAAU,EAAE,MAAM;QACrC,CAAC,eAAe;QAChB,CAAC,6BAAqB,CAAC,GAAG,CAAC,MAAM,CAAC;QAClC,CAAC,6BAAqB,CAAC,GAAG,CAAC,UAAU,CAAC,EACtC,CAAC;QACD,MAAM,IAAI,gCAAuB,CAC/B,sHAAsH,CACvH,CAAC;IACJ,CAAC;IAED,OAAO,iBAAiB,CAAC;AAC3B,CAAC","sourcesContent":["import { TransactionParams } from '../../baseCoin';\nimport { InvalidTransactionError } from '../../errors';\nimport { PopulatedIntent, TxRequest } from './baseTypes';\n\n/**\n * Transaction types that legitimately carry no explicit recipients.\n * These are the intentType strings as stored in TxRequest.intent.intentType by WP.\n * verifyTransaction handles no-recipient validation for these internally.\n * Mirrors the bypass list in abstractEthLikeNewCoins.ts verifyTssTransaction.\n *\n * ECDSA types: acceleration, fillNonce, transferToken, tokenApproval, consolidate,\n *              bridgeFunds, enableToken, customTx, wrapApprove, wrap, unwrap,\n *              finalizeUnwrap, contractCall\n * BSC/BNB delegation-based staking: delegate, undelegate, switchValidator\n * CELO/ETH lock-based staking: stake, unstake, stakeWithCallData, unstakeWithCallData,\n *              transferStake, increaseStake, goUnstake\n * Claim rewards (BSC, CELO — TRX/SOL use EdDSA and are unaffected): claim, stakeClaimRewards\n */\nexport const NO_RECIPIENT_TX_TYPES = new Set([\n  // ECDSA types\n  'acceleration',\n  'fillNonce',\n  'transferToken',\n  'tokenApproval',\n  'consolidate',\n  'bridgeFunds',\n  'enableToken',\n  'enabletoken',\n  'disableToken',\n  'disabletoken',\n  'customTx',\n  // DeFi vault operations — recipients/calldata built server-side from defiParams\n  'defiApprove',\n  'defiDeposit',\n  'defiWithdraw',\n  // Native wrap/unwrap (WETH9 deposit()/withdraw()) — calldata and the WETH9\n  // address are resolved server-side from the vault binding, so no recipients.\n  // Registered in BOTH spellings on purpose: this set is matched against\n  // txParams.type, which is buildParams.type (camelCase, from wallet.sendMany),\n  // AND against intent.intentType (kebab-case, as WP persists it). Signing paths\n  // that carry no txParams — notably pendingApproval.approve() →\n  // recreateTxRequest() → signTxRequest() with no txParams — only ever see the\n  // kebab-case spelling.\n  'wrapNative',\n  'wrap-native',\n  'unwrapNative',\n  'unwrap-native',\n  // ERC-7984 shield/unshield: approve/wrap/unwrap calldata is built server-side from the\n  // intent, and finalizeUnwrap txnReqs are WP-created at READY_TO_FINALIZE (client signs\n  // only) — none carry SDK-level recipients.\n  'wrapApprove',\n  'wrap',\n  'unwrap',\n  'finalizeUnwrap',\n  // Smart contract invocations with no explicit SDK-level recipients\n  'contractCall',\n\n  // BSC/BNB delegation-based staking — intentType strings from TxRequest.intent.intentType.\n  // Note: SOL solDelegateIntent also uses intentType \"delegate\".\n  'delegate',\n  'undelegate',\n  'switchValidator',\n\n  // CELO/ETH lock-based staking\n  'stake',\n  'unstake',\n  'stakeWithCallData',\n  'unstakeWithCallData',\n  'transferStake',\n  'increaseStake',\n  'goUnstake',\n\n  // Claim rewards — BSC and CELO (TRX/SOL/Cosmos use EdDSA, not affected by this guard)\n  'claim',\n  'stakeClaimRewards',\n\n  'createAccount',\n  // Canton operations with no SDK-level recipients. Canton.verifyTransaction validates these from the transaction itself.\n  'transferAccept',\n  'transferReject',\n  'transferOfferWithdrawn',\n  'cosignDelegationAccept',\n  'allocationAllocate',\n  'allocationOfferWithdrawn',\n  'cantonCommand',\n  'cantonEndInvestorOnboardingOffer',\n  'cantonEndInvestorOnboardingAccept',\n  'cantonEndInvestorOnboardingReject',\n  'cantonParticipantOnboardingRequest',\n\n  'pledge',\n\n  // Avalanche / Flare cross-chain atomic imports — recipients are not supplied\n  // by the client because the import consumes UTXOs already owned by the\n  // wallet; the destination address is the wallet itself. WP issues these\n  // with intentType 'import' (P-chain) or 'importtoc' (C-chain).\n  'import',\n  'importtoc',\n\n  // SOL: deactivate stake account — no on-chain transfer recipient.\n  'deactivate',\n\n  // SOL: authorize stake account — no transfer recipient.\n  'authorize',\n]);\n\n/**\n * Resolves the effective txParams for TSS signing recipient verification.\n *\n * For smart contract interactions, recipients live in txRequest.intent.recipients\n * (native amount = 0, so buildParams is empty). Falls back to intent recipients\n * mapped to ITransactionRecipient shape when txParams.recipients is absent.\n *\n * tokenName is derived from tokenData.tokenName when present, otherwise from\n * amount.symbol when chainName is provided and symbol differs from it.\n *\n * Staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) are\n * identified generically by the presence of `stakingRequestId` on the intent —\n * a required field on BaseStakeIntent in @bitgo/public-types. These intents\n * have no txParams recipients by design; validation is done at the coin layer.\n *\n * Throws InvalidTransactionError if no recipients can be resolved and the\n * transaction is not a known no-recipient type.\n *\n * @param txRequest - the transaction request containing the persisted intent\n * @param txParams - the caller-supplied transaction parameters (may be undefined)\n * @param chainName - the base chain name (e.g. 'sol', 'tsol') used to exclude\n *   native-coin transfers from tokenName; pass baseCoin.getChain()\n */\nexport function resolveEffectiveTxParams(\n  txRequest: TxRequest,\n  txParams: TransactionParams | undefined,\n  chainName?: string\n): TransactionParams {\n  const intentRecipients = (txRequest.intent as PopulatedIntent)?.recipients?.map((intentRecipient) => {\n    // Prefer tokenData.tokenName; fall back to amount.symbol when chainName is\n    // provided and differs from it. When absent, skip the symbol fallback.\n    const { symbol } = intentRecipient.amount;\n    const tokenName =\n      intentRecipient.tokenData?.tokenName ||\n      (chainName !== undefined && symbol && symbol !== chainName ? symbol : undefined);\n    return {\n      address: intentRecipient.address.address,\n      amount: intentRecipient.amount.value,\n      data: intentRecipient.data,\n      ...(tokenName && { tokenName }),\n    };\n  });\n\n  const effectiveTxParams: TransactionParams = {\n    ...txParams,\n    recipients: txParams?.recipients?.length ? txParams.recipients : intentRecipients,\n  };\n\n  // Fall back to intent.intentType when txParams.type is not explicitly set.\n  // Staking wallets call signTransaction without txParams, so the type lives only in the intent.\n  const txType = effectiveTxParams.type ?? (txRequest.intent as PopulatedIntent)?.intentType ?? '';\n\n  // Propagate the resolved type so downstream callers\n  if (!effectiveTxParams.type && txType) {\n    effectiveTxParams.type = txType;\n  }\n\n  // Propagate stakingRequestId from intent into effectiveTxParams so verifyTssTransaction\n  // overrides can bypass the no-recipient guard without needing access to txRequest directly.\n  const intentStakingRequestId = (txRequest.intent as PopulatedIntent)?.stakingRequestId;\n  if (intentStakingRequestId && !effectiveTxParams.stakingRequestId) {\n    effectiveTxParams.stakingRequestId = intentStakingRequestId;\n  }\n\n  // All staking intents (BSC delegate/undelegate, CELO stake/unstake, etc.) carry\n  // stakingRequestId as a required field on BaseStakeIntent (@bitgo/public-types).\n  // Use its presence as a generic staking signal — no need to enumerate every intentType.\n  const isStakingIntent = !!(txRequest.intent as PopulatedIntent)?.stakingRequestId;\n\n  // buildParams.type from the wallet UI is PascalCase ('Import'); intent.intentType from WP\n  // is lowercase ('import'). Either may be the source of truth depending on the signing path.\n  const intentType = (txRequest.intent as PopulatedIntent)?.intentType ?? '';\n\n  if (\n    !effectiveTxParams.recipients?.length &&\n    !isStakingIntent &&\n    !NO_RECIPIENT_TX_TYPES.has(txType) &&\n    !NO_RECIPIENT_TX_TYPES.has(intentType)\n  ) {\n    throw new InvalidTransactionError(\n      'Recipient details are required to verify this transaction before signing. Pass txParams with at least one recipient.'\n    );\n  }\n\n  return effectiveTxParams;\n}\n"]}

package/dist/src/bitgo/utils/tss/redpallas/SMC/utils.d.ts

@@ -0,0 +1,29 @@
+import { RedpallasBitgoToOVC1Round1Response, RedpallasBitgoToOVC1Round2Response, RedpallasMPCv2KeyGenRound1Response, RedpallasMPCv2KeyGenRound2Response, RedpallasOVC1ToBitgoRound1Payload, RedpallasOVC2ToBitgoRound2Payload } from '@bitgo/public-types';
+import { IBaseCoin } from '../../../../baseCoin';
+import { BitGoBase } from '../../../../bitgoBase';
+import { Keychain } from '../../../..';
+import { RedpallasMPCv2KeyGenSendFn } from '../redpallasMPCv2KeyGenSender';
+/**
+ * Custodial (SMC/OVC) DKG-only key generation for the Zcash Orchard shielded pool (RedPallas).
+ *
+ * Mirrors for both custodial and SMC wallet
+ * ceremonies driven by external OVC (offline vault console) clients: round1/round2 payloads are
+ * relayed from OVC1/OVC2 to BitGo and back. There is no round3 (no signing) - RedPallas MPS DKG
+ * completes key generation in 2 online rounds, same as EdDSA MPS DKG.
+ */
+export declare class RedpallasMPCv2SMCUtils {
+    private bitgo;
+    private baseCoin;
+    private MPCv2Utils;
+    constructor(bitgo: BitGoBase, baseCoin: IBaseCoin);
+    keyGenRound1(enterprise: string, payload: RedpallasOVC1ToBitgoRound1Payload): Promise<RedpallasBitgoToOVC1Round1Response>;
+    keyGenRound2(enterprise: string, payload: RedpallasOVC2ToBitgoRound2Payload): Promise<RedpallasBitgoToOVC1Round2Response>;
+    keyGenRound1BySender(senderFn: RedpallasMPCv2KeyGenSendFn<RedpallasMPCv2KeyGenRound1Response>, payload: RedpallasOVC1ToBitgoRound1Payload): Promise<RedpallasBitgoToOVC1Round1Response>;
+    keyGenRound2BySender(senderFn: RedpallasMPCv2KeyGenSendFn<RedpallasMPCv2KeyGenRound2Response>, payload: RedpallasOVC2ToBitgoRound2Payload): Promise<RedpallasBitgoToOVC1Round2Response>;
+    uploadClientKeys(bitgoKeyId: string, userCommonKeychain: string, backupCommonKeychain: string): Promise<{
+        userKeychain: Keychain;
+        backupKeychain: Keychain;
+        bitgoKeychain: Keychain;
+    }>;
+}
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/bitgo/utils/tss/redpallas/SMC/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../../src/bitgo/utils/tss/redpallas/SMC/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,kCAAkC,EAClC,kCAAkC,EAElC,kCAAkC,EAClC,kCAAkC,EAClC,iCAAiC,EACjC,iCAAiC,EAClC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAgB,QAAQ,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EAAE,0BAA0B,EAAsC,MAAM,+BAA+B,CAAC;AAE/G;;;;;;;GAOG;AACH,qBAAa,sBAAsB;IAGrB,OAAO,CAAC,KAAK;IAAa,OAAO,CAAC,QAAQ;IAFtD,OAAO,CAAC,UAAU,CAAsB;gBAEpB,KAAK,EAAE,SAAS,EAAU,QAAQ,EAAE,SAAS;IAIpD,YAAY,CACvB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAIjC,YAAY,CACvB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAIjC,oBAAoB,CAC/B,QAAQ,EAAE,0BAA0B,CAAC,kCAAkC,CAAC,EACxE,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAwCjC,oBAAoB,CAC/B,QAAQ,EAAE,0BAA0B,CAAC,kCAAkC,CAAC,EACxE,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,kCAAkC,CAAC;IAsDjC,gBAAgB,CAC3B,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,MAAM,EAC1B,oBAAoB,EAAE,MAAM,GAC3B,OAAO,CAAC;QAAE,YAAY,EAAE,QAAQ,CAAC;QAAC,cAAc,EAAE,QAAQ,CAAC;QAAC,aAAa,EAAE,QAAQ,CAAA;KAAE,CAAC;CA8B1F"}