@bitgo/sdk-lib-safes 1.4.0 → 1.6.0

package/dist/src/safeDerivation.js

@@ -33,20 +33,27 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DerivedFromParentWithHardenedPath = exports.DERIVED_FROM_PARENT_WITH_HARDENED_PATH = void 0;
-exports.parseSafeDerivationIndex = parseSafeDerivationIndex;
-exports.getSafeHardenedDerivationPath = getSafeHardenedDerivationPath;
-exports.parseDerivedFromParentWithHardenedPath = parseDerivedFromParentWithHardenedPath;
+exports.DerivedFromParentWithSoftPath = exports.DerivedFromParentWithHardenedPath = void 0;
+exports.assertBip32Path = assertBip32Path;
+exports.isDerivedFromParentWithHardenedPath = isDerivedFromParentWithHardenedPath;
+exports.isDerivedFromParentWithSoftPath = isDerivedFromParentWithSoftPath;
+exports.parseSafeBip44Path = parseSafeBip44Path;
+exports.getSafeBip44CoinType = getSafeBip44CoinType;
+exports.buildSafeBip44Path = buildSafeBip44Path;
+exports.toSoftTwinPath = toSoftTwinPath;
 exports.deriveSafeChildHardenedFromXprv = deriveSafeChildHardenedFromXprv;
 exports.deriveAndSelfCheckSafeChildHardened = deriveAndSelfCheckSafeChildHardened;
 exports.deriveSafeChildEd25519Hardened = deriveSafeChildEd25519Hardened;
