@bitgo-beta/sdk-core 8.2.1-beta.198 → 8.2.1-beta.1981

package/dist/src/bitgo/wallet/safeKeychain.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @prettier
+ */
+import { BitGoBase } from '../bitgoBase';
+import { IKeychains, Keychain, KeychainWithEncryptedPrv } from '../keychain';
+export declare class InvalidRootKeychainSourceError extends Error {
+    constructor(id: string, source: string | undefined);
+}
+/** Thrown when hardened derivation does not match the registered child public key. */
+export declare class SafeDerivedPublicKeyMismatchError extends Error {
+    constructor(walletId: string, expectedPub: string, derivedPub: string);
+}
+/** Thrown when owner signing is not implemented for this safe slot (TSS, ed25519 multisig, …). */
+export declare class SafeOwnerSigningNotImplementedError extends Error {
+    constructor(walletId: string, detail: string);
+}
+/**
+ * True when this is the safe minter's user key: wallet is in a safe, the key
+ * has a parent root, and there is no child-level encryptedPrv (sharees have one).
+ */
+export declare function isSafeChildPublicOnlyKeychain(walletSafeId: string | undefined, keychain: Keychain | undefined): keychain is Keychain & {
+    parent: string;
+};
+/**
+ * Fetch the root user keychain for a safe child key.
+ * Requires `source === 'user'` so a misconfigured parent fails early.
+ */
+export declare function fetchRootKeychainForSafeChild(keychains: IKeychains, childKeychain: Keychain): Promise<KeychainWithEncryptedPrv>;
+export interface ResolveSafeOwnerSigningPrvParams {
+    bitgo: BitGoBase;
+    keychains: IKeychains;
+    walletId: string;
+    /** Onchain secp256k1: hardened-derive and verify pub. Other slots throw. */
+    multisigType: string | undefined;
+    coinFamily: string;
+    childKeychain: Keychain;
+    walletPassphrase: string;
+    /** When already fetched (passphrase preflight), skip a second GET. */
+    rootKeychain?: KeychainWithEncryptedPrv;
+}
+/**
+ * Resolve signing material for a safe owner (child key has no encryptedPrv).
+ *
+ * Onchain secp256k1: decrypt root → walk sequential `m/<n>'` children until the
+ * registered pub matches (the mint index is not stored on the child key).
+ * TSS and ed25519 onchain: throw — do not return root material or BIP32-derive the wrong curve.
+ *
+ * Do not use for wallet sharing — that must not receive root key material.
+ * Call only when `isSafeChildPublicOnlyKeychain` is true.
+ */
+export declare function resolveSafeOwnerSigningPrv(params: ResolveSafeOwnerSigningPrvParams): Promise<string>;
+//# sourceMappingURL=safeKeychain.d.ts.map

package/dist/src/bitgo/wallet/safeKeychain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeKeychain.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/safeKeychain.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAA6B,UAAU,EAAE,QAAQ,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAIxG,qBAAa,8BAA+B,SAAQ,KAAK;gBAC3C,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS;CAOnD;AAED,sFAAsF;AACtF,qBAAa,iCAAkC,SAAQ,KAAK;gBAC9C,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAOtE;AAED,kGAAkG;AAClG,qBAAa,mCAAoC,SAAQ,KAAK;gBAChD,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAI7C;AAKD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,QAAQ,EAAE,QAAQ,GAAG,SAAS,GAC7B,QAAQ,IAAI,QAAQ,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAE3C;AAED;;;GAGG;AACH,wBAAsB,6BAA6B,CACjD,SAAS,EAAE,UAAU,EACrB,aAAa,EAAE,QAAQ,GACtB,OAAO,CAAC,wBAAwB,CAAC,CAYnC;AAED,MAAM,WAAW,gCAAgC;IAC/C,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,EAAE,UAAU,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,QAAQ,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,YAAY,CAAC,EAAE,wBAAwB,CAAC;CACzC;AAED;;;;;;;;;GASG;AACH,wBAAsB,0BAA0B,CAAC,MAAM,EAAE,gCAAgC,GAAG,OAAO,CAAC,MAAM,CAAC,CAkC1G"}

