@bitgo/sdk-core 38.21.0 → 38.22.0

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

@@ -12,6 +12,7 @@ export { ITssUtils, IEddsaUtils, TxRequest, EddsaUnsignedTransaction } from './e
 export * as BaseTssUtils from './baseTSSUtils';
 export * from './baseTypes';
 export * from './addressVerification';
+export * from './keyVerification';
 export * from './preHashedSignable';
 export * from './recipientUtils';
 export * from './keyShareEnvelope';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/index.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,EAAE,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,KAAK,UAAU,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,UAAU,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,cAAc,MAAM,aAAa,CAAC;AAE9C,iCAAiC;AACjC,OAAO,EAAE,QAAQ,EAAE,CAAC;AACpB,sCAAsC;AACtC,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,OAAO,EAAE,eAAe,EAAE,CAAC;AAG3B,+CAA+C;AAC/C,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAEtF,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAC/C,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/index.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,EAAE,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,KAAK,UAAU,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,UAAU,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,cAAc,MAAM,aAAa,CAAC;AAE9C,iCAAiC;AACjC,OAAO,EAAE,QAAQ,EAAE,CAAC;AACpB,sCAAsC;AACtC,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,OAAO,EAAE,eAAe,EAAE,CAAC;AAG3B,+CAA+C;AAC/C,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAEtF,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAC/C,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC"}

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

@@ -47,8 +47,9 @@ exports.RedpallasUtils = __importStar(require("./redpallas"));
 exports.BaseTssUtils = __importStar(require("./baseTSSUtils"));
 __exportStar(require("./baseTypes"), exports);
 __exportStar(require("./addressVerification"), exports);