+exports.deriveSafeChildTriplet = deriveSafeChildTriplet;
 /**
  * @prettier
  *
  * @experimental Shared safe child derivation for mint, sign, and recovery.
  *
- * User child: hardened `m/<index>'` from the sequential `safe.derivationIndex[slot]`.
- * Backup / BitGo children are soft-derived at `m/<index>` client-side for recovery.
+ * User child (every slot): hardened `m/44'/<coinType>'/<slot>'/<account>'`.
+ * Multisig co-signers (backup / BitGo): the soft twin `m/44/<coinType>/<slot>/<account>`.
+ * `<coinType>` is statics `bip44CoinType`, `<slot>` is statics `SAFE_ROOT_SLOT_ORDINALS[slot]`,
+ * and `<account>` is the safe's per-(slot, coinType) counter.
  *
  * Do not use `derivedFromParentWithSeed` / `deriveKeyWithSeed` (`m/999999/a/b`) —
  * that is the custody hashed path and cannot reproduce a safe child.
@@ -56,48 +63,106 @@ const nacl = __importStar(require("tweetnacl"));
 const utxo_lib_1 = require("@bitgo/utxo-lib");
 const statics_1 = require("@bitgo/statics");
 const ed25519KeyDeriver_1 = require("./ed25519KeyDeriver");
-const codecs_1 = require("./codecs");
 const ed25519Pub_1 = require("./ed25519Pub");
-exports.DERIVED_FROM_PARENT_WITH_HARDENED_PATH = /^m\/(\d+)'$/;
-function parseSafeDerivationIndex(index) {
-    let idx;
-    if (typeof index === 'number') {
-        idx = index;
-    }
-    else if (/^\d+$/.test(index)) {
-        idx = Number(index);
-    }
-    else {
-        throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);
+const HARDENED_BIP44_PATH = /^m\/44'\/(\d+)'\/(\d+)'\/(\d+)'$/;
+const SOFT_BIP44_PATH = /^m\/44\/(\d+)\/(\d+)\/(\d+)$/;
+const SAFE_SLOT_ORDINALS = Object.values(statics_1.SAFE_ROOT_SLOT_ORDINALS);
+/**
+ * Assert `path` is a valid BIP32 path for the given derivation kind. Hardened paths require every
+ * segment to carry the `'` marker; soft paths reject it. Every segment must be a non-negative
+ * integer at or below {@link MAX_BIP32_INDEX}.
+ */
+function assertBip32Path(path, opts) {
+    const re = opts.hardened ? /^m(\/\d+')+$/ : /^m(\/\d+)+$/;
+    if (!re.test(path)) {
+        throw new Error(`Invalid ${opts.hardened ? 'hardened' : 'soft'} derivation path '${path}'`);
     }
-    if (!Number.isInteger(idx) || idx < 0 || idx > statics_1.MAX_BIP32_INDEX) {
-        throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);
+    const outOfRange = path
+        .split('/')
+        .slice(1)
+        .map((segment) => Number(opts.hardened ? segment.slice(0, -1) : segment))
+        .some((index) => !Number.isInteger(index) || index < 0 || index > statics_1.MAX_BIP32_INDEX);
+    if (outOfRange) {
+        throw new Error(`Invalid ${opts.hardened ? 'hardened' : 'soft'} derivation path '${path}': index out of range`);
     }
-    return idx;
 }
-function getSafeHardenedDerivationPath(index) {
-    return `m/${parseSafeDerivationIndex(index)}'`;
+/**
+ * Canonical decimal only: `044` and `44` name one key under two strings, so string-equality
+ * path checks (the server's unique index) would treat one child as two.
+ */
+function parseBip32Index(segment) {
+    const index = Number(segment);
+    return Number.isInteger(index) && index <= statics_1.MAX_BIP32_INDEX && String(index) === segment ? index : undefined;
 }
-exports.DerivedFromParentWithHardenedPath = t.brand(t.string, (s) => parseDerivedFromParentWithHardenedPathIndex(s) !== undefined, 'DerivedFromParentWithHardenedPath');
-function parseDerivedFromParentWithHardenedPathIndex(path) {
-    const match = exports.DERIVED_FROM_PARENT_WITH_HARDENED_PATH.exec(path);
+function parseBip44Segments(match) {
     if (!match) {
         return undefined;
     }
-    try {
-        return parseSafeDerivationIndex(match[1]);
+    const coinType = parseBip32Index(match[1]);
+    const slotOrdinal = parseBip32Index(match[2]);
+    const account = parseBip32Index(match[3]);
+    if (coinType === undefined || slotOrdinal === undefined || account === undefined) {
+        return undefined;
     }
-    catch {
+    if (!SAFE_SLOT_ORDINALS.includes(slotOrdinal)) {
         return undefined;
     }
+    return { coinType, slotOrdinal, account };
+}
+function isDerivedFromParentWithHardenedPath(s) {
+    return parseBip44Segments(HARDENED_BIP44_PATH.exec(s)) !== undefined;
+}
+function isDerivedFromParentWithSoftPath(s) {
+    return parseBip44Segments(SOFT_BIP44_PATH.exec(s)) !== undefined;
+}
+exports.DerivedFromParentWithHardenedPath = t.brand(t.string, (s) => isDerivedFromParentWithHardenedPath(s), 'DerivedFromParentWithHardenedPath');
+exports.DerivedFromParentWithSoftPath = t.brand(t.string, (s) => isDerivedFromParentWithSoftPath(s), 'DerivedFromParentWithSoftPath');
+/**
+ * Reads the numeric segments out of a user/MPC child path. Rejects anything else, including a
+ * cast soft path: a hardened derive ceremony must never run at, or register, a soft path.
+ */
+function parseSafeBip44Path(path) {
+    const segments = parseBip44Segments(HARDENED_BIP44_PATH.exec(path));
+    if (segments === undefined) {
+        throw new Error(`Invalid safe BIP44 path '${path}'`);
+    }
+    return segments;
 }
-function parseDerivedFromParentWithHardenedPath(path) {
-    const validated = (0, codecs_1.decodeWithCodec)(exports.DerivedFromParentWithHardenedPath, path, 'derivedFromParentWithHardenedPath');
-    const index = parseDerivedFromParentWithHardenedPathIndex(validated);
-    if (index === undefined) {
-        throw new Error(`Invalid derivedFromParentWithHardenedPath '${path}': expected m/<n>'`);
+/** The `<coinType>` segment for a coin. OFC and fiat coins have none and cannot mint a safe child. */
+function getSafeBip44CoinType(coin) {
+    const coinType = statics_1.coins.get(coin).bip44CoinType;
+    if (coinType === undefined) {
+        throw new Error(`Coin '${coin}' has no BIP44 coin type and cannot derive a safe child`);
+    }
+    return coinType;
+}
+/**
+ * Builds the user-child path `m/44'/<coinType>'/<slot>'/<account>'`. `coinType` comes from statics
+ * (or the derivation-index response) and `account` from the safe's per-(slot, coinType) counter.
+ */
+function buildSafeBip44Path(coinType, slot, account) {
+    const path = `m/44'/${coinType}'/${statics_1.SAFE_ROOT_SLOT_ORDINALS[slot]}'/${account}'`;
+    if (!isDerivedFromParentWithHardenedPath(path)) {
+        throw new Error(`Invalid safe BIP44 path segments: coinType=${coinType}, slot=${slot}, account=${account}`);
+    }
+    return path;
+}
+/** Strips hardening from every level: the co-signer path paired with a user-child path. */
+function toSoftTwinPath(path) {
+    const softPath = path.replace(/'/g, '');
+    if (!isDerivedFromParentWithSoftPath(softPath)) {
+        throw new Error(`Invalid safe BIP44 path '${path}': no soft twin`);
+    }
+    return softPath;
+}
+/**
+ * The type alone is not enough: a cast path with a soft level on a user child would let the
+ * parent xpub plus the child prv recover the root.
+ */
+function assertHardenedPath(path) {
+    if (!isDerivedFromParentWithHardenedPath(path)) {
+        throw new Error(`Invalid safe child path '${path}': expected m/44'/<coinType>'/<slot>'/<account>'`);
     }
-    return index;
 }
 function childFromNode(child, derivationPath) {
     if (!child.privateKey) {
@@ -109,15 +174,14 @@ function childFromNode(child, derivationPath) {
         derivationPath,
     };
 }
-function deriveSafeChildHardenedFromXprv(rootXprv, index) {
-    const idx = parseSafeDerivationIndex(index);
-    const derivationPath = getSafeHardenedDerivationPath(idx);
-    return childFromNode(utxo_lib_1.bip32.fromBase58(rootXprv).deriveHardened(idx), derivationPath);
+function deriveSafeChildHardenedFromXprv(rootXprv, path) {
+    assertHardenedPath(path);
+    return childFromNode(utxo_lib_1.bip32.fromBase58(rootXprv).derivePath(path), path);
 }
 /** Re-derive and assert both results match before the child is registered. */
-function deriveAndSelfCheckSafeChildHardened(rootXprv, index) {
-    const first = deriveSafeChildHardenedFromXprv(rootXprv, index);
-    const second = deriveSafeChildHardenedFromXprv(rootXprv, index);
+function deriveAndSelfCheckSafeChildHardened(rootXprv, path) {
+    const first = deriveSafeChildHardenedFromXprv(rootXprv, path);
+    const second = deriveSafeChildHardenedFromXprv(rootXprv, path);
     if (first.pub !== second.pub || first.prv !== second.prv) {
         throw new Error(`Safe child self-check failed at ${first.derivationPath}: derivation was not deterministic`);
     }
@@ -126,7 +190,7 @@ function deriveAndSelfCheckSafeChildHardened(rootXprv, index) {
 /**
  * SLIP-0010 hardened derivation of a safe user child from an ed25519 root secret seed.
  *
- * `rootPrv` is a Stellar StrKey `S…` secret seed (what slot-④ `ed25519Multisig` user roots store).
+ * `rootPrv` is a Stellar StrKey `S…` secret seed (what slot-② `ed25519Multisig` user roots store).
  * The derivation reuses the existing SLIP-0010 implementation {@link Ed25519KeyDeriver.derivePath}
  * (hardened-only CKDPriv over the `ed25519 seed` HMAC master), then expands the resulting 32-byte
  * child seed into a keypair with `nacl`. The child `pub` is a bare StrKey `G…`; the `prv` is the
@@ -135,17 +199,40 @@ function deriveAndSelfCheckSafeChildHardened(rootXprv, index) {
  * Unlike the secp256k1 path, ed25519 hardened derivation needs no chain code — the composite
  * `pub‖chainCode` form is only for SOFT co-signer derivation and is not used here.
  */
-function deriveSafeChildEd25519Hardened(rootPrv, index) {
-    const idx = parseSafeDerivationIndex(index);
-    const derivationPath = getSafeHardenedDerivationPath(idx);
+function deriveSafeChildEd25519Hardened(rootPrv, path) {
+    assertHardenedPath(path);
     const rawSeedHex = (0, ed25519Pub_1.decodeEd25519StrKeySecretSeed)(rootPrv).toString('hex');
-    const childSeed = ed25519KeyDeriver_1.Ed25519KeyDeriver.derivePath(derivationPath, rawSeedHex).key;
+    const childSeed = ed25519KeyDeriver_1.Ed25519KeyDeriver.derivePath(path, rawSeedHex).key;
     const keyPair = nacl.sign.keyPair.fromSeed(Uint8Array.from(childSeed));
     const pub = (0, ed25519Pub_1.encodeEd25519StrKeyPublicKey)(Buffer.from(keyPair.publicKey));
     return {
         prv: Buffer.from(childSeed).toString('hex'),
         pub,
-        derivationPath,
+        derivationPath: path,
+    };
+}
+/**
+ * Derives the slot-① (secp256k1Multisig) child triplet from the keycard roots: the user child at
+ * the hardened `path`, the backup and BitGo children at its soft twin.
+ */
+function deriveSafeChildTriplet(roots, path) {
+    assertHardenedPath(path);
+    const userRoot = utxo_lib_1.bip32.fromBase58(roots.user);
+    const backupRoot = utxo_lib_1.bip32.fromBase58(roots.backup);
+    const bitgoRoot = utxo_lib_1.bip32.fromBase58(roots.bitgo);
+    if (userRoot.isNeutered() || backupRoot.isNeutered()) {
+        throw new Error('deriveSafeChildTriplet: user and backup roots must be private (xprv)');
+    }
+    if (!bitgoRoot.isNeutered()) {
+        throw new Error('deriveSafeChildTriplet: bitgo root must be public (xpub)');
+    }
+    const softPath = toSoftTwinPath(path);
+    const user = userRoot.derivePath(path);
+    const backup = backupRoot.derivePath(softPath);
+    return {
+        user: { prv: user.toBase58(), pub: user.neutered().toBase58() },
+        backup: { prv: backup.toBase58(), pub: backup.neutered().toBase58() },
+        bitgo: { pub: bitgoRoot.derivePath(softPath).toBase58() },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safeDerivation.js","sourceRoot":"","sources":["../../src/safeDerivation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * @experimental Shared safe child derivation for mint, sign, and recovery.\n *\n * User child: hardened `m/<index>'` from the sequential `safe.derivationIndex[slot]`.\n * Backup / BitGo children are soft-derived at `m/<index>` client-side for recovery.\n *\n * Do not use `derivedFromParentWithSeed` / `deriveKeyWithSeed` (`m/999999/a/b`) —\n * that is the custody hashed path and cannot reproduce a safe child.\n */\nimport * as t from 'io-ts';\nimport * as nacl from 'tweetnacl';\nimport { bip32, BIP32Interface } from '@bitgo/utxo-lib';\nimport { MAX_BIP32_INDEX } from '@bitgo/statics';\nimport { Ed25519KeyDeriver } from './ed25519KeyDeriver';\nimport { decodeWithCodec } from './codecs';\nimport { decodeEd25519StrKeySecretSeed, encodeEd25519StrKeyPublicKey } from './ed25519Pub';\n\nexport const DERIVED_FROM_PARENT_WITH_HARDENED_PATH = /^m\\/(\\d+)'$/;\n\nexport function parseSafeDerivationIndex(index: string | number): number {\n  let idx: number;\n  if (typeof index === 'number') {\n    idx = index;\n  } else if (/^\\d+$/.test(index)) {\n    idx = Number(index);\n  } else {\n    throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);\n  }\n  if (!Number.isInteger(idx) || idx < 0 || idx > MAX_BIP32_INDEX) {\n    throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);\n  }\n  return idx;\n}\n\nexport function getSafeHardenedDerivationPath(index: string | number): string {\n  return `m/${parseSafeDerivationIndex(index)}'`;\n}\n\nexport interface DerivedFromParentWithHardenedPathBrand {\n  readonly DerivedFromParentWithHardenedPath: unique symbol;\n}\n\nexport type DerivedFromParentWithHardenedPath = t.Branded<string, DerivedFromParentWithHardenedPathBrand>;\n\nexport const DerivedFromParentWithHardenedPath = t.brand(\n  t.string,\n  (s): s is DerivedFromParentWithHardenedPath => parseDerivedFromParentWithHardenedPathIndex(s) !== undefined,\n  'DerivedFromParentWithHardenedPath'\n);\n\nfunction parseDerivedFromParentWithHardenedPathIndex(path: string): number | undefined {\n  const match = DERIVED_FROM_PARENT_WITH_HARDENED_PATH.exec(path);\n  if (!match) {\n    return undefined;\n  }\n  try {\n    return parseSafeDerivationIndex(match[1]);\n  } catch {\n    return undefined;\n  }\n}\n\nexport function parseDerivedFromParentWithHardenedPath(path: string): number {\n  const validated = decodeWithCodec(DerivedFromParentWithHardenedPath, path, 'derivedFromParentWithHardenedPath');\n  const index = parseDerivedFromParentWithHardenedPathIndex(validated);\n  if (index === undefined) {\n    throw new Error(`Invalid derivedFromParentWithHardenedPath '${path}': expected m/<n>'`);\n  }\n  return index;\n}\n\nexport interface SafeHardenedChildKey {\n  prv: string;\n  pub: string;\n  derivationPath: string;\n}\n\nfunction childFromNode(child: BIP32Interface, derivationPath: string): SafeHardenedChildKey {\n  if (!child.privateKey) {\n    throw new Error(`Failed to derive hardened safe child at ${derivationPath}`);\n  }\n  return {\n    prv: child.toBase58(),\n    pub: child.neutered().toBase58(),\n    derivationPath,\n  };\n}\n\nexport function deriveSafeChildHardenedFromXprv(rootXprv: string, index: string | number): SafeHardenedChildKey {\n  const idx = parseSafeDerivationIndex(index);\n  const derivationPath = getSafeHardenedDerivationPath(idx);\n  return childFromNode(bip32.fromBase58(rootXprv).deriveHardened(idx), derivationPath);\n}\n\n/** Re-derive and assert both results match before the child is registered. */\nexport function deriveAndSelfCheckSafeChildHardened(rootXprv: string, index: string | number): SafeHardenedChildKey {\n  const first = deriveSafeChildHardenedFromXprv(rootXprv, index);\n  const second = deriveSafeChildHardenedFromXprv(rootXprv, index);\n  if (first.pub !== second.pub || first.prv !== second.prv) {\n    throw new Error(`Safe child self-check failed at ${first.derivationPath}: derivation was not deterministic`);\n  }\n  return first;\n}\n\n/**\n * SLIP-0010 hardened derivation of a safe user child from an ed25519 root secret seed.\n *\n * `rootPrv` is a Stellar StrKey `S…` secret seed (what slot-④ `ed25519Multisig` user roots store).\n * The derivation reuses the existing SLIP-0010 implementation {@link Ed25519KeyDeriver.derivePath}\n * (hardened-only CKDPriv over the `ed25519 seed` HMAC master), then expands the resulting 32-byte\n * child seed into a keypair with `nacl`. The child `pub` is a bare StrKey `G…`; the `prv` is the\n * raw 32-byte child seed as hex (the seed input a signer needs).\n *\n * Unlike the secp256k1 path, ed25519 hardened derivation needs no chain code — the composite\n * `pub‖chainCode` form is only for SOFT co-signer derivation and is not used here.\n */\nexport function deriveSafeChildEd25519Hardened(rootPrv: string, index: string | number): SafeHardenedChildKey {\n  const idx = parseSafeDerivationIndex(index);\n  const derivationPath = getSafeHardenedDerivationPath(idx);\n  const rawSeedHex = decodeEd25519StrKeySecretSeed(rootPrv).toString('hex');\n  const childSeed = Ed25519KeyDeriver.derivePath(derivationPath, rawSeedHex).key;\n  const keyPair = nacl.sign.keyPair.fromSeed(Uint8Array.from(childSeed));\n  const pub = encodeEd25519StrKeyPublicKey(Buffer.from(keyPair.publicKey));\n  return {\n    prv: Buffer.from(childSeed).toString('hex'),\n    pub,\n    derivationPath,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safeDerivation.js","sourceRoot":"","sources":["../../src/safeDerivation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * @experimental Shared safe child derivation for mint, sign, and recovery.\n *\n * User child (every slot): hardened `m/44'/<coinType>'/<slot>'/<account>'`.\n * Multisig co-signers (backup / BitGo): the soft twin `m/44/<coinType>/<slot>/<account>`.\n * `<coinType>` is statics `bip44CoinType`, `<slot>` is statics `SAFE_ROOT_SLOT_ORDINALS[slot]`,\n * and `<account>` is the safe's per-(slot, coinType) counter.\n *\n * Do not use `derivedFromParentWithSeed` / `deriveKeyWithSeed` (`m/999999/a/b`) —\n * that is the custody hashed path and cannot reproduce a safe child.\n */\nimport * as t from 'io-ts';\nimport * as nacl from 'tweetnacl';\nimport { bip32, BIP32Interface } from '@bitgo/utxo-lib';\nimport { coins, MAX_BIP32_INDEX, SAFE_ROOT_SLOT_ORDINALS } from '@bitgo/statics';\nimport type { RootKeyType } from '@bitgo/public-types';\nimport { Ed25519KeyDeriver } from './ed25519KeyDeriver';\nimport { decodeEd25519StrKeySecretSeed, encodeEd25519StrKeyPublicKey } from './ed25519Pub';\n\nconst HARDENED_BIP44_PATH = /^m\\/44'\\/(\\d+)'\\/(\\d+)'\\/(\\d+)'$/;\nconst SOFT_BIP44_PATH = /^m\\/44\\/(\\d+)\\/(\\d+)\\/(\\d+)$/;\nconst SAFE_SLOT_ORDINALS: readonly number[] = Object.values(SAFE_ROOT_SLOT_ORDINALS);\n\nexport interface SafeBip44PathSegments {\n  coinType: number;\n  slotOrdinal: number;\n  account: number;\n}\n\n/**\n * Assert `path` is a valid BIP32 path for the given derivation kind. Hardened paths require every\n * segment to carry the `'` marker; soft paths reject it. Every segment must be a non-negative\n * integer at or below {@link MAX_BIP32_INDEX}.\n */\nexport function assertBip32Path(path: string, opts: { hardened: boolean }): void {\n  const re = opts.hardened ? /^m(\\/\\d+')+$/ : /^m(\\/\\d+)+$/;\n  if (!re.test(path)) {\n    throw new Error(`Invalid ${opts.hardened ? 'hardened' : 'soft'} derivation path '${path}'`);\n  }\n  const outOfRange = path\n    .split('/')\n    .slice(1)\n    .map((segment) => Number(opts.hardened ? segment.slice(0, -1) : segment))\n    .some((index) => !Number.isInteger(index) || index < 0 || index > MAX_BIP32_INDEX);\n  if (outOfRange) {\n    throw new Error(`Invalid ${opts.hardened ? 'hardened' : 'soft'} derivation path '${path}': index out of range`);\n  }\n}\n\n/**\n * Canonical decimal only: `044` and `44` name one key under two strings, so string-equality\n * path checks (the server's unique index) would treat one child as two.\n */\nfunction parseBip32Index(segment: string): number | undefined {\n  const index = Number(segment);\n  return Number.isInteger(index) && index <= MAX_BIP32_INDEX && String(index) === segment ? index : undefined;\n}\n\nfunction parseBip44Segments(match: RegExpExecArray | null): SafeBip44PathSegments | undefined {\n  if (!match) {\n    return undefined;\n  }\n  const coinType = parseBip32Index(match[1]);\n  const slotOrdinal = parseBip32Index(match[2]);\n  const account = parseBip32Index(match[3]);\n  if (coinType === undefined || slotOrdinal === undefined || account === undefined) {\n    return undefined;\n  }\n  if (!SAFE_SLOT_ORDINALS.includes(slotOrdinal)) {\n    return undefined;\n  }\n  return { coinType, slotOrdinal, account };\n}\n\nexport interface DerivedFromParentWithHardenedPathBrand {\n  readonly DerivedFromParentWithHardenedPath: unique symbol;\n}\n\nexport interface DerivedFromParentWithSoftPathBrand {\n  readonly DerivedFromParentWithSoftPath: unique symbol;\n}\n\n/** Safe user-child path `m/44'/<coinType>'/<slot>'/<account>'`; also every MPC child. */\nexport type DerivedFromParentWithHardenedPath = t.Branded<string, DerivedFromParentWithHardenedPathBrand>;\n\n/** Multisig co-signer path `m/44/<coinType>/<slot>/<account>`, the soft twin of a user-child path. */\nexport type DerivedFromParentWithSoftPath = t.Branded<string, DerivedFromParentWithSoftPathBrand>;\n\nexport function isDerivedFromParentWithHardenedPath(s: string): s is DerivedFromParentWithHardenedPath {\n  return parseBip44Segments(HARDENED_BIP44_PATH.exec(s)) !== undefined;\n}\n\nexport function isDerivedFromParentWithSoftPath(s: string): s is DerivedFromParentWithSoftPath {\n  return parseBip44Segments(SOFT_BIP44_PATH.exec(s)) !== undefined;\n}\n\nexport const DerivedFromParentWithHardenedPath = t.brand(\n  t.string,\n  (s): s is DerivedFromParentWithHardenedPath => isDerivedFromParentWithHardenedPath(s),\n  'DerivedFromParentWithHardenedPath'\n);\n\nexport const DerivedFromParentWithSoftPath = t.brand(\n  t.string,\n  (s): s is DerivedFromParentWithSoftPath => isDerivedFromParentWithSoftPath(s),\n  'DerivedFromParentWithSoftPath'\n);\n\n/**\n * Reads the numeric segments out of a user/MPC child path. Rejects anything else, including a\n * cast soft path: a hardened derive ceremony must never run at, or register, a soft path.\n */\nexport function parseSafeBip44Path(path: DerivedFromParentWithHardenedPath): SafeBip44PathSegments {\n  const segments = parseBip44Segments(HARDENED_BIP44_PATH.exec(path));\n  if (segments === undefined) {\n    throw new Error(`Invalid safe BIP44 path '${path}'`);\n  }\n  return segments;\n}\n\n/** The `<coinType>` segment for a coin. OFC and fiat coins have none and cannot mint a safe child. */\nexport function getSafeBip44CoinType(coin: string): number {\n  const coinType = coins.get(coin).bip44CoinType;\n  if (coinType === undefined) {\n    throw new Error(`Coin '${coin}' has no BIP44 coin type and cannot derive a safe child`);\n  }\n  return coinType;\n}\n\n/**\n * Builds the user-child path `m/44'/<coinType>'/<slot>'/<account>'`. `coinType` comes from statics\n * (or the derivation-index response) and `account` from the safe's per-(slot, coinType) counter.\n */\nexport function buildSafeBip44Path(\n  coinType: number,\n  slot: RootKeyType,\n  account: number\n): DerivedFromParentWithHardenedPath {\n  const path = `m/44'/${coinType}'/${SAFE_ROOT_SLOT_ORDINALS[slot]}'/${account}'`;\n  if (!isDerivedFromParentWithHardenedPath(path)) {\n    throw new Error(`Invalid safe BIP44 path segments: coinType=${coinType}, slot=${slot}, account=${account}`);\n  }\n  return path;\n}\n\n/** Strips hardening from every level: the co-signer path paired with a user-child path. */\nexport function toSoftTwinPath(path: DerivedFromParentWithHardenedPath): DerivedFromParentWithSoftPath {\n  const softPath = path.replace(/'/g, '');\n  if (!isDerivedFromParentWithSoftPath(softPath)) {\n    throw new Error(`Invalid safe BIP44 path '${path}': no soft twin`);\n  }\n  return softPath;\n}\n\n/**\n * The type alone is not enough: a cast path with a soft level on a user child would let the\n * parent xpub plus the child prv recover the root.\n */\nfunction assertHardenedPath(path: string): asserts path is DerivedFromParentWithHardenedPath {\n  if (!isDerivedFromParentWithHardenedPath(path)) {\n    throw new Error(`Invalid safe child path '${path}': expected m/44'/<coinType>'/<slot>'/<account>'`);\n  }\n}\n\nexport interface SafeHardenedChildKey {\n  prv: string;\n  pub: string;\n  derivationPath: DerivedFromParentWithHardenedPath;\n}\n\nfunction childFromNode(child: BIP32Interface, derivationPath: DerivedFromParentWithHardenedPath): SafeHardenedChildKey {\n  if (!child.privateKey) {\n    throw new Error(`Failed to derive hardened safe child at ${derivationPath}`);\n  }\n  return {\n    prv: child.toBase58(),\n    pub: child.neutered().toBase58(),\n    derivationPath,\n  };\n}\n\nexport function deriveSafeChildHardenedFromXprv(\n  rootXprv: string,\n  path: DerivedFromParentWithHardenedPath\n): SafeHardenedChildKey {\n  assertHardenedPath(path);\n  return childFromNode(bip32.fromBase58(rootXprv).derivePath(path), path);\n}\n\n/** Re-derive and assert both results match before the child is registered. */\nexport function deriveAndSelfCheckSafeChildHardened(\n  rootXprv: string,\n  path: DerivedFromParentWithHardenedPath\n): SafeHardenedChildKey {\n  const first = deriveSafeChildHardenedFromXprv(rootXprv, path);\n  const second = deriveSafeChildHardenedFromXprv(rootXprv, path);\n  if (first.pub !== second.pub || first.prv !== second.prv) {\n    throw new Error(`Safe child self-check failed at ${first.derivationPath}: derivation was not deterministic`);\n  }\n  return first;\n}\n\n/**\n * SLIP-0010 hardened derivation of a safe user child from an ed25519 root secret seed.\n *\n * `rootPrv` is a Stellar StrKey `S…` secret seed (what slot-② `ed25519Multisig` user roots store).\n * The derivation reuses the existing SLIP-0010 implementation {@link Ed25519KeyDeriver.derivePath}\n * (hardened-only CKDPriv over the `ed25519 seed` HMAC master), then expands the resulting 32-byte\n * child seed into a keypair with `nacl`. The child `pub` is a bare StrKey `G…`; the `prv` is the\n * raw 32-byte child seed as hex (the seed input a signer needs).\n *\n * Unlike the secp256k1 path, ed25519 hardened derivation needs no chain code — the composite\n * `pub‖chainCode` form is only for SOFT co-signer derivation and is not used here.\n */\nexport function deriveSafeChildEd25519Hardened(\n  rootPrv: string,\n  path: DerivedFromParentWithHardenedPath\n): SafeHardenedChildKey {\n  assertHardenedPath(path);\n  const rawSeedHex = decodeEd25519StrKeySecretSeed(rootPrv).toString('hex');\n  const childSeed = Ed25519KeyDeriver.derivePath(path, rawSeedHex).key;\n  const keyPair = nacl.sign.keyPair.fromSeed(Uint8Array.from(childSeed));\n  const pub = encodeEd25519StrKeyPublicKey(Buffer.from(keyPair.publicKey));\n  return {\n    prv: Buffer.from(childSeed).toString('hex'),\n    pub,\n    derivationPath: path,\n  };\n}\n\nexport interface SafeSecp256k1ChildTriplet {\n  user: { prv: string; pub: string };\n  backup: { prv: string; pub: string };\n  bitgo: { pub: string };\n}\n\n/**\n * Derives the slot-① (secp256k1Multisig) child triplet from the keycard roots: the user child at\n * the hardened `path`, the backup and BitGo children at its soft twin.\n */\nexport function deriveSafeChildTriplet(\n  roots: { user: string; backup: string; bitgo: string },\n  path: DerivedFromParentWithHardenedPath\n): SafeSecp256k1ChildTriplet {\n  assertHardenedPath(path);\n  const userRoot = bip32.fromBase58(roots.user);\n  const backupRoot = bip32.fromBase58(roots.backup);\n  const bitgoRoot = bip32.fromBase58(roots.bitgo);\n  if (userRoot.isNeutered() || backupRoot.isNeutered()) {\n    throw new Error('deriveSafeChildTriplet: user and backup roots must be private (xprv)');\n  }\n  if (!bitgoRoot.isNeutered()) {\n    throw new Error('deriveSafeChildTriplet: bitgo root must be public (xpub)');\n  }\n  const softPath = toSoftTwinPath(path);\n  const user = userRoot.derivePath(path);\n  const backup = backupRoot.derivePath(softPath);\n  return {\n    user: { prv: user.toBase58(), pub: user.neutered().toBase58() },\n    backup: { prv: backup.toBase58(), pub: backup.neutered().toBase58() },\n    bitgo: { pub: bitgoRoot.derivePath(softPath).toBase58() },\n  };\n}\n"]}