package/dist/src/bitgo/wallet/safeKeychain.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeOwnerSigningNotImplementedError = exports.SafeDerivedPublicKeyMismatchError = exports.InvalidRootKeychainSourceError = void 0;
+exports.isSafeChildPublicOnlyKeychain = isSafeChildPublicOnlyKeychain;
+exports.fetchRootKeychainForSafeChild = fetchRootKeychainForSafeChild;
+exports.resolveSafeOwnerSigningPrv = resolveSafeOwnerSigningPrv;
+const keychain_1 = require("../keychain");
+const safeDerivation_1 = require("../safe/safeDerivation");
+const errors_1 = require("../errors");
+class InvalidRootKeychainSourceError extends Error {
+    constructor(id, source) {
+        super(`Root keychain ${id} has source '${source ?? 'unknown'}'; expected 'user'. ` +
+            `Using a backup or BitGo root would fail at signing.`);
+        this.name = 'InvalidRootKeychainSourceError';
+    }
+}
+exports.InvalidRootKeychainSourceError = InvalidRootKeychainSourceError;
+/** Thrown when hardened derivation does not match the registered child public key. */
+class SafeDerivedPublicKeyMismatchError extends Error {
+    constructor(walletId, expectedPub, derivedPub) {
+        super(`Safe wallet ${walletId}: derived child public key does not match the registered user key. ` +
+            `Expected ${expectedPub}, got ${derivedPub}.`);
+        this.name = 'SafeDerivedPublicKeyMismatchError';
+    }
+}
+exports.SafeDerivedPublicKeyMismatchError = SafeDerivedPublicKeyMismatchError;
+/** Thrown when owner signing is not implemented for this safe slot (TSS, ed25519 multisig, …). */
+class SafeOwnerSigningNotImplementedError extends Error {
+    constructor(walletId, detail) {
+        super(`Safe wallet ${walletId}: ${detail}`);
+        this.name = 'SafeOwnerSigningNotImplementedError';
+    }
+}
+exports.SafeOwnerSigningNotImplementedError = SafeOwnerSigningNotImplementedError;
+/** ed25519 onchain multisig (slot ④). Needs SLIP-0010, not secp256k1 BIP32. */
+const ED25519_ONCHAIN_FAMILIES = new Set(['algo', 'xlm', 'hbar']);
+/**
+ * True when this is the safe minter's user key: wallet is in a safe, the key
+ * has a parent root, and there is no child-level encryptedPrv (sharees have one).
+ */
+function isSafeChildPublicOnlyKeychain(walletSafeId, keychain) {
+    return !!(walletSafeId && keychain?.parent && !keychain.encryptedPrv);
+}
+/**
+ * Fetch the root user keychain for a safe child key.
+ * Requires `source === 'user'` so a misconfigured parent fails early.
+ */
+async function fetchRootKeychainForSafeChild(keychains, childKeychain) {
+    if (!childKeychain.parent) {
+        throw new Error('childKeychain.parent is required to fetch the root keychain');
+    }
+    const root = await keychains.get({ id: childKeychain.parent });
+    if (root.source !== 'user') {
+        throw new InvalidRootKeychainSourceError(root.id, root.source);
+    }
+    if (!root.encryptedPrv) {
+        throw new Error(`root keychain ${root.id} does not have property encryptedPrv`);
+    }
+    return root;
+}
+/**
+ * Resolve signing material for a safe owner (child key has no encryptedPrv).
+ *
+ * Onchain secp256k1: decrypt root → walk sequential `m/<n>'` children until the
+ * registered pub matches (the mint index is not stored on the child key).
+ * TSS and ed25519 onchain: throw — do not return root material or BIP32-derive the wrong curve.
+ *
+ * Do not use for wallet sharing — that must not receive root key material.
+ * Call only when `isSafeChildPublicOnlyKeychain` is true.
+ */
+async function resolveSafeOwnerSigningPrv(params) {
+    const { bitgo, keychains, walletId, multisigType, coinFamily, childKeychain, walletPassphrase } = params;
+    if (multisigType !== 'onchain') {
+        throw new SafeOwnerSigningNotImplementedError(walletId, 'TSS owner signing from the root keyshare is not implemented. ' +
+            'Returning the root private key would expose material that can derive every child in this slot.');
+    }
+    if (ED25519_ONCHAIN_FAMILIES.has(coinFamily)) {
+        throw new SafeOwnerSigningNotImplementedError(walletId, `ed25519 multisig owner derivation (${coinFamily}) is not implemented; BIP32 would produce the wrong child key.`);
+    }
+    const rootKeychain = params.rootKeychain ?? (await fetchRootKeychainForSafeChild(keychains, childKeychain));
+    const rootPrv = await (0, keychain_1.decryptKeychainPrivateKey)(bitgo, rootKeychain, walletPassphrase);
+    if (!rootPrv) {
+        throw new errors_1.IncorrectPasswordError();
+    }
+    if (!childKeychain.pub) {
+        throw new Error(`Safe wallet ${walletId}: child keychain is missing pub for pre-sign verification`);
+    }
+    try {
+        const derived = (0, safeDerivation_1.deriveSafeChildHardenedMatchingPub)(rootPrv, childKeychain.pub);
+        return derived.prv;
+    }
+    catch (e) {
+        const detail = e instanceof Error ? e.message : String(e);
+        throw new SafeDerivedPublicKeyMismatchError(walletId, childKeychain.pub, detail);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safeKeychain.js","sourceRoot":"","sources":["../../../../src/bitgo/wallet/safeKeychain.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { BitGoBase } from '../bitgoBase';\nimport { decryptKeychainPrivateKey, IKeychains, Keychain, KeychainWithEncryptedPrv } from '../keychain';\nimport { deriveSafeChildHardenedMatchingPub } from '../safe/safeDerivation';\nimport { IncorrectPasswordError } from '../errors';\n\nexport class InvalidRootKeychainSourceError extends Error {\n  constructor(id: string, source: string | undefined) {\n    super(\n      `Root keychain ${id} has source '${source ?? 'unknown'}'; expected 'user'. ` +\n        `Using a backup or BitGo root would fail at signing.`\n    );\n    this.name = 'InvalidRootKeychainSourceError';\n  }\n}\n\n/** Thrown when hardened derivation does not match the registered child public key. */\nexport class SafeDerivedPublicKeyMismatchError extends Error {\n  constructor(walletId: string, expectedPub: string, derivedPub: string) {\n    super(\n      `Safe wallet ${walletId}: derived child public key does not match the registered user key. ` +\n        `Expected ${expectedPub}, got ${derivedPub}.`\n    );\n    this.name = 'SafeDerivedPublicKeyMismatchError';\n  }\n}\n\n/** Thrown when owner signing is not implemented for this safe slot (TSS, ed25519 multisig, …). */\nexport class SafeOwnerSigningNotImplementedError extends Error {\n  constructor(walletId: string, detail: string) {\n    super(`Safe wallet ${walletId}: ${detail}`);\n    this.name = 'SafeOwnerSigningNotImplementedError';\n  }\n}\n\n/** ed25519 onchain multisig (slot ④). Needs SLIP-0010, not secp256k1 BIP32. */\nconst ED25519_ONCHAIN_FAMILIES = new Set(['algo', 'xlm', 'hbar']);\n\n/**\n * True when this is the safe minter's user key: wallet is in a safe, the key\n * has a parent root, and there is no child-level encryptedPrv (sharees have one).\n */\nexport function isSafeChildPublicOnlyKeychain(\n  walletSafeId: string | undefined,\n  keychain: Keychain | undefined\n): keychain is Keychain & { parent: string } {\n  return !!(walletSafeId && keychain?.parent && !keychain.encryptedPrv);\n}\n\n/**\n * Fetch the root user keychain for a safe child key.\n * Requires `source === 'user'` so a misconfigured parent fails early.\n */\nexport async function fetchRootKeychainForSafeChild(\n  keychains: IKeychains,\n  childKeychain: Keychain\n): Promise<KeychainWithEncryptedPrv> {\n  if (!childKeychain.parent) {\n    throw new Error('childKeychain.parent is required to fetch the root keychain');\n  }\n  const root = await keychains.get({ id: childKeychain.parent });\n  if (root.source !== 'user') {\n    throw new InvalidRootKeychainSourceError(root.id, root.source);\n  }\n  if (!root.encryptedPrv) {\n    throw new Error(`root keychain ${root.id} does not have property encryptedPrv`);\n  }\n  return root as KeychainWithEncryptedPrv;\n}\n\nexport interface ResolveSafeOwnerSigningPrvParams {\n  bitgo: BitGoBase;\n  keychains: IKeychains;\n  walletId: string;\n  /** Onchain secp256k1: hardened-derive and verify pub. Other slots throw. */\n  multisigType: string | undefined;\n  coinFamily: string;\n  childKeychain: Keychain;\n  walletPassphrase: string;\n  /** When already fetched (passphrase preflight), skip a second GET. */\n  rootKeychain?: KeychainWithEncryptedPrv;\n}\n\n/**\n * Resolve signing material for a safe owner (child key has no encryptedPrv).\n *\n * Onchain secp256k1: decrypt root → walk sequential `m/<n>'` children until the\n * registered pub matches (the mint index is not stored on the child key).\n * TSS and ed25519 onchain: throw — do not return root material or BIP32-derive the wrong curve.\n *\n * Do not use for wallet sharing — that must not receive root key material.\n * Call only when `isSafeChildPublicOnlyKeychain` is true.\n */\nexport async function resolveSafeOwnerSigningPrv(params: ResolveSafeOwnerSigningPrvParams): Promise<string> {\n  const { bitgo, keychains, walletId, multisigType, coinFamily, childKeychain, walletPassphrase } = params;\n\n  if (multisigType !== 'onchain') {\n    throw new SafeOwnerSigningNotImplementedError(\n      walletId,\n      'TSS owner signing from the root keyshare is not implemented. ' +\n        'Returning the root private key would expose material that can derive every child in this slot.'\n    );\n  }\n  if (ED25519_ONCHAIN_FAMILIES.has(coinFamily)) {\n    throw new SafeOwnerSigningNotImplementedError(\n      walletId,\n      `ed25519 multisig owner derivation (${coinFamily}) is not implemented; BIP32 would produce the wrong child key.`\n    );\n  }\n\n  const rootKeychain = params.rootKeychain ?? (await fetchRootKeychainForSafeChild(keychains, childKeychain));\n  const rootPrv = await decryptKeychainPrivateKey(bitgo, rootKeychain, walletPassphrase);\n  if (!rootPrv) {\n    throw new IncorrectPasswordError();\n  }\n\n  if (!childKeychain.pub) {\n    throw new Error(`Safe wallet ${walletId}: child keychain is missing pub for pre-sign verification`);\n  }\n\n  try {\n    const derived = deriveSafeChildHardenedMatchingPub(rootPrv, childKeychain.pub);\n    return derived.prv;\n  } catch (e) {\n    const detail = e instanceof Error ? e.message : String(e);\n    throw new SafeDerivedPublicKeyMismatchError(walletId, childKeychain.pub, detail);\n  }\n}\n"]}