@bitgo-beta/sdk-core 8.2.1-beta.214 → 8.2.1-beta.2140

package/dist/src/bitgo/safe/recovery.d.ts

@@ -0,0 +1,192 @@
+/**
+ * @prettier
+ *
+ * @experimental WRW-facing safe recovery entry points.
+ */
+import { Buffer } from 'buffer';
+import type { RootKeyType } from '@bitgo/public-types';
+import { type Ed25519ExtendedKeyParts, type ExternalEd25519Signer } from './derivableEd25519Pub';
+import { BitGoBase } from '../bitgoBase';
+export type DecryptedMpcSafeRoot = {
+    signing: Buffer;
+    vrf: Buffer;
+};
+export type OnchainSafeRoot = {
+    user: string;
+    backup: string;
+    bitgo: string;
+};
+export type MpcSafeRoot = {
+    user: DecryptedMpcSafeRoot;
+    backup: DecryptedMpcSafeRoot;
+    bitgo: string;
+};
+export type Ed25519MultisigSafeRoot = {
+    user: string;
+    backup: {
+        prv: string;
+        chainCode: string;
+    };
+    bitgo: string;
+};
+export type Secp256k1MultisigChildKeys = {
+    user: {
+        prv: string;
+        pub: string;
+    };
+    backup: {
+        prv: string;
+        pub: string;
+    };
+    bitgo: {
+        pub: string;
+    };
+};
+export type EcdsaMpcChildKeys = {
+    commonKeychain: string;
+    user: string;
+    backup: string;
+};
+export type EddsaMpcChildKeys = EcdsaMpcChildKeys;
+/**
+ * A hardened (SLIP-0010) ed25519 child. The `kind` discriminator prevents a raw seed from being
+ * mistaken for an extended key downstream — both are 32-byte values that `isValidPub` would accept.
+ */
+export type SafeEd25519SeedKey = {
+    readonly kind: 'seed';
+    readonly seed: string;
+    readonly pub: string;
+};
+/**
+ * A soft (BIP32-Ed25519) ed25519 child. No 32-byte seed maps back to a soft-derived child, so the
+ * signer needs both halves directly: `kL` (the clamped scalar) and `kR` (the nonce prefix).
+ */
+export type SafeEd25519ExtendedKey = {
+    readonly kind: 'extended';
+} & Ed25519ExtendedKeyParts<string>;
+/** The three ed25519 co-signer children. BitGo is pub-only: its private key stays in the HSM. */
+export type Ed25519MultisigChildKeys = {
+    user: SafeEd25519SeedKey;
+    backup: SafeEd25519ExtendedKey;
+    bitgo: {
+        readonly pub: string;
+    };
+};
+export type DerivedSafeWalletKeys = {
+    slot: 'secp256k1Multisig';
+    path: string;
+    keys: Secp256k1MultisigChildKeys;
+} | {
+    slot: 'ecdsaMpc';
+    path: string;
+    keys: EcdsaMpcChildKeys;
+} | {
+    slot: 'eddsaMpc';
+    path: string;
+    keys: EddsaMpcChildKeys;
+} | {
+    slot: 'ed25519Multisig';
+    path: string;
+    keys: Ed25519MultisigChildKeys;
+};
+export type SecpSafeRecoverKeyParams = {
+    slot: 'secp256k1Multisig';
+    userKey: string;
+    backupKey: string;
+    bitgoKey: string;
+    walletPassphrase?: string;
+};
+/**
+ * Slot-2 (ed25519Multisig) safe recovery key params. A discriminated union on `mode`, so the invalid
+ * combos are not representable: signed mode always carries the lazy signer and never a `backupKey`,
+ * unsigned mode always carries the encoded `backupKey` and never a signer or passphrase.
+ *
+ * `rootAddress` is the wallet's on-chain address. For ALGO it's the 2-of-3 multisig address over the
+ * three child pubs — derivable here, but `recover()` still requires it as input. Note this is
+ * *derived*, not independently verified against a known wallet address; callers with a recorded
+ * address should cross-check it themselves. For HBAR this field is omitted so the caller's
+ * network-assigned account ID is preserved when the key params are spread into a recovery request.
+ */
+export type Ed25519SafeRecoverKeyParams = {
+    slot: 'ed25519Multisig';
+    mode: 'signed';
+    userKey: string;
+    bitgoKey: string;
+    walletPassphrase: string;
+    rootAddress?: string;
+    /**
+     * Lazy signer for the seedless backup child. The backup child has no seed, so it cannot be
+     * seed-signed; and its signature must cover `tx.bytesToSign()`, which only exists once
+     * `recover()` builds the tx. So instead of a pre-made signature we pass a closure that holds
+     * the private `kL`/`kR` and signs on demand — the private halves never leave it.
+     */
+    externalBackupSigner: ExternalEd25519Signer;
+} | {
+    slot: 'ed25519Multisig';
+    mode: 'unsigned';
+    userKey: string;
+    backupKey: string;
+    bitgoKey: string;
+    rootAddress?: string;
+};
+export type SafeRecoverKeyParams = SecpSafeRecoverKeyParams | Ed25519SafeRecoverKeyParams;
+export type DecryptedSafeRoots = {
+    secp256k1Multisig: OnchainSafeRoot;
+    ed25519Multisig: Ed25519MultisigSafeRoot;
+    ecdsaMpc: MpcSafeRoot;
+    eddsaMpc: MpcSafeRoot;
+};
+export declare function decryptSafeKeycard(params: {
+    bitgo: BitGoBase;
+    userKeyBox: string;
+    backupKeyBox: string;
+    bitgoKeyBox: string;
+    password: string;
+}): Promise<DecryptedSafeRoots>;
+/**
+ * Derives a Safe wallet's child keys at the BIP44 path for a given slot and account.
+ * Supports all four slots: `secp256k1Multisig`, `ed25519Multisig`, `ecdsaMpc`, and `eddsaMpc`.
+ */
+export declare function deriveSafeWalletKeys(params: {
+    coin: string;
+    slot: RootKeyType;
+    account: number;
+    roots: DecryptedSafeRoots;
+}): Promise<DerivedSafeWalletKeys>;
+/**
+ * The request shape for `buildSafeRecoverKeyParams`. The `slot` literal is the discriminant that
+ * ties each slot to its own `keys` shape, so TypeScript narrows `params.keys` automatically and a
+ * slot added without a branch is a compile error rather than a silent cast.
+ */
+export type SafeRecoverKeyParamsRequest = {
+    bitgo: BitGoBase;
+    coin: string;
+    mode: 'signed' | 'unsigned';
+} & ({
+    slot: 'secp256k1Multisig';
+    keys: Secp256k1MultisigChildKeys;
+} | {
+    slot: 'ed25519Multisig';
+    keys: Ed25519MultisigChildKeys;
+} | {
+    slot: 'ecdsaMpc';
+    keys: EcdsaMpcChildKeys;
+} | {
+    slot: 'eddsaMpc';
+    keys: EddsaMpcChildKeys;
+});
+/**
+ * Builds the key fields `coin.recover()` expects from derived Safe child keys.
+ * Supports `secp256k1Multisig` (slot 1) and `ed25519Multisig` (slot 2); the MPC slots fail closed.
+ * Signed mode re-encrypts the child secrets under a fresh ephemeral passphrase (v1/SJCL); unsigned
+ * mode returns pubs. Where supported, `rootAddress` is derived from the child keys, not independently
+ * verified; otherwise it is omitted so the caller can supply it.
+ */
+export declare function buildSafeRecoverKeyParams(params: Extract<SafeRecoverKeyParamsRequest, {
+    slot: 'secp256k1Multisig';
+}>): Promise<SecpSafeRecoverKeyParams>;
+export declare function buildSafeRecoverKeyParams(params: Extract<SafeRecoverKeyParamsRequest, {
+    slot: 'ed25519Multisig';
+}>): Promise<Ed25519SafeRecoverKeyParams>;
+export declare function buildSafeRecoverKeyParams(params: SafeRecoverKeyParamsRequest): Promise<SafeRecoverKeyParams>;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/src/bitgo/safe/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/safe/recovery.ts"],"names":[],"mappings":"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"}