+__exportStar(require("./keyVerification"), exports);
 __exportStar(require("./preHashedSignable"), exports);
 __exportStar(require("./recipientUtils"), exports);
 __exportStar(require("./keyShareEnvelope"), exports);
 __exportStar(require("./signableConsistency"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYml0Z28vdXRpbHMvdHNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlEQUFtRTtBQU0xRCxtQkFORixlQUFRLENBTUU7QUFFUiw4RkFSVSxxQkFBYSxPQVFWO0FBQ2IsZ0dBVHlCLHVCQUFlLE9BU3pCO0FBUnhCLHNEQUFzQztBQUN0QyxzREFBc0M7QUFDdEMsOERBQThDO0FBWTlDLCtEQUErQztBQUMvQyw4Q0FBNEI7QUFDNUIsd0RBQXNDO0FBQ3RDLHNEQUFvQztBQUNwQyxtREFBaUM7QUFDakMscURBQW1DO0FBQ25DLHdEQUFzQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBUc3NVdGlscywgeyBUc3NVdGlsc1R5cGVzLCBFZGRzYVV0aWxzVHlwZXMgfSBmcm9tICcuL2VkZHNhJztcbmV4cG9ydCAqIGFzIEVDRFNBVXRpbHMgZnJvbSAnLi9lY2RzYSc7XG5leHBvcnQgKiBhcyBFRERTQVV0aWxzIGZyb20gJy4vZWRkc2EnO1xuZXhwb3J0ICogYXMgUmVkcGFsbGFzVXRpbHMgZnJvbSAnLi9yZWRwYWxsYXMnO1xuXG4vKiogQGRlcHJlY2F0ZWQgdXNlIEVERFNBVXRpbHMgKi9cbmV4cG9ydCB7IFRzc1V0aWxzIH07XG4vKiogQGRlcHJlY2F0ZWQgdXNlIEVERFNBVXRpbHNUeXBlcyAqL1xuZXhwb3J0IHsgVHNzVXRpbHNUeXBlcyB9O1xuZXhwb3J0IHsgRWRkc2FVdGlsc1R5cGVzIH07XG5cbi8vIGV4cG9ydGluZyB0aGlzIHR5cGVzIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5LlxuLyoqIEBkZXByZWNhdGVkIHVzZSBFRERTQVV0aWxzLjx0eXBlL21ldGhvZD4gKi9cbmV4cG9ydCB7IElUc3NVdGlscywgSUVkZHNhVXRpbHMsIFR4UmVxdWVzdCwgRWRkc2FVbnNpZ25lZFRyYW5zYWN0aW9uIH0gZnJvbSAnLi9lZGRzYSc7XG5cbmV4cG9ydCAqIGFzIEJhc2VUc3NVdGlscyBmcm9tICcuL2Jhc2VUU1NVdGlscyc7XG5leHBvcnQgKiBmcm9tICcuL2Jhc2VUeXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2FkZHJlc3NWZXJpZmljYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9wcmVIYXNoZWRTaWduYWJsZSc7XG5leHBvcnQgKiBmcm9tICcuL3JlY2lwaWVudFV0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4va2V5U2hhcmVFbnZlbG9wZSc7XG5leHBvcnQgKiBmcm9tICcuL3NpZ25hYmxlQ29uc2lzdGVuY3knO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYml0Z28vdXRpbHMvdHNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlEQUFtRTtBQU0xRCxtQkFORixlQUFRLENBTUU7QUFFUiw4RkFSVSxxQkFBYSxPQVFWO0FBQ2IsZ0dBVHlCLHVCQUFlLE9BU3pCO0FBUnhCLHNEQUFzQztBQUN0QyxzREFBc0M7QUFDdEMsOERBQThDO0FBWTlDLCtEQUErQztBQUMvQyw4Q0FBNEI7QUFDNUIsd0RBQXNDO0FBQ3RDLG9EQUFrQztBQUNsQyxzREFBb0M7QUFDcEMsbURBQWlDO0FBQ2pDLHFEQUFtQztBQUNuQyx3REFBc0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgVHNzVXRpbHMsIHsgVHNzVXRpbHNUeXBlcywgRWRkc2FVdGlsc1R5cGVzIH0gZnJvbSAnLi9lZGRzYSc7XG5leHBvcnQgKiBhcyBFQ0RTQVV0aWxzIGZyb20gJy4vZWNkc2EnO1xuZXhwb3J0ICogYXMgRUREU0FVdGlscyBmcm9tICcuL2VkZHNhJztcbmV4cG9ydCAqIGFzIFJlZHBhbGxhc1V0aWxzIGZyb20gJy4vcmVkcGFsbGFzJztcblxuLyoqIEBkZXByZWNhdGVkIHVzZSBFRERTQVV0aWxzICovXG5leHBvcnQgeyBUc3NVdGlscyB9O1xuLyoqIEBkZXByZWNhdGVkIHVzZSBFRERTQVV0aWxzVHlwZXMgKi9cbmV4cG9ydCB7IFRzc1V0aWxzVHlwZXMgfTtcbmV4cG9ydCB7IEVkZHNhVXRpbHNUeXBlcyB9O1xuXG4vLyBleHBvcnRpbmcgdGhpcyB0eXBlcyBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eS5cbi8qKiBAZGVwcmVjYXRlZCB1c2UgRUREU0FVdGlscy48dHlwZS9tZXRob2Q+ICovXG5leHBvcnQgeyBJVHNzVXRpbHMsIElFZGRzYVV0aWxzLCBUeFJlcXVlc3QsIEVkZHNhVW5zaWduZWRUcmFuc2FjdGlvbiB9IGZyb20gJy4vZWRkc2EnO1xuXG5leHBvcnQgKiBhcyBCYXNlVHNzVXRpbHMgZnJvbSAnLi9iYXNlVFNTVXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9iYXNlVHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9hZGRyZXNzVmVyaWZpY2F0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4va2V5VmVyaWZpY2F0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vcHJlSGFzaGVkU2lnbmFibGUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZWNpcGllbnRVdGlscyc7XG5leHBvcnQgKiBmcm9tICcuL2tleVNoYXJlRW52ZWxvcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zaWduYWJsZUNvbnNpc3RlbmN5JztcbiJdfQ==

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

@@ -0,0 +1,45 @@
+import { UserSigningMaterial } from '../../tss/eddsa/types';
+/**
+ * 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`)
+ */
+export declare function parseEddsaUserSigningMaterial(prv: string): UserSigningMaterial;
+/**
+ * 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
+ */
+export declare function eddsaUserSigningMaterialMatchesCommonKeychain(params: {
+    prv: string;
+    commonKeychain: string;
+}): Promise<boolean>;
+//# sourceMappingURL=keyVerification.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyVerification.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/keyVerification.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAiE5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAY9E;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,6CAA6C,CAAC,MAAM,EAAE;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBnB"}

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":"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","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/recipientUtils.d.ts

@@ -1,4 +1,4 @@
-import { TransactionParams, VerifyTransactionOptions } from '../../baseCoin';
+import { TransactionParams } from '../../baseCoin';
 import { TxRequest } from './baseTypes';
 /**
  * Transaction types that legitimately carry no explicit recipients.
@@ -39,17 +39,4 @@ export declare const NO_RECIPIENT_TX_TYPES: Set<string>;
  *   native-coin transfers from tokenName; pass baseCoin.getChain()
  */
 export declare function resolveEffectiveTxParams(txRequest: TxRequest, txParams: TransactionParams | undefined, chainName?: string): TransactionParams;
-/**
- * Resolves the verifyTransaction options for signing-time verification of a TSS txRequest.
- *
- * Consolidation intent recipients are a server-generated, build-time balance snapshot that drifts
- * from the swept amount, so they are not backfilled; sweep-to-base-address is verified instead,
- * mirroring wallet.sendAccountConsolidations.
- *
- * @param txRequest - the transaction request containing the persisted intent
- * @param txHex - the unsigned transaction to verify
- * @param txParams - the caller-supplied transaction parameters (may be undefined)
- * @param chainName - the base chain name; pass baseCoin.getChain()
- */
-export declare function resolveTssVerifyTransactionOptions(txRequest: TxRequest, txHex: string, txParams: TransactionParams | undefined, chainName: string): Pick<VerifyTransactionOptions, 'txPrebuild' | 'txParams' | 'verification'>;
 //# sourceMappingURL=recipientUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"recipientUtils.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/recipientUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE7E,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;AAOD;;;;;;;;;;;GAWG;AACH,wBAAgB,kCAAkC,CAChD,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EACvC,SAAS,EAAE,MAAM,GAChB,IAAI,CAAC,wBAAwB,EAAE,YAAY,GAAG,UAAU,GAAG,cAAc,CAAC,CAS5E"}
+{"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

@@ -1,42 +1,7 @@
 "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;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NO_RECIPIENT_TX_TYPES = void 0;
 exports.resolveEffectiveTxParams = resolveEffectiveTxParams;
-exports.resolveTssVerifyTransactionOptions = resolveTssVerifyTransactionOptions;
-const t = __importStar(require("io-ts"));
 const errors_1 = require("../../errors");
 /**
  * Transaction types that legitimately carry no explicit recipients.
@@ -200,30 +165,4 @@ function resolveEffectiveTxParams(txRequest, txParams, chainName) {
     }
     return effectiveTxParams;
 }
-const ConsolidateIntent = t.intersection([
-    t.type({ intentType: t.literal('consolidate') }),
-    t.partial({ consolidateId: t.string }),
-]);
-/**
- * Resolves the verifyTransaction options for signing-time verification of a TSS txRequest.
- *
- * Consolidation intent recipients are a server-generated, build-time balance snapshot that drifts
- * from the swept amount, so they are not backfilled; sweep-to-base-address is verified instead,
- * mirroring wallet.sendAccountConsolidations.
- *
- * @param txRequest - the transaction request containing the persisted intent
- * @param txHex - the unsigned transaction to verify
- * @param txParams - the caller-supplied transaction parameters (may be undefined)
- * @param chainName - the base chain name; pass baseCoin.getChain()
- */
-function resolveTssVerifyTransactionOptions(txRequest, txHex, txParams, chainName) {
-    if (ConsolidateIntent.is(txRequest.intent)) {
-        return {
-            txPrebuild: { txHex, consolidateId: txRequest.intent.consolidateId },
-            txParams: { ...txParams },
-            verification: { consolidationToBaseAddress: true },
-        };
-    }
-    return { txPrebuild: { txHex }, txParams: resolveEffectiveTxParams(txRequest, txParams, chainName) };
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipientUtils.js","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/recipientUtils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as t from 'io-ts';\nimport { TransactionParams, VerifyTransactionOptions } 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\nconst ConsolidateIntent = t.intersection([\n  t.type({ intentType: t.literal('consolidate') }),\n  t.partial({ consolidateId: t.string }),\n]);\n\n/**\n * Resolves the verifyTransaction options for signing-time verification of a TSS txRequest.\n *\n * Consolidation intent recipients are a server-generated, build-time balance snapshot that drifts\n * from the swept amount, so they are not backfilled; sweep-to-base-address is verified instead,\n * mirroring wallet.sendAccountConsolidations.\n *\n * @param txRequest - the transaction request containing the persisted intent\n * @param txHex - the unsigned transaction to verify\n * @param txParams - the caller-supplied transaction parameters (may be undefined)\n * @param chainName - the base chain name; pass baseCoin.getChain()\n */\nexport function resolveTssVerifyTransactionOptions(\n  txRequest: TxRequest,\n  txHex: string,\n  txParams: TransactionParams | undefined,\n  chainName: string\n): Pick<VerifyTransactionOptions, 'txPrebuild' | 'txParams' | 'verification'> {\n  if (ConsolidateIntent.is(txRequest.intent)) {\n    return {\n      txPrebuild: { txHex, consolidateId: txRequest.intent.consolidateId },\n      txParams: { ...txParams },\n      verification: { consolidationToBaseAddress: true },\n    };\n  }\n  return { txPrebuild: { txHex }, txParams: resolveEffectiveTxParams(txRequest, txParams, chainName) };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipientUtils.js","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/recipientUtils.ts"],"names":[],"mappings":"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","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/wallet/iWallet.d.ts

@@ -370,8 +370,6 @@ export interface WalletSignTransactionOptions extends WalletSignBaseOptions {
         txParams: TransactionParams;
         verification?: VerificationOptions;
     };
-    /** Populated by wallet.verifyTxParams TSS path so signing uses the same txRequest that was verified. */
-    resolvedTxRequestForSigning?: TxRequest;
     [index: string]: unknown;
 }
 interface WalletSignMessageBase extends WalletSignBaseOptions {
@@ -400,6 +398,21 @@ export interface GetUserPrvOptions {
     coldDerivationSeed?: string;
     walletPassphrase?: string;
 }
+export interface VerifyKeyOptions {
+    /**
+     * User TSS signing material: the same string that would be passed as `prv` when signing a
+     * transaction. TSS EdDSA (MPCv1) wallets only.
+     */
+    prv: string;
+    reqId?: IRequestTracer;
+}
+export interface VerifyKeyResult {
+    /**
+     * Whether the signing material recombines to the wallet's commonKeychain. A consistency
+     * check, not proof of possession — never use it as an authorization signal.
+     */
+    match: boolean;
+}
 export interface WalletCoinSpecific {
     tokenFlushThresholds?: any;
     addressVersion?: number;
@@ -1184,6 +1197,7 @@ export interface IWallet {
     prebuildTransaction(params?: PrebuildTransactionOptions): Promise<PrebuildTransactionResult>;
     signTransaction(params?: WalletSignTransactionOptions): Promise<SignedTransaction>;
     getUserPrv(params?: GetUserPrvOptions): Promise<string>;
+    verifyKey(params: VerifyKeyOptions): Promise<VerifyKeyResult>;
     prebuildAndSignTransaction(params?: PrebuildAndSignTransactionOptions): Promise<SignedTransaction>;
     signAndSendTxRequest(params?: SignAndSendTxRequestOptions): Promise<SignedTransaction>;
     accelerateTransaction(params?: AccelerateTransactionOptions): Promise<any>;