@bitgo-beta/sdk-core 8.2.1-beta.212 → 8.2.1-beta.2121

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

@@ -0,0 +1,75 @@
+/**
+ * @prettier
+ */
+import { BitGoBase } from '../bitgoBase';
+import { IKeychains, Keychain, KeychainWithEncryptedPrv } from '../keychain';
+import type { DecryptedKeychainData } from './iWallet';
+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);
+}
+/** Thrown when wallet sharing is not implemented for this safe slot (TSS, ed25519 multisig, …). */
+export declare class SafeShareNotImplementedError 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>;
+/**
+ * Shared params for resolving safe-owner key material (owner signing and wallet sharing).
+ * Both resolvers extend this so the precondition/derivation path cannot diverge.
+ */
+export interface SafeKeyMaterialBaseParams {
+    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;
+}
+export type ResolveSafeOwnerSigningPrvParams = SafeKeyMaterialBaseParams;
+/**
+ * Resolve signing material for a safe owner (child key has no encryptedPrv).
+ *
+ * Onchain secp256k1: decrypt root, hardened-derive at `derivedFromParentWithPath`
+ * (`m/44'/<coinType>'/<slot>'/<account>'`), and verify the registered pub.
+ * 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>;
+export interface ResolveSafeChildPrvForSharingParams extends SafeKeyMaterialBaseParams {
+    mpcAlgorithm?: 'ecdsa' | 'eddsa';
+}
+/**
+ * Resolve sharing material for a safe owner (child key has no encryptedPrv).
+ *
+ * Onchain secp256k1: decrypt root, hardened-derive at `derivedFromParentWithPath`
+ * (`m/<n>'`), verify the registered pub, and return the CHILD `{prv, pub}` — never the root.
+ * TSS and ed25519 onchain: throw `SafeShareNotImplementedError` naming the slot + blocker.
+ *
+ * Call only when `isSafeChildPublicOnlyKeychain` is true.
+ */
+export declare function resolveSafeChildPrvForSharing(params: ResolveSafeChildPrvForSharingParams): Promise<DecryptedKeychainData>;
+//# 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,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAEvD,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;AAED,mGAAmG;AACnG,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,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;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,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,MAAM,MAAM,gCAAgC,GAAG,yBAAyB,CAAC;AAoEzE;;;;;;;;;GASG;AACH,wBAAsB,0BAA0B,CAAC,MAAM,EAAE,gCAAgC,GAAG,OAAO,CAAC,MAAM,CAAC,CAgB1G;AAED,MAAM,WAAW,mCAAoC,SAAQ,yBAAyB;IACpF,YAAY,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;CAClC;AAYD;;;;;;;;GAQG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,mCAAmC,GAC1C,OAAO,CAAC,qBAAqB,CAAC,CAMhC"}

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeShareNotImplementedError = exports.SafeOwnerSigningNotImplementedError = exports.SafeDerivedPublicKeyMismatchError = exports.InvalidRootKeychainSourceError = void 0;
+exports.isSafeChildPublicOnlyKeychain = isSafeChildPublicOnlyKeychain;
+exports.fetchRootKeychainForSafeChild = fetchRootKeychainForSafeChild;
+exports.resolveSafeOwnerSigningPrv = resolveSafeOwnerSigningPrv;
+exports.resolveSafeChildPrvForSharing = resolveSafeChildPrvForSharing;
+const keychain_1 = require("../keychain");
+const sdk_lib_safes_1 = require("@bitgo-beta/sdk-lib-safes");
+const codecs_1 = require("../utils/codecs");
+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;
+/** Thrown when wallet sharing is not implemented for this safe slot (TSS, ed25519 multisig, …). */
+class SafeShareNotImplementedError extends Error {
+    constructor(walletId, detail) {
+        super(`Safe wallet ${walletId}: ${detail}`);
+        this.name = 'SafeShareNotImplementedError';
+    }
+}
+exports.SafeShareNotImplementedError = SafeShareNotImplementedError;
+/** 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;
+}
+/**
+ * Shared core that resolves safe key material for a pub-only safe child. Returns the CHILD
+ * `{prv, pub}` only — never the root — so the root can never leak into a share document.
+ *
+ * Onchain secp256k1: decrypt root, hardened-derive at `derivedFromParentWithPath`
+ * (`m/<n>'`), and verify the registered pub. TSS and ed25519 onchain throw via
+ * `makeNotImplementedError` — the caller constructs its own error class + message, so the
+ * guard set stays shared while signing/sharing report their own errors.
+ */
+async function resolveSafeKeyMaterial(params) {
+    const { bitgo, keychains, walletId, multisigType, coinFamily, childKeychain, walletPassphrase, makeNotImplementedError, } = params;
+    if (multisigType !== 'onchain') {
+        throw makeNotImplementedError('tss', walletId);
+    }
+    if (ED25519_ONCHAIN_FAMILIES.has(coinFamily)) {
+        throw makeNotImplementedError('ed25519', walletId);
+    }
+    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`);
+    }
+    if (childKeychain.derivedFromParentWithPath === undefined) {
+        throw new Error(`Safe wallet ${walletId}: child keychain is missing derivedFromParentWithPath`);
+    }
+    const derived = (0, sdk_lib_safes_1.deriveSafeChildHardenedFromXprv)(rootPrv, (0, codecs_1.decodeWithCodec)(sdk_lib_safes_1.DerivedFromParentWithHardenedPath, childKeychain.derivedFromParentWithPath, 'derivedFromParentWithPath'));
+    if (derived.pub !== childKeychain.pub) {
+        throw new SafeDerivedPublicKeyMismatchError(walletId, childKeychain.pub, derived.pub);
+    }
+    if (derived.pub === rootKeychain.pub) {
+        throw new Error(`Safe wallet ${walletId}: derived child pub unexpectedly equals the root pub`);
+    }
+    return { prv: derived.prv, pub: derived.pub };
+}
+/**
+ * Resolve signing material for a safe owner (child key has no encryptedPrv).
+ *
+ * Onchain secp256k1: decrypt root, hardened-derive at `derivedFromParentWithPath`
+ * (`m/44'/<coinType>'/<slot>'/<account>'`), and verify the registered pub.
+ * 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 { prv } = await resolveSafeKeyMaterial({
+        ...params,
+        makeNotImplementedError: (slot, walletId) => slot === 'ed25519'
+            ? new SafeOwnerSigningNotImplementedError(walletId, `ed25519 multisig owner derivation (${params.coinFamily}) is not implemented; BIP32 would produce the wrong child key.`)
+            : 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.'),
+    });
+    return prv;
+}
+/** Slot-named not-implemented detail for wallet sharing. */
+function safeShareSlotDetail(slot, params) {
+    if (slot === 'ed25519') {
+        return `ed25519 multisig safe sharing (${params.coinFamily}) is not implemented; BIP32 would derive the wrong child.`;
+    }
+    return params.mpcAlgorithm === 'eddsa'
+        ? 'eddsaMpc safe sharing is not implemented (needs the EdDSA derive ceremony).'
+        : 'ecdsaMpc safe sharing is not implemented (needs the DKLS derive ceremony).';
+}
+/**
+ * Resolve sharing material for a safe owner (child key has no encryptedPrv).
+ *
+ * Onchain secp256k1: decrypt root, hardened-derive at `derivedFromParentWithPath`
+ * (`m/<n>'`), verify the registered pub, and return the CHILD `{prv, pub}` — never the root.
+ * TSS and ed25519 onchain: throw `SafeShareNotImplementedError` naming the slot + blocker.
+ *
+ * Call only when `isSafeChildPublicOnlyKeychain` is true.
+ */
+async function resolveSafeChildPrvForSharing(params) {
+    return resolveSafeKeyMaterial({
+        ...params,
+        makeNotImplementedError: (slot, walletId) => new SafeShareNotImplementedError(walletId, safeShareSlotDetail(slot, params)),
+    });
+}
+//# 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 { deriveSafeChildHardenedFromXprv, DerivedFromParentWithHardenedPath } from '@bitgo-beta/sdk-lib-safes';\nimport { decodeWithCodec } from '../utils/codecs';\nimport { IncorrectPasswordError } from '../errors';\nimport type { DecryptedKeychainData } from './iWallet';\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/** Thrown when wallet sharing is not implemented for this safe slot (TSS, ed25519 multisig, …). */\nexport class SafeShareNotImplementedError extends Error {\n  constructor(walletId: string, detail: string) {\n    super(`Safe wallet ${walletId}: ${detail}`);\n    this.name = 'SafeShareNotImplementedError';\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\n/**\n * Shared params for resolving safe-owner key material (owner signing and wallet sharing).\n * Both resolvers extend this so the precondition/derivation path cannot diverge.\n */\nexport interface SafeKeyMaterialBaseParams {\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\nexport type ResolveSafeOwnerSigningPrvParams = SafeKeyMaterialBaseParams;\n\ntype SafeKeyMaterialSlot = 'tss' | 'ed25519';\n\ntype ResolveSafeKeyMaterialParams = SafeKeyMaterialBaseParams & {\n  /** Constructs the not-implemented error for the current resolver (signing vs sharing). */\n  makeNotImplementedError: (slot: SafeKeyMaterialSlot, walletId: string) => Error;\n};\n\n/**\n * Shared core that resolves safe key material for a pub-only safe child. Returns the CHILD\n * `{prv, pub}` only — never the root — so the root can never leak into a share document.\n *\n * Onchain secp256k1: decrypt root, hardened-derive at `derivedFromParentWithPath`\n * (`m/<n>'`), and verify the registered pub. TSS and ed25519 onchain throw via\n * `makeNotImplementedError` — the caller constructs its own error class + message, so the\n * guard set stays shared while signing/sharing report their own errors.\n */\nasync function resolveSafeKeyMaterial(params: ResolveSafeKeyMaterialParams): Promise<{ prv: string; pub: string }> {\n  const {\n    bitgo,\n    keychains,\n    walletId,\n    multisigType,\n    coinFamily,\n    childKeychain,\n    walletPassphrase,\n    makeNotImplementedError,\n  } = params;\n\n  if (multisigType !== 'onchain') {\n    throw makeNotImplementedError('tss', walletId);\n  }\n  if (ED25519_ONCHAIN_FAMILIES.has(coinFamily)) {\n    throw makeNotImplementedError('ed25519', walletId);\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  if (childKeychain.derivedFromParentWithPath === undefined) {\n    throw new Error(`Safe wallet ${walletId}: child keychain is missing derivedFromParentWithPath`);\n  }\n\n  const derived = deriveSafeChildHardenedFromXprv(\n    rootPrv,\n    decodeWithCodec(\n      DerivedFromParentWithHardenedPath,\n      childKeychain.derivedFromParentWithPath,\n      'derivedFromParentWithPath'\n    )\n  );\n  if (derived.pub !== childKeychain.pub) {\n    throw new SafeDerivedPublicKeyMismatchError(walletId, childKeychain.pub, derived.pub);\n  }\n\n  if (derived.pub === rootKeychain.pub) {\n    throw new Error(`Safe wallet ${walletId}: derived child pub unexpectedly equals the root pub`);\n  }\n  return { prv: derived.prv, pub: derived.pub };\n}\n\n/**\n * Resolve signing material for a safe owner (child key has no encryptedPrv).\n *\n * Onchain secp256k1: decrypt root, hardened-derive at `derivedFromParentWithPath`\n * (`m/44'/<coinType>'/<slot>'/<account>'`), and verify the registered pub.\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 { prv } = await resolveSafeKeyMaterial({\n    ...params,\n    makeNotImplementedError: (slot, walletId) =>\n      slot === 'ed25519'\n        ? new SafeOwnerSigningNotImplementedError(\n            walletId,\n            `ed25519 multisig owner derivation (${params.coinFamily}) is not implemented; BIP32 would produce the wrong child key.`\n          )\n        : 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  return prv;\n}\n\nexport interface ResolveSafeChildPrvForSharingParams extends SafeKeyMaterialBaseParams {\n  mpcAlgorithm?: 'ecdsa' | 'eddsa';\n}\n\n/** Slot-named not-implemented detail for wallet sharing. */\nfunction safeShareSlotDetail(slot: SafeKeyMaterialSlot, params: ResolveSafeChildPrvForSharingParams): string {\n  if (slot === 'ed25519') {\n    return `ed25519 multisig safe sharing (${params.coinFamily}) is not implemented; BIP32 would derive the wrong child.`;\n  }\n  return params.mpcAlgorithm === 'eddsa'\n    ? 'eddsaMpc safe sharing is not implemented (needs the EdDSA derive ceremony).'\n    : 'ecdsaMpc safe sharing is not implemented (needs the DKLS derive ceremony).';\n}\n\n/**\n * Resolve sharing material for a safe owner (child key has no encryptedPrv).\n *\n * Onchain secp256k1: decrypt root, hardened-derive at `derivedFromParentWithPath`\n * (`m/<n>'`), verify the registered pub, and return the CHILD `{prv, pub}` — never the root.\n * TSS and ed25519 onchain: throw `SafeShareNotImplementedError` naming the slot + blocker.\n *\n * Call only when `isSafeChildPublicOnlyKeychain` is true.\n */\nexport async function resolveSafeChildPrvForSharing(\n  params: ResolveSafeChildPrvForSharingParams\n): Promise<DecryptedKeychainData> {\n  return resolveSafeKeyMaterial({\n    ...params,\n    makeNotImplementedError: (slot, walletId) =>\n      new SafeShareNotImplementedError(walletId, safeShareSlotDetail(slot, params)),\n  });\n}\n"]}