package/dist/src/bitgo/safe/recovery.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptSafeKeycard = decryptSafeKeycard;
+exports.deriveSafeWalletKeys = deriveSafeWalletKeys;
+exports.buildSafeRecoverKeyParams = buildSafeRecoverKeyParams;
+/**
+ * @prettier
+ *
+ * @experimental WRW-facing safe recovery entry points.
+ */
+const buffer_1 = require("buffer");
+const crypto_1 = require("crypto");
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const statics_1 = require("@bitgo-beta/statics");
+const sdk_lib_safes_1 = require("@bitgo-beta/sdk-lib-safes");
+const derivableEd25519Pub_1 = require("./derivableEd25519Pub");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const errors_1 = require("../errors");
+const keyShareEnvelope_1 = require("../utils/tss/keyShareEnvelope");
+async function decryptSafeKeycard(params) {
+    const { bitgo, userKeyBox, backupKeyBox, bitgoKeyBox, password } = params;
+    const userRoots = (0, sdk_lib_safes_1.parseSafeKeycardBox)(userKeyBox);
+    const backupRoots = (0, sdk_lib_safes_1.parseSafeKeycardBox)(backupKeyBox);
+    const bitgoRoots = (0, sdk_lib_safes_1.parseSafeKeycardBox)(bitgoKeyBox);
+    const decryptRoot = async (root) => {
+        try {
+            return await bitgo.decrypt({ input: root, password });
+        }
+        catch (e) {
+            throw new errors_1.IncorrectPasswordError('unable to decrypt the safe keycard with the provided password', e);
+        }
+    };
+    const unwrapMpcRoot = (decrypted) => {
+        try {
+            return (0, keyShareEnvelope_1.parseSafeMpcKeyEnvelopes)(decrypted);
+        }
+        catch (e) {
+            throw new errors_1.IncorrectPasswordError('unable to decrypt the safe keycard with the provided password', e);
+        }
+    };
+    // Only box B's ed25519Multisig slot may carry the derivable `{ prv, chainCode }` object; every
+    // other entry — all of boxes A and C, and every non-ed25519 slot in box B — is a bare string and
+    // fails closed if it carries the object instead.
+    const requireBareString = (entry) => {
+        if (sdk_lib_safes_1.Ed25519ChainCodeEntryCodec.is(entry)) {
+            throw new Error('unexpected ed25519 chain-code entry where a bare string was required');
+        }
+        return entry;
+    };
+    const decryptEd25519Backup = async (entry) => {
+        if (!sdk_lib_safes_1.Ed25519ChainCodeEntryCodec.is(entry)) {
+            throw new Error('ed25519 backup root must carry a chain code');
+        }
+        return { prv: await decryptRoot(entry.prv), chainCode: entry.chainCode };
+    };
+    return {
+        secp256k1Multisig: {
+            user: await decryptRoot(requireBareString(userRoots.secp256k1Multisig)),
+            backup: await decryptRoot(requireBareString(backupRoots.secp256k1Multisig)),
+            bitgo: requireBareString(bitgoRoots.secp256k1Multisig),
+        },
+        ed25519Multisig: {
+            user: await decryptRoot(requireBareString(userRoots.ed25519Multisig)),
+            backup: await decryptEd25519Backup(backupRoots.ed25519Multisig),
+            bitgo: requireBareString(bitgoRoots.ed25519Multisig),
+        },
+        ecdsaMpc: {
+            user: unwrapMpcRoot(await decryptRoot(requireBareString(userRoots.ecdsaMpc))),
+            backup: unwrapMpcRoot(await decryptRoot(requireBareString(backupRoots.ecdsaMpc))),
+            bitgo: requireBareString(bitgoRoots.ecdsaMpc),
+        },
+        eddsaMpc: {
+            user: unwrapMpcRoot(await decryptRoot(requireBareString(userRoots.eddsaMpc))),
+            backup: unwrapMpcRoot(await decryptRoot(requireBareString(backupRoots.eddsaMpc))),
+            bitgo: requireBareString(bitgoRoots.eddsaMpc),
+        },
+    };
+}
+/**
+ * Derives a Safe wallet's child keys at the BIP44 path for a given slot and account.
+ * Supports all four slots: `secp256k1Multisig`, `ed25519Multisig`, `ecdsaMpc`, and `eddsaMpc`.
+ */
+async function deriveSafeWalletKeys(params) {
+    if (!Number.isInteger(params.account) || params.account < 0 || params.account > statics_1.MAX_BIP32_INDEX) {
+        throw new Error(`deriveSafeWalletKeys: invalid account '${params.account}'`);
+    }
+    const { account, roots } = params;
+    const path = (0, sdk_lib_safes_1.buildSafeBip44Path)((0, sdk_lib_safes_1.getSafeBip44CoinType)(params.coin), params.slot, account);
+    const { coinType, slotOrdinal } = (0, sdk_lib_safes_1.parseSafeBip44Path)(path);
+    if (params.slot === 'secp256k1Multisig') {
+        return { slot: 'secp256k1Multisig', path, keys: (0, sdk_lib_safes_1.deriveSafeChildTriplet)(roots.secp256k1Multisig, path) };
+    }
+    if (params.slot === 'ecdsaMpc') {
+        const { commonKeychain, userChild, backupChild } = await sdk_lib_mpc_1.DklsVrfUtils.deriveSafeEcdsaMpcChild({
+            userRoot: roots.ecdsaMpc.user,
+            backupRoot: roots.ecdsaMpc.backup,
+            account,
+            coinType,
+            safeSlotOrdinal: slotOrdinal,
+        });
+        return {
+            slot: 'ecdsaMpc',
+            path,
+            keys: { commonKeychain, user: userChild, backup: backupChild },
+        };
+    }
+    if (params.slot === 'eddsaMpc') {
+        const { commonKeychain, userChild, backupChild } = await sdk_lib_mpc_1.MpsVrfUtils.deriveSafeEddsaMpcChild({
+            userRoot: roots.eddsaMpc.user,
+            backupRoot: roots.eddsaMpc.backup,
+            account,
+            coinType,
+            safeSlotOrdinal: slotOrdinal,
+        });
+        return {
+            slot: 'eddsaMpc',
+            path,
+            keys: { commonKeychain, user: userChild, backup: backupChild },
+        };
+    }
+    if (params.slot === 'ed25519Multisig') {
+        const root = roots.ed25519Multisig;
+        const cosignerPath = (0, sdk_lib_safes_1.toSoftTwinPath)(path);
+        const user = (0, sdk_lib_safes_1.deriveSafeChildEd25519Hardened)(root.user, path);
+        const backup = await (0, derivableEd25519Pub_1.softDeriveChildPrvEd25519AtPath)({
+            seedStrKey: root.backup.prv,
+            chainCode: root.backup.chainCode,
+            path: cosignerPath,
+        });
+        const bitgo = await (0, derivableEd25519Pub_1.softDeriveChildPubEd25519AtPath)(root.bitgo, cosignerPath);
+        return {
+            slot: 'ed25519Multisig',
+            path,
+            keys: {
+                user: { kind: 'seed', seed: user.prv, pub: (0, sdk_lib_safes_1.decodeEd25519StrKeyPublicKey)(user.pub).toString('hex') },
+                backup: {
+                    kind: 'extended',
+                    kL: backup.kL.toString('hex'),
+                    kR: backup.kR.toString('hex'),
+                    pub: backup.pub.toString('hex'),
+                },
+                bitgo: { pub: bitgo.toString('hex') },
+            },
+        };
+    }
+    throw new Error(`deriveSafeWalletKeys: slot '${params.slot}' is not supported yet`);
+}
+/**
+ * Per-coin encoders for the `ed25519Multisig` slot: each slot-2 coin re-encodes the same 32-byte
+ * children into its own address/seed string formats. A coin absent from the registry is not yet
+ * supported for slot-2 recovery (xlm is a future arm).
+ */
+const ALGO_ENCODERS = {
+    encodePub: sdk_lib_safes_1.encodeAlgoKey,
+    encodeSeed: sdk_lib_safes_1.encodeAlgoKey,
+    deriveRootAddress: (userPub, backupPub, bitgoPub) => (0, sdk_lib_safes_1.algoMultisigAddress)(1, 2, [userPub, backupPub, bitgoPub]),
+};
+const ED25519_MULTISIG_COIN_ENCODERS = {
+    algo: ALGO_ENCODERS,
+    talgo: ALGO_ENCODERS,
+    hbar: { encodePub: sdk_lib_safes_1.encodeHbarPublicKeyDer, encodeSeed: sdk_lib_safes_1.encodeHbarPrivateKeyDer },
+    thbar: { encodePub: sdk_lib_safes_1.encodeHbarPublicKeyDer, encodeSeed: sdk_lib_safes_1.encodeHbarPrivateKeyDer },
+};
+async function buildSafeRecoverKeyParams(params) {
+    const { bitgo, mode } = params;
+    if (params.slot === 'ed25519Multisig') {
+        return buildEd25519MultisigRecoverKeyParams(bitgo, params.coin, params.keys, mode);
+    }
+    if (params.slot === 'secp256k1Multisig') {
+        const keys = params.keys;
+        if (mode === 'unsigned') {
+            return {
+                slot: 'secp256k1Multisig',
+                userKey: keys.user.pub,
+                backupKey: keys.backup.pub,
+                bitgoKey: keys.bitgo.pub,
+            };
+        }
+        const userPrv = utxo_lib_1.bip32.fromBase58(keys.user.prv);
+        const backupPrv = utxo_lib_1.bip32.fromBase58(keys.backup.prv);
+        if (!userPrv.privateKey || !backupPrv.privateKey) {
+            throw new Error('buildSafeRecoverKeyParams: keys.user.prv and keys.backup.prv must be private xprvs');
+        }
+        const walletPassphrase = (0, crypto_1.randomBytes)(32).toString('hex');
+        const [userKey, backupKey] = await Promise.all([
+            bitgo.encrypt({ input: keys.user.prv, password: walletPassphrase, encryptionVersion: 1 }),
+            bitgo.encrypt({ input: keys.backup.prv, password: walletPassphrase, encryptionVersion: 1 }),
+        ]);
+        return {
+            slot: 'secp256k1Multisig',
+            userKey,
+            backupKey,
+            bitgoKey: keys.bitgo.pub,
+            walletPassphrase,
+        };
+    }
+    throw new Error(`buildSafeRecoverKeyParams: slot '${params.slot}' is not supported yet`);
+}
+async function buildEd25519MultisigRecoverKeyParams(bitgo, coin, keys, mode) {
+    const encoders = ED25519_MULTISIG_COIN_ENCODERS[coin];
+    if (!encoders) {
+        throw new Error(`buildSafeRecoverKeyParams: coin '${coin}' ed25519Multisig is not supported yet`);
+    }
+    for (const pub of [keys.user.pub, keys.backup.pub, keys.bitgo.pub]) {
+        // strict hex, not length-only: Buffer.from(pub, 'hex') truncates at the first bad pair, so a
+        // length check alone would accept trailing garbage
+        if (!/^[0-9a-f]{64}$/i.test(pub)) {
+            throw new Error('buildSafeRecoverKeyParams: ed25519 child public keys must be 32 bytes');
+        }
+    }
+    const userPub = buffer_1.Buffer.from(keys.user.pub, 'hex');
+    const backupPub = buffer_1.Buffer.from(keys.backup.pub, 'hex');
+    const bitgoPub = buffer_1.Buffer.from(keys.bitgo.pub, 'hex');
+    // The root address is derivable from child pubs for ALGO (version-1 2-of-3 multisig), but
+    // not for HBAR (Hedera account IDs are network-assigned). Each coin declares, via its registry
+    // entry, whether it can derive one; the caller supplies it otherwise.
+    const rootAddress = encoders.deriveRootAddress?.(userPub, backupPub, bitgoPub);
+    const rootAddressParams = rootAddress === undefined ? {} : { rootAddress };
+    if (mode === 'unsigned') {
+        return {
+            slot: 'ed25519Multisig',
+            mode: 'unsigned',
+            userKey: encoders.encodePub(userPub),
+            backupKey: encoders.encodePub(backupPub),
+            bitgoKey: encoders.encodePub(bitgoPub),
+            ...rootAddressParams,
+        };
+    }
+    // The user child is a hardened SLIP-0010 seed, so it re-encrypts exactly like slot 1. The backup
+    // child is a seedless soft extended key: it cannot be re-encrypted as a seed, so it becomes a lazy
+    // external signer over the tx bytes (WCN-2895's extended-key signer, invoked by the coin).
+    const walletPassphrase = (0, crypto_1.randomBytes)(32).toString('hex');
+    const userKey = await bitgo.encrypt({
+        input: encoders.encodeSeed(buffer_1.Buffer.from(keys.user.seed, 'hex')),
+        password: walletPassphrase,
+        encryptionVersion: 1,
+    });
+    return {
+        slot: 'ed25519Multisig',
+        mode: 'signed',
+        userKey,
+        bitgoKey: encoders.encodePub(bitgoPub),
+        walletPassphrase,
+        ...rootAddressParams,
+        externalBackupSigner: {
+            publicKey: keys.backup.pub,
+            sign: async (message) => ({
+                signature: (await (0, derivableEd25519Pub_1.signEd25519Extended)(buffer_1.Buffer.from(message), buffer_1.Buffer.from(keys.backup.kL, 'hex'), buffer_1.Buffer.from(keys.backup.kR, 'hex'))).toString('hex'),
+            }),
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../../../../src/bitgo/safe/recovery.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * @experimental WRW-facing safe recovery entry points.\n */\nimport { Buffer } from 'buffer';\nimport { randomBytes } from 'crypto';\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport { MAX_BIP32_INDEX } from '@bitgo-beta/statics';\nimport type { RootKeyType } from '@bitgo/public-types';\nimport {\n  buildSafeBip44Path,\n  decodeEd25519StrKeyPublicKey,\n  deriveSafeChildEd25519Hardened,\n  deriveSafeChildTriplet,\n  Ed25519ChainCodeEntryCodec,\n  getSafeBip44CoinType,\n  parseSafeBip44Path,\n  parseSafeKeycardBox,\n  toSoftTwinPath,\n  algoMultisigAddress,\n  encodeAlgoKey,\n  encodeHbarPublicKeyDer,\n  encodeHbarPrivateKeyDer,\n  type SafeKeycardRootEntry,\n} from '@bitgo-beta/sdk-lib-safes';\nimport {\n  signEd25519Extended,\n  softDeriveChildPubEd25519AtPath,\n  softDeriveChildPrvEd25519AtPath,\n  type Ed25519ExtendedKeyParts,\n  type ExternalEd25519Signer,\n} from './derivableEd25519Pub';\nimport { DklsVrfUtils, MpsVrfUtils } from '@bitgo-beta/sdk-lib-mpc';\nimport { BitGoBase } from '../bitgoBase';\nimport { IncorrectPasswordError } from '../errors';\nimport { parseSafeMpcKeyEnvelopes } from '../utils/tss/keyShareEnvelope';\n\nexport type DecryptedMpcSafeRoot = { signing: Buffer; vrf: Buffer };\n\nexport type OnchainSafeRoot = { user: string; backup: string; bitgo: string };\nexport type MpcSafeRoot = { user: DecryptedMpcSafeRoot; backup: DecryptedMpcSafeRoot; bitgo: string };\nexport type Ed25519MultisigSafeRoot = {\n  user: string;\n  backup: { prv: string; chainCode: string };\n  bitgo: string;\n};\n\nexport type Secp256k1MultisigChildKeys = {\n  user: { prv: string; pub: string };\n  backup: { prv: string; pub: string };\n  bitgo: { pub: string };\n};\n\nexport type EcdsaMpcChildKeys = {\n  commonKeychain: string;\n  user: string;\n  backup: string;\n};\n\nexport type EddsaMpcChildKeys = EcdsaMpcChildKeys;\n\n/**\n * A hardened (SLIP-0010) ed25519 child. The `kind` discriminator prevents a raw seed from being\n * mistaken for an extended key downstream — both are 32-byte values that `isValidPub` would accept.\n */\nexport type SafeEd25519SeedKey = {\n  readonly kind: 'seed';\n  readonly seed: string; // 32-byte child seed (hex) — the signer input\n  readonly pub: string; // 32-byte public key (hex)\n};\n\n/**\n * A soft (BIP32-Ed25519) ed25519 child. No 32-byte seed maps back to a soft-derived child, so the\n * signer needs both halves directly: `kL` (the clamped scalar) and `kR` (the nonce prefix).\n */\nexport type SafeEd25519ExtendedKey = { readonly kind: 'extended' } & Ed25519ExtendedKeyParts<string>; // hex\n\n/** The three ed25519 co-signer children. BitGo is pub-only: its private key stays in the HSM. */\nexport type Ed25519MultisigChildKeys = {\n  user: SafeEd25519SeedKey;\n  backup: SafeEd25519ExtendedKey;\n  bitgo: { readonly pub: string };\n};\n\nexport type DerivedSafeWalletKeys =\n  | { slot: 'secp256k1Multisig'; path: string; keys: Secp256k1MultisigChildKeys }\n  | { slot: 'ecdsaMpc'; path: string; keys: EcdsaMpcChildKeys }\n  | { slot: 'eddsaMpc'; path: string; keys: EddsaMpcChildKeys }\n  | { slot: 'ed25519Multisig'; path: string; keys: Ed25519MultisigChildKeys };\n\nexport type SecpSafeRecoverKeyParams = {\n  slot: 'secp256k1Multisig';\n  userKey: string;\n  backupKey: string;\n  bitgoKey: string;\n  walletPassphrase?: string;\n};\n\n/**\n * Slot-2 (ed25519Multisig) safe recovery key params. A discriminated union on `mode`, so the invalid\n * combos are not representable: signed mode always carries the lazy signer and never a `backupKey`,\n * unsigned mode always carries the encoded `backupKey` and never a signer or passphrase.\n *\n * `rootAddress` is the wallet's on-chain address. For ALGO it's the 2-of-3 multisig address over the\n * three child pubs — derivable here, but `recover()` still requires it as input. Note this is\n * *derived*, not independently verified against a known wallet address; callers with a recorded\n * address should cross-check it themselves. For HBAR this field is omitted so the caller's\n * network-assigned account ID is preserved when the key params are spread into a recovery request.\n */\nexport type Ed25519SafeRecoverKeyParams =\n  | {\n      slot: 'ed25519Multisig';\n      mode: 'signed';\n      userKey: string;\n      bitgoKey: string;\n      walletPassphrase: string;\n      rootAddress?: string;\n      /**\n       * Lazy signer for the seedless backup child. The backup child has no seed, so it cannot be\n       * seed-signed; and its signature must cover `tx.bytesToSign()`, which only exists once\n       * `recover()` builds the tx. So instead of a pre-made signature we pass a closure that holds\n       * the private `kL`/`kR` and signs on demand — the private halves never leave it.\n       */\n      externalBackupSigner: ExternalEd25519Signer;\n    }\n  | {\n      slot: 'ed25519Multisig';\n      mode: 'unsigned';\n      userKey: string;\n      backupKey: string;\n      bitgoKey: string;\n      rootAddress?: string;\n    };\n\nexport type SafeRecoverKeyParams = SecpSafeRecoverKeyParams | Ed25519SafeRecoverKeyParams;\n\nexport type DecryptedSafeRoots = {\n  secp256k1Multisig: OnchainSafeRoot;\n  ed25519Multisig: Ed25519MultisigSafeRoot;\n  ecdsaMpc: MpcSafeRoot;\n  eddsaMpc: MpcSafeRoot;\n};\n\nexport async function decryptSafeKeycard(params: {\n  bitgo: BitGoBase;\n  userKeyBox: string;\n  backupKeyBox: string;\n  bitgoKeyBox: string;\n  password: string;\n}): Promise<DecryptedSafeRoots> {\n  const { bitgo, userKeyBox, backupKeyBox, bitgoKeyBox, password } = params;\n\n  const userRoots = parseSafeKeycardBox(userKeyBox);\n  const backupRoots = parseSafeKeycardBox(backupKeyBox);\n  const bitgoRoots = parseSafeKeycardBox(bitgoKeyBox);\n\n  const decryptRoot = async (root: string): Promise<string> => {\n    try {\n      return await bitgo.decrypt({ input: root, password });\n    } catch (e) {\n      throw new IncorrectPasswordError('unable to decrypt the safe keycard with the provided password', e);\n    }\n  };\n\n  const unwrapMpcRoot = (decrypted: string): DecryptedMpcSafeRoot => {\n    try {\n      return parseSafeMpcKeyEnvelopes(decrypted);\n    } catch (e) {\n      throw new IncorrectPasswordError('unable to decrypt the safe keycard with the provided password', e);\n    }\n  };\n\n  // Only box B's ed25519Multisig slot may carry the derivable `{ prv, chainCode }` object; every\n  // other entry — all of boxes A and C, and every non-ed25519 slot in box B — is a bare string and\n  // fails closed if it carries the object instead.\n  const requireBareString = (entry: SafeKeycardRootEntry): string => {\n    if (Ed25519ChainCodeEntryCodec.is(entry)) {\n      throw new Error('unexpected ed25519 chain-code entry where a bare string was required');\n    }\n    return entry;\n  };\n\n  const decryptEd25519Backup = async (entry: SafeKeycardRootEntry): Promise<{ prv: string; chainCode: string }> => {\n    if (!Ed25519ChainCodeEntryCodec.is(entry)) {\n      throw new Error('ed25519 backup root must carry a chain code');\n    }\n    return { prv: await decryptRoot(entry.prv), chainCode: entry.chainCode };\n  };\n\n  return {\n    secp256k1Multisig: {\n      user: await decryptRoot(requireBareString(userRoots.secp256k1Multisig)),\n      backup: await decryptRoot(requireBareString(backupRoots.secp256k1Multisig)),\n      bitgo: requireBareString(bitgoRoots.secp256k1Multisig),\n    },\n    ed25519Multisig: {\n      user: await decryptRoot(requireBareString(userRoots.ed25519Multisig)),\n      backup: await decryptEd25519Backup(backupRoots.ed25519Multisig),\n      bitgo: requireBareString(bitgoRoots.ed25519Multisig),\n    },\n    ecdsaMpc: {\n      user: unwrapMpcRoot(await decryptRoot(requireBareString(userRoots.ecdsaMpc))),\n      backup: unwrapMpcRoot(await decryptRoot(requireBareString(backupRoots.ecdsaMpc))),\n      bitgo: requireBareString(bitgoRoots.ecdsaMpc),\n    },\n    eddsaMpc: {\n      user: unwrapMpcRoot(await decryptRoot(requireBareString(userRoots.eddsaMpc))),\n      backup: unwrapMpcRoot(await decryptRoot(requireBareString(backupRoots.eddsaMpc))),\n      bitgo: requireBareString(bitgoRoots.eddsaMpc),\n    },\n  };\n}\n\n/**\n * Derives a Safe wallet's child keys at the BIP44 path for a given slot and account.\n * Supports all four slots: `secp256k1Multisig`, `ed25519Multisig`, `ecdsaMpc`, and `eddsaMpc`.\n */\nexport async function deriveSafeWalletKeys(params: {\n  coin: string;\n  slot: RootKeyType;\n  account: number;\n  roots: DecryptedSafeRoots;\n}): Promise<DerivedSafeWalletKeys> {\n  if (!Number.isInteger(params.account) || params.account < 0 || params.account > MAX_BIP32_INDEX) {\n    throw new Error(`deriveSafeWalletKeys: invalid account '${params.account}'`);\n  }\n\n  const { account, roots } = params;\n  const path = buildSafeBip44Path(getSafeBip44CoinType(params.coin), params.slot, account);\n  const { coinType, slotOrdinal } = parseSafeBip44Path(path);\n\n  if (params.slot === 'secp256k1Multisig') {\n    return { slot: 'secp256k1Multisig', path, keys: deriveSafeChildTriplet(roots.secp256k1Multisig, path) };\n  }\n\n  if (params.slot === 'ecdsaMpc') {\n    const { commonKeychain, userChild, backupChild } = await DklsVrfUtils.deriveSafeEcdsaMpcChild({\n      userRoot: roots.ecdsaMpc.user,\n      backupRoot: roots.ecdsaMpc.backup,\n      account,\n      coinType,\n      safeSlotOrdinal: slotOrdinal,\n    });\n    return {\n      slot: 'ecdsaMpc',\n      path,\n      keys: { commonKeychain, user: userChild, backup: backupChild },\n    };\n  }\n\n  if (params.slot === 'eddsaMpc') {\n    const { commonKeychain, userChild, backupChild } = await MpsVrfUtils.deriveSafeEddsaMpcChild({\n      userRoot: roots.eddsaMpc.user,\n      backupRoot: roots.eddsaMpc.backup,\n      account,\n      coinType,\n      safeSlotOrdinal: slotOrdinal,\n    });\n    return {\n      slot: 'eddsaMpc',\n      path,\n      keys: { commonKeychain, user: userChild, backup: backupChild },\n    };\n  }\n\n  if (params.slot === 'ed25519Multisig') {\n    const root = roots.ed25519Multisig;\n    const cosignerPath = toSoftTwinPath(path);\n\n    const user = deriveSafeChildEd25519Hardened(root.user, path);\n    const backup = await softDeriveChildPrvEd25519AtPath({\n      seedStrKey: root.backup.prv,\n      chainCode: root.backup.chainCode,\n      path: cosignerPath,\n    });\n    const bitgo = await softDeriveChildPubEd25519AtPath(root.bitgo, cosignerPath);\n\n    return {\n      slot: 'ed25519Multisig',\n      path,\n      keys: {\n        user: { kind: 'seed', seed: user.prv, pub: decodeEd25519StrKeyPublicKey(user.pub).toString('hex') },\n        backup: {\n          kind: 'extended',\n          kL: backup.kL.toString('hex'),\n          kR: backup.kR.toString('hex'),\n          pub: backup.pub.toString('hex'),\n        },\n        bitgo: { pub: bitgo.toString('hex') },\n      },\n    };\n  }\n\n  throw new Error(`deriveSafeWalletKeys: slot '${params.slot}' is not supported yet`);\n}\n\n/**\n * Per-coin encoders for the `ed25519Multisig` slot: each slot-2 coin re-encodes the same 32-byte\n * children into its own address/seed string formats. A coin absent from the registry is not yet\n * supported for slot-2 recovery (xlm is a future arm).\n */\nconst ALGO_ENCODERS = {\n  encodePub: encodeAlgoKey,\n  encodeSeed: encodeAlgoKey,\n  deriveRootAddress: (userPub: Buffer, backupPub: Buffer, bitgoPub: Buffer) =>\n    algoMultisigAddress(1, 2, [userPub, backupPub, bitgoPub]),\n};\n\nconst ED25519_MULTISIG_COIN_ENCODERS: Record<\n  string,\n  | {\n      encodePub: (bytes: Buffer) => string;\n      encodeSeed: (bytes: Buffer) => string;\n      deriveRootAddress?: (userPub: Buffer, backupPub: Buffer, bitgoPub: Buffer) => string;\n    }\n  | undefined\n> = {\n  algo: ALGO_ENCODERS,\n  talgo: ALGO_ENCODERS,\n  hbar: { encodePub: encodeHbarPublicKeyDer, encodeSeed: encodeHbarPrivateKeyDer },\n  thbar: { encodePub: encodeHbarPublicKeyDer, encodeSeed: encodeHbarPrivateKeyDer },\n};\n\n/**\n * The request shape for `buildSafeRecoverKeyParams`. The `slot` literal is the discriminant that\n * ties each slot to its own `keys` shape, so TypeScript narrows `params.keys` automatically and a\n * slot added without a branch is a compile error rather than a silent cast.\n */\nexport type SafeRecoverKeyParamsRequest = {\n  bitgo: BitGoBase;\n  coin: string;\n  mode: 'signed' | 'unsigned';\n} & (\n  | { slot: 'secp256k1Multisig'; keys: Secp256k1MultisigChildKeys }\n  | { slot: 'ed25519Multisig'; keys: Ed25519MultisigChildKeys }\n  | { slot: 'ecdsaMpc'; keys: EcdsaMpcChildKeys }\n  | { slot: 'eddsaMpc'; keys: EddsaMpcChildKeys }\n);\n\n/**\n * Builds the key fields `coin.recover()` expects from derived Safe child keys.\n * Supports `secp256k1Multisig` (slot 1) and `ed25519Multisig` (slot 2); the MPC slots fail closed.\n * Signed mode re-encrypts the child secrets under a fresh ephemeral passphrase (v1/SJCL); unsigned\n * mode returns pubs. Where supported, `rootAddress` is derived from the child keys, not independently\n * verified; otherwise it is omitted so the caller can supply it.\n */\nexport async function buildSafeRecoverKeyParams(\n  params: Extract<SafeRecoverKeyParamsRequest, { slot: 'secp256k1Multisig' }>\n): Promise<SecpSafeRecoverKeyParams>;\nexport async function buildSafeRecoverKeyParams(\n  params: Extract<SafeRecoverKeyParamsRequest, { slot: 'ed25519Multisig' }>\n): Promise<Ed25519SafeRecoverKeyParams>;\nexport async function buildSafeRecoverKeyParams(params: SafeRecoverKeyParamsRequest): Promise<SafeRecoverKeyParams>;\nexport async function buildSafeRecoverKeyParams(params: SafeRecoverKeyParamsRequest): Promise<SafeRecoverKeyParams> {\n  const { bitgo, mode } = params;\n\n  if (params.slot === 'ed25519Multisig') {\n    return buildEd25519MultisigRecoverKeyParams(bitgo, params.coin, params.keys, mode);\n  }\n\n  if (params.slot === 'secp256k1Multisig') {\n    const keys = params.keys;\n\n    if (mode === 'unsigned') {\n      return {\n        slot: 'secp256k1Multisig',\n        userKey: keys.user.pub,\n        backupKey: keys.backup.pub,\n        bitgoKey: keys.bitgo.pub,\n      };\n    }\n\n    const userPrv = bip32.fromBase58(keys.user.prv);\n    const backupPrv = bip32.fromBase58(keys.backup.prv);\n    if (!userPrv.privateKey || !backupPrv.privateKey) {\n      throw new Error('buildSafeRecoverKeyParams: keys.user.prv and keys.backup.prv must be private xprvs');\n    }\n\n    const walletPassphrase = randomBytes(32).toString('hex');\n    const [userKey, backupKey] = await Promise.all([\n      bitgo.encrypt({ input: keys.user.prv, password: walletPassphrase, encryptionVersion: 1 }),\n      bitgo.encrypt({ input: keys.backup.prv, password: walletPassphrase, encryptionVersion: 1 }),\n    ]);\n\n    return {\n      slot: 'secp256k1Multisig',\n      userKey,\n      backupKey,\n      bitgoKey: keys.bitgo.pub,\n      walletPassphrase,\n    };\n  }\n\n  throw new Error(`buildSafeRecoverKeyParams: slot '${params.slot}' is not supported yet`);\n}\n\nasync function buildEd25519MultisigRecoverKeyParams(\n  bitgo: BitGoBase,\n  coin: string,\n  keys: Ed25519MultisigChildKeys,\n  mode: 'signed' | 'unsigned'\n): Promise<Ed25519SafeRecoverKeyParams> {\n  const encoders = ED25519_MULTISIG_COIN_ENCODERS[coin];\n  if (!encoders) {\n    throw new Error(`buildSafeRecoverKeyParams: coin '${coin}' ed25519Multisig is not supported yet`);\n  }\n\n  for (const pub of [keys.user.pub, keys.backup.pub, keys.bitgo.pub]) {\n    // strict hex, not length-only: Buffer.from(pub, 'hex') truncates at the first bad pair, so a\n    // length check alone would accept trailing garbage\n    if (!/^[0-9a-f]{64}$/i.test(pub)) {\n      throw new Error('buildSafeRecoverKeyParams: ed25519 child public keys must be 32 bytes');\n    }\n  }\n\n  const userPub = Buffer.from(keys.user.pub, 'hex');\n  const backupPub = Buffer.from(keys.backup.pub, 'hex');\n  const bitgoPub = Buffer.from(keys.bitgo.pub, 'hex');\n\n  // The root address is derivable from child pubs for ALGO (version-1 2-of-3 multisig), but\n  // not for HBAR (Hedera account IDs are network-assigned). Each coin declares, via its registry\n  // entry, whether it can derive one; the caller supplies it otherwise.\n  const rootAddress = encoders.deriveRootAddress?.(userPub, backupPub, bitgoPub);\n  const rootAddressParams = rootAddress === undefined ? {} : { rootAddress };\n\n  if (mode === 'unsigned') {\n    return {\n      slot: 'ed25519Multisig',\n      mode: 'unsigned',\n      userKey: encoders.encodePub(userPub),\n      backupKey: encoders.encodePub(backupPub),\n      bitgoKey: encoders.encodePub(bitgoPub),\n      ...rootAddressParams,\n    };\n  }\n\n  // The user child is a hardened SLIP-0010 seed, so it re-encrypts exactly like slot 1. The backup\n  // child is a seedless soft extended key: it cannot be re-encrypted as a seed, so it becomes a lazy\n  // external signer over the tx bytes (WCN-2895's extended-key signer, invoked by the coin).\n  const walletPassphrase = randomBytes(32).toString('hex');\n  const userKey = await bitgo.encrypt({\n    input: encoders.encodeSeed(Buffer.from(keys.user.seed, 'hex')),\n    password: walletPassphrase,\n    encryptionVersion: 1,\n  });\n\n  return {\n    slot: 'ed25519Multisig',\n    mode: 'signed',\n    userKey,\n    bitgoKey: encoders.encodePub(bitgoPub),\n    walletPassphrase,\n    ...rootAddressParams,\n    externalBackupSigner: {\n      publicKey: keys.backup.pub,\n      sign: async (message) => ({\n        signature: (\n          await signEd25519Extended(\n            Buffer.from(message),\n            Buffer.from(keys.backup.kL, 'hex'),\n            Buffer.from(keys.backup.kR, 'hex')\n          )\n        ).toString('hex'),\n      }),\n    },\n  };\n}\n"]}

package/dist/src/bitgo/safe/rootCoin.d.ts

@@ -0,0 +1,15 @@
+import { RootKeyType } from '@bitgo/public-types';
+import { IBaseCoin } from '../baseCoin';
+import { BitGoBase } from '../bitgoBase';
+/**
+ * Canonical order of the safe root slots. Shared by safe minting (Safes.createSafeKeys) and
+ * passkey register/remove (Safe) so both iterate the slots identically.
+ * @experimental
+ */
+export declare const SAFE_ROOT_SLOTS: RootKeyType[];
+/**
+ * Coin used to route a given root's key operations (see ROOT_COIN_BY_NETWORK).
+ * @experimental
+ */
+export declare function coinForRoot(bitgo: BitGoBase, slot: RootKeyType): IBaseCoin;
+//# sourceMappingURL=rootCoin.d.ts.map

package/dist/src/bitgo/safe/rootCoin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootCoin.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/safe/rootCoin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,EAAqE,CAAC;AA4B/G;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,GAAG,SAAS,CAK1E"}

package/dist/src/bitgo/safe/rootCoin.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAFE_ROOT_SLOTS = void 0;
+exports.coinForRoot = coinForRoot;
+const common_1 = require("../../common");
+/**
+ * Canonical order of the safe root slots. Shared by safe minting (Safes.createSafeKeys) and
+ * passkey register/remove (Safe) so both iterate the slots identically.
+ * @experimental
+ */
+exports.SAFE_ROOT_SLOTS = ['secp256k1Multisig', 'ed25519Multisig', 'ecdsaMpc', 'eddsaMpc'];
+/**
+ * Representative coin per root slot, by network. Safe roots are curve/scheme-scoped, not
+ * coin-scoped — WP stamps `curve` server-side from the coin's key curve, so any coin of the
+ * right (curve, scheme) works. These are stable, always-available choices used only to route
+ * the key ceremony; the resulting root is interchangeable across coins of the slot.
+ * @experimental
+ */
+const ROOT_COIN_BY_NETWORK = {
+    mainnet: {
+        // multisig roots
+        secp256k1Multisig: 'btc',
+        ed25519Multisig: 'xlm',
+        // MPC roots
+        ecdsaMpc: 'eth',
+        eddsaMpc: 'sol',
+    },
+    testnet: {
+        // multisig roots
+        secp256k1Multisig: 'tbtc',
+        ed25519Multisig: 'txlm',
+        // MPC roots
+        ecdsaMpc: 'hteth',
+        eddsaMpc: 'tsol',
+    },
+};
+/**
+ * Coin used to route a given root's key operations (see ROOT_COIN_BY_NETWORK).
+ * @experimental
+ */
+function coinForRoot(bitgo, slot) {
+    // V1Network is exactly 'bitcoin' | 'testnet', so this branch is exhaustive over every
+    // environment: 'bitcoin' is mainnet and every other value is a testnet.
+    const network = common_1.Environments[bitgo.getEnv()].network === 'bitcoin' ? 'mainnet' : 'testnet';
+    return bitgo.coin(ROOT_COIN_BY_NETWORK[network][slot]);
+}
+//# sourceMappingURL=data:application/json;base64,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