@bitgo-beta/sdk-lib-safes 1.0.0-beta.4 → 1.0.0-beta.41

package/dist/src/index.d.ts

@@ -1,10 +1,11 @@
 /**
  * @prettier
  *
- * @experimental Pure Safe derivation leaf. Never imports sdk-core/BaseCoin/Wallet/Safe/key-card.
+ * @experimental Pure Safe derivation and keycard box codec leaf. Never imports sdk-core/BaseCoin/Wallet/Safe/key-card.
  */
 export * from './ed25519KeyDeriver';
 export * from './ed25519Pub';
+export * from './keycardCodec';
 export * from './safeDerivation';
 export * from './safeSlot';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/src/index.js

@@ -17,10 +17,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * @prettier
  *
- * @experimental Pure Safe derivation leaf. Never imports sdk-core/BaseCoin/Wallet/Safe/key-card.
+ * @experimental Pure Safe derivation and keycard box codec leaf. Never imports sdk-core/BaseCoin/Wallet/Safe/key-card.
  */
 __exportStar(require("./ed25519KeyDeriver"), exports);
 __exportStar(require("./ed25519Pub"), exports);
+__exportStar(require("./keycardCodec"), exports);
 __exportStar(require("./safeDerivation"), exports);
 __exportStar(require("./safeSlot"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOzs7O0dBSUc7QUFDSCxzREFBb0M7QUFDcEMsK0NBQTZCO0FBQzdCLG1EQUFpQztBQUNqQyw2Q0FBMkIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwcmV0dGllclxuICpcbiAqIEBleHBlcmltZW50YWwgUHVyZSBTYWZlIGRlcml2YXRpb24gbGVhZi4gTmV2ZXIgaW1wb3J0cyBzZGstY29yZS9CYXNlQ29pbi9XYWxsZXQvU2FmZS9rZXktY2FyZC5cbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9lZDI1NTE5S2V5RGVyaXZlcic7XG5leHBvcnQgKiBmcm9tICcuL2VkMjU1MTlQdWInO1xuZXhwb3J0ICogZnJvbSAnLi9zYWZlRGVyaXZhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3NhZmVTbG90JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOzs7O0dBSUc7QUFDSCxzREFBb0M7QUFDcEMsK0NBQTZCO0FBQzdCLGlEQUErQjtBQUMvQixtREFBaUM7QUFDakMsNkNBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcHJldHRpZXJcbiAqXG4gKiBAZXhwZXJpbWVudGFsIFB1cmUgU2FmZSBkZXJpdmF0aW9uIGFuZCBrZXljYXJkIGJveCBjb2RlYyBsZWFmLiBOZXZlciBpbXBvcnRzIHNkay1jb3JlL0Jhc2VDb2luL1dhbGxldC9TYWZlL2tleS1jYXJkLlxuICovXG5leHBvcnQgKiBmcm9tICcuL2VkMjU1MTlLZXlEZXJpdmVyJztcbmV4cG9ydCAqIGZyb20gJy4vZWQyNTUxOVB1Yic7XG5leHBvcnQgKiBmcm9tICcuL2tleWNhcmRDb2RlYyc7XG5leHBvcnQgKiBmcm9tICcuL3NhZmVEZXJpdmF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vc2FmZVNsb3QnO1xuIl19

package/dist/src/keycardCodec.d.ts

@@ -0,0 +1,24 @@
+import type { RootKeyType } from '@bitgo/public-types';
+/**
+ * Identifier for one of a safe's four roots (one per signing scheme). Each value is the
+ * root's `rootKeyType`, which is also the key used in the keycard's per-box JSON.
+ */
+export type SafeRootKeyType = RootKeyType;
+/**
+ * The JSON object encoded in a safe keycard box (A/B/C): the four roots keyed by
+ * {@link SafeRootKeyType}. Values are per-root ciphertext for A/B (encryptedPrv or
+ * reducedEncryptedPrv; safe MPC ciphertext decrypts to a versioned signing+VRF envelope) or
+ * public keys for C. The root-key-type keys are self-identifying, so a
+ * consumer parses by key rather than by size/offset.
+ */
+export type SafeKeycardRoots = Record<SafeRootKeyType, string>;
+/**
+ * Parses a safe keycard box value — the JSON packed by key-card's `generateSafeQrData`, e.g.
+ * `{"secp256k1Multisig":"…","ecdsaMpc":"…",…}` — into its four roots. Throws if the value is
+ * not valid JSON or any root is missing/non-string. Recovery tooling calls this on the A/B/C
+ * box value, then decrypts each root value with the safe password. An MPC root value is an
+ * opaque versioned envelope; recovery must unwrap its `prvKeyShare` and `vrf` fields instead
+ * of treating the decrypted bytes as a bare share.
+ */
+export declare function parseSafeKeycardBox(data: string): SafeKeycardRoots;
+//# sourceMappingURL=keycardCodec.d.ts.map

package/dist/src/keycardCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keycardCodec.d.ts","sourceRoot":"","sources":["../../src/keycardCodec.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;AAa/D;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAOlE"}

package/dist/src/keycardCodec.js

@@ -0,0 +1,75 @@
+"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.parseSafeKeycardBox = parseSafeKeycardBox;
+/**
+ * @prettier
+ *
+ * @experimental Safe keycard box codec.
+ *
+ * Each of Boxes A/B/C on a Safe keycard is a JSON object mapping a root slot name to that slot's key
+ * string. It lives in this leaf so sdk-core and WRW can parse a box without depending on key-card,
+ * which pulls in PDF/QR libraries and itself depends on sdk-core.
+ */
+const t = __importStar(require("io-ts"));
+const E = __importStar(require("fp-ts/Either"));
+const PathReporter_1 = require("io-ts/lib/PathReporter");
+const io_ts_types_1 = require("io-ts-types");
+// Annotating with SafeKeycardRoots makes the compiler reject a key added to or removed from one side only.
+const SafeKeycardRootsCodec = t.type({
+    secp256k1Multisig: t.string,
+    ecdsaMpc: t.string,
+    eddsaMpc: t.string,
+    ed25519Multisig: t.string,
+});
+// Decodes a box's JSON string straight into the validated roots record.
+const SafeKeycardBoxFromString = io_ts_types_1.JsonFromString.pipe(SafeKeycardRootsCodec);
+/**
+ * Parses a safe keycard box value — the JSON packed by key-card's `generateSafeQrData`, e.g.
+ * `{"secp256k1Multisig":"…","ecdsaMpc":"…",…}` — into its four roots. Throws if the value is
+ * not valid JSON or any root is missing/non-string. Recovery tooling calls this on the A/B/C
+ * box value, then decrypts each root value with the safe password. An MPC root value is an
+ * opaque versioned envelope; recovery must unwrap its `prvKeyShare` and `vrf` fields instead
+ * of treating the decrypted bytes as a bare share.
+ */
+function parseSafeKeycardBox(data) {
+    const decoded = SafeKeycardBoxFromString.decode(data);
+    if (E.isLeft(decoded)) {
+        // PathReporter, not decodeWithCodec: io-ts errors carry no message, so decodeWithCodec would report only "unknown".
+        throw new Error(`parseSafeKeycardBox: ${PathReporter_1.PathReporter.report(decoded).join('; ')}`);
+    }
+    return decoded.right;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/safeDerivation.d.ts

@@ -1,10 +1,10 @@
 /**
  * @prettier
  *
- * @experimental Shared safe child derivation for mint and sign.
+ * @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 server-side at `m/<index>` (not here).
+ * Backup / BitGo children are soft-derived at `m/<index>` client-side for recovery.
  *
  * Do not use `derivedFromParentWithSeed` / `deriveKeyWithSeed` (`m/999999/a/b`) —
  * that is the custody hashed path and cannot reproduce a safe child.

package/dist/src/safeDerivation.js

@@ -43,10 +43,10 @@ exports.deriveSafeChildEd25519Hardened = deriveSafeChildEd25519Hardened;
 /**
  * @prettier
  *
- * @experimental Shared safe child derivation for mint and sign.
+ * @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 server-side at `m/<index>` (not here).
+ * Backup / BitGo children are soft-derived at `m/<index>` client-side for recovery.
  *
  * Do not use `derivedFromParentWithSeed` / `deriveKeyWithSeed` (`m/999999/a/b`) —
  * that is the custody hashed path and cannot reproduce a safe child.
@@ -54,10 +54,10 @@ exports.deriveSafeChildEd25519Hardened = deriveSafeChildEd25519Hardened;
 const t = __importStar(require("io-ts"));
 const nacl = __importStar(require("tweetnacl"));
 const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const statics_1 = require("@bitgo-beta/statics");
 const ed25519KeyDeriver_1 = require("./ed25519KeyDeriver");
 const codecs_1 = require("./codecs");
 const ed25519Pub_1 = require("./ed25519Pub");
-const MAX_BIP32_INDEX = 0x7fffffff;
 exports.DERIVED_FROM_PARENT_WITH_HARDENED_PATH = /^m\/(\d+)'$/;
 function parseSafeDerivationIndex(index) {
     let idx;
@@ -70,7 +70,7 @@ function parseSafeDerivationIndex(index) {
     else {
         throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);
     }
-    if (!Number.isInteger(idx) || idx < 0 || idx > MAX_BIP32_INDEX) {
+    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`);
     }
     return idx;
@@ -148,4 +148,4 @@ function deriveSafeChildEd25519Hardened(rootPrv, index) {
         derivationPath,
     };
 }
-//# 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 and sign.\n *\n * User child: hardened `m/<index>'` from the sequential `safe.derivationIndex[slot]`.\n * Backup / BitGo children are soft-derived server-side at `m/<index>` (not here).\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-beta/utxo-lib';\nimport { Ed25519KeyDeriver } from './ed25519KeyDeriver';\nimport { decodeWithCodec } from './codecs';\nimport { decodeEd25519StrKeySecretSeed, encodeEd25519StrKeyPublicKey } from './ed25519Pub';\n\nconst MAX_BIP32_INDEX = 0x7fffffff;\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: 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-beta/utxo-lib';\nimport { MAX_BIP32_INDEX } from '@bitgo-beta/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"]}

package/dist/src/safeSlot.d.ts

@@ -1,7 +1,14 @@
 import type { RootKeyType } from '@bitgo/public-types';
 type OnchainSafeRootKeySlot = Extract<RootKeyType, 'secp256k1Multisig' | 'ed25519Multisig'>;
-type TssSafeRootKeySlot = Extract<RootKeyType, 'ecdsaMpc'>;
+type TssSafeRootKeySlot = Extract<RootKeyType, 'ecdsaMpc' | 'eddsaMpc'>;
 export declare function onchainSlotForCoin(chain: string): OnchainSafeRootKeySlot;
 export declare function tssSlotForCoin(chain: string): TssSafeRootKeySlot;
+/**
+ * Every safe root slot a coin can be minted under, in deterministic order (onchain first,
+ * then tss). Mirrors wallet-platform's mint truth: the onchain slot is included iff the coin
+ * carries {@link CoinFeature.MULTISIG}, the tss slot iff it carries {@link CoinFeature.TSS}.
+ * A coin that mints under neither (e.g. a Pallas coin) yields `[]`.
+ */
+export declare function safeSlotsForCoin(chain: string): RootKeyType[];
 export {};
 //# sourceMappingURL=safeSlot.d.ts.map

package/dist/src/safeSlot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safeSlot.d.ts","sourceRoot":"","sources":["../../src/safeSlot.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,KAAK,sBAAsB,GAAG,OAAO,CAAC,WAAW,EAAE,mBAAmB,GAAG,iBAAiB,CAAC,CAAC;AAC5F,KAAK,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;AAE3D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,CASxE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAShE"}
+{"version":3,"file":"safeSlot.d.ts","sourceRoot":"","sources":["../../src/safeSlot.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,KAAK,sBAAsB,GAAG,OAAO,CAAC,WAAW,EAAE,mBAAmB,GAAG,iBAAiB,CAAC,CAAC;AAC5F,KAAK,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,CAAC,CAAC;AAYxE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAMxE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAMhE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE,CAW7D"}

package/dist/src/safeSlot.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onchainSlotForCoin = onchainSlotForCoin;
 exports.tssSlotForCoin = tssSlotForCoin;
+exports.safeSlotsForCoin = safeSlotsForCoin;
 /**
  * @prettier
  *
@@ -9,30 +10,51 @@ exports.tssSlotForCoin = tssSlotForCoin;
  *
  * Maps a coin chain + minting model to the safe root slot that derives it. The slot
  * is a signing scheme, not a coin: slot ① secp256k1Multisig serves UTXO + XRP + TRX + …,
- * slot ④ ed25519Multisig serves ALGO/XLM/HBAR, and ecdsaMpc serves TSS coins.
+ * slot ② ed25519Multisig serves ALGO/XLM/HBAR, and the MPC slots serve TSS coins.
  *
  * The multisigType-vs-coin validation stays in sdk-core (it needs IBaseCoin); these
  * functions take only the chain so this leaf never imports sdk-core.
  */
 const statics_1 = require("@bitgo-beta/statics");
+/**
+ * Exhaustive curve → slot registry. Pallas maps to nothing: a Pallas coin has no safe
+ * root slot. The compiler guarantees every {@link KeyCurve} member is present.
+ */
+const CURVE_TO_SLOTS = {
+    [statics_1.KeyCurve.Secp256k1]: { onchain: 'secp256k1Multisig', tss: 'ecdsaMpc' },
+    [statics_1.KeyCurve.Ed25519]: { onchain: 'ed25519Multisig', tss: 'eddsaMpc' },
+    [statics_1.KeyCurve.Pallas]: {},
+};
 function onchainSlotForCoin(chain) {
-    const curve = statics_1.coins.get(chain).primaryKeyCurve;
-    if (curve === statics_1.KeyCurve.Secp256k1) {
-        return 'secp256k1Multisig';
+    const slot = CURVE_TO_SLOTS[statics_1.coins.get(chain).primaryKeyCurve].onchain;
+    if (!slot) {
+        throw new Error(`Coin '${chain}' is not supported for safe wallet minting`);
     }
-    if (curve === statics_1.KeyCurve.Ed25519) {
-        return 'ed25519Multisig';
-    }
-    throw new Error(`Coin '${chain}' is not supported for safe wallet minting`);
+    return slot;
 }
 function tssSlotForCoin(chain) {
-    const curve = statics_1.coins.get(chain).primaryKeyCurve;
-    if (curve === statics_1.KeyCurve.Secp256k1) {
-        return 'ecdsaMpc';
+    const slot = CURVE_TO_SLOTS[statics_1.coins.get(chain).primaryKeyCurve].tss;
+    if (!slot) {
+        throw new Error(`Coin '${chain}' is not supported for safe wallet minting`);
+    }
+    return slot;
+}
+/**
+ * Every safe root slot a coin can be minted under, in deterministic order (onchain first,
+ * then tss). Mirrors wallet-platform's mint truth: the onchain slot is included iff the coin
+ * carries {@link CoinFeature.MULTISIG}, the tss slot iff it carries {@link CoinFeature.TSS}.
+ * A coin that mints under neither (e.g. a Pallas coin) yields `[]`.
+ */
+function safeSlotsForCoin(chain) {
+    const coin = statics_1.coins.get(chain);
+    const { onchain, tss } = CURVE_TO_SLOTS[coin.primaryKeyCurve];
+    const slots = [];
+    if (onchain && coin.features.includes(statics_1.CoinFeature.MULTISIG)) {
+        slots.push(onchain);
     }
-    if (curve === statics_1.KeyCurve.Ed25519) {
-        throw new Error('ed25519 MPC safe wallet minting is not yet supported');
+    if (tss && coin.features.includes(statics_1.CoinFeature.TSS)) {
+        slots.push(tss);
     }
-    throw new Error(`Coin '${chain}' is not supported for safe wallet minting`);
+    return slots;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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