@bitgo-beta/sdk-core 8.2.1-beta.21 → 8.2.1-beta.2100

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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

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

@@ -0,0 +1,88 @@
+import { FreezeSafeBody, SafeData, SafeShareData, SafeShareState } from '@bitgo/public-types';
+import { BitGoBase } from '../bitgoBase';
+import { Wallet } from '../wallet';
+import { AcceptSafeShareOptions, AddSafeMemberOptions, AddSafeWalletMemberOptions, CreateSafeWalletOptions, ISafe, RegisterSafePasskeyOptions, RegisterSafePasskeyResponse, RemoveSafePasskeyOptions, UpdateSafeOptions, WalletShareData } from './iSafe';
+/**
+ * @experimental
+ */
+export declare class Safe implements ISafe {
+    private readonly bitgo;
+    readonly _safe: SafeData;
+    constructor(bitgo: BitGoBase, safeData: SafeData);
+    id(): string;
+    enterpriseId(): string;
+    label(): string;
+    status(): SafeData['status'];
+    /**
+     * Enterprise-scoped v2 URL for this safe, e.g. /api/v2/enterprise/:eId/safes/:safeId
+     * @param extra
+     */
+    url(extra?: string): string;
+    /**
+     * Mint a child wallet: peek the sequential index, derive the child keys, register
+     * them, then mint.
+     *
+     * `onchain`: hardened-derive the user child (`m/<index>'`), register it
+     * public-only; backup and BitGo children are soft-derived on the server.
+     *
+     * `tss`: decrypt the user root blob, run the user/BitGo hard-derive ceremony,
+     * register the ordered child documents, then mint.
+     */
+    createWallet(params: CreateSafeWalletOptions): Promise<Wallet>;
+    /**
+     * TSS wallet mint: decrypt the user root blob, run the user/BitGo hard-derive
+     * ceremony, register the ordered child documents, then mint.
+     */
+    private createTssWalletInSafe;
+    private fetchSafeData;
+    /**
+     * Add a member to the whole safe (view/admin/spend). Spend opens a key share.
+     */
+    addMember(params: AddSafeMemberOptions): Promise<SafeData>;
+    /**
+     * Share ONE safe wallet with a non-member via the existing wallet-share handshake.
+     */
+    addMemberToWallet(params: AddSafeWalletMemberOptions): Promise<WalletShareData>;
+    /**
+     * List the safe key shares visible to the caller.
+     */
+    listShares(params?: {
+        state?: SafeShareState;
+    }): Promise<SafeShareData[]>;
+    /**
+     * Accept a safe key share addressed to the caller.
+     */
+    acceptShare(params: AcceptSafeShareOptions): Promise<SafeShareData>;
+    /**
+     * Update the safe label.
+     */
+    update(params: UpdateSafeOptions): Promise<SafeData>;
+    /**
+     * Freeze the safe — blocks withdrawals on all safe wallets. Safe stays 'active'.
+     * @param params
+     */
+    freeze(params?: FreezeSafeBody): Promise<SafeData>;
+    /**
+     * Archive the safe. Requires every safe wallet to already be archived; also the abandonment
+     * path for a stuck 'initializing' safe.
+     */
+    archive(): Promise<SafeData>;
+    /**
+     * Register a PRF passkey on every user root of the safe.
+     *
+     * For each user root (position 0 of each populated slot), decrypt the root with the Safe
+     * password, then re-encrypt it under the PRF-derived password (bound to the enterprise via
+     * AES-GCM AAD). One PRF assertion serves the whole safe; the write set is the user roots only
+     * — backup and BitGo roots are never wrapped.
+     */
+    registerPasskey(params: RegisterSafePasskeyOptions): Promise<RegisterSafePasskeyResponse>;
+    /**
+     * Remove a PRF passkey from every user root of the safe.
+     *
+     * The Safe password is verified client-side (decrypt one user root) before the server is
+     * called; the server enforces owner authorization and performs the idempotent per-root `$pull`.
+     */
+    removePasskey(params: RemoveSafePasskeyOptions): Promise<void>;
+    toJSON(): SafeData;
+}
+//# sourceMappingURL=safe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"safe.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/safe/safe.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAoB,MAAM,qBAAqB,CAAC;AAEhH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAMzC,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGnC,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,KAAK,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,iBAAiB,EACjB,eAAe,EAChB,MAAM,SAAS,CAAC;AAiEjB;;GAEG;AACH,qBAAa,IAAK,YAAW,KAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,SAAgB,KAAK,EAAE,QAAQ,CAAC;gBAEpB,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ;IAKhD,EAAE,IAAI,MAAM;IAIZ,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAIf,MAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC;IAI5B;;;OAGG;IACH,GAAG,CAAC,KAAK,SAAK,GAAG,MAAM;IAIvB;;;;;;;;;OASG;IACG,YAAY,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC;IAkFpE;;;OAGG;YACW,qBAAqB;YAuDrB,aAAa;IAK3B;;OAEG;IACG,SAAS,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAIhE;;OAEG;IACG,iBAAiB,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,eAAe,CAAC;IAIrF;;OAEG;IACG,UAAU,CAAC,MAAM,GAAE;QAAE,KAAK,CAAC,EAAE,cAAc,CAAA;KAAO,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAInF;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,aAAa,CAAC;IAIzE;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAK1D;;;OAGG;IACG,MAAM,CAAC,MAAM,GAAE,cAAmB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAK5D;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;IAKlC;;;;;;;OAOG;IACG,eAAe,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAqE/F;;;;;OAKG;IACG,aAAa,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BpE,MAAM,IAAI,QAAQ;CAGnB"}

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

@@ -0,0 +1,409 @@
+"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.Safe = void 0;
+/**
+ * @prettier
+ *
+ * @experimental The safe client surface is experimental and may change (including breaking
+ * changes) before the public release.
+ */
+const t = __importStar(require("io-ts"));
+const public_types_1 = require("@bitgo/public-types");
+const errors_1 = require("../errors");
+const keychain_1 = require("../keychain");
+const utils_1 = require("../utils");
+const codecs_1 = require("../utils/codecs");
+const postWithCodec_1 = require("../utils/postWithCodec");
+const wallet_1 = require("../wallet");
+const safeKeychain_1 = require("../wallet/safeKeychain");
+const webauthn_1 = require("../webauthn");
+const rootCoin_1 = require("./rootCoin");
+const sdk_lib_safes_1 = require("@bitgo-beta/sdk-lib-safes");
+const SafeRootKeySlot = t.keyof({
+    secp256k1Multisig: null,
+    ecdsaMpc: null,
+    eddsaMpc: null,
+    ed25519Multisig: null,
+});
+const GetDerivationIndexResponse = t.type({
+    slot: SafeRootKeySlot,
+    index: (0, codecs_1.boundedInt)(0, 0x7fffffff, 'derivationIndex'),
+});
+const CreateWalletInSafeBody = t.union([
+    t.strict({
+        coin: t.string,
+        label: t.string,
+        type: t.literal('hot'),
+        multisigType: t.literal('onchain'),
+        keys: t.tuple([t.string]),
+    }),
+    // TSS mint uses ordered user, backup, and BitGo child documents.
+    t.strict({
+        coin: t.string,
+        label: t.string,
+        type: t.literal('hot'),
+        multisigType: t.literal('tss'),
+        keys: t.tuple([t.string, t.string, t.string]),
+    }),
+]);
+const PasskeyEntryCodec = t.type({
+    keyId: t.string,
+    encryptedPrv: t.string,
+});
+const RegisterSafePasskeyBody = t.type({
+    otpDeviceId: t.string,
+    prfSalt: t.string,
+    entries: t.array(PasskeyEntryCodec),
+});
+const RegisterSafePasskeyResponseCodec = t.type({
+    otpDeviceId: t.string,
+    updatedKeys: t.array(t.string),
+});
+function rootIdFromSafe(safe, slot, position) {
+    const triplet = safe.rootKeys?.hot?.[slot];
+    if (!triplet || triplet.length !== 3) {
+        return undefined;
+    }
+    const rootId = triplet[position];
+    return rootId.length > 0 ? rootId : undefined;
+}
+/**
+ * @experimental
+ */
+class Safe {
+    constructor(bitgo, safeData) {
+        this.bitgo = bitgo;
+        this._safe = safeData;
+    }
+    id() {
+        return this._safe.id;
+    }
+    enterpriseId() {
+        return this._safe.enterpriseId;
+    }
+    label() {
+        return this._safe.label;
+    }
+    status() {
+        return this._safe.status;
+    }
+    /**
+     * Enterprise-scoped v2 URL for this safe, e.g. /api/v2/enterprise/:eId/safes/:safeId
+     * @param extra
+     */
+    url(extra = '') {
+        return this.bitgo.url(`/enterprise/${this.enterpriseId()}/safes/${this.id()}${extra}`, 2);
+    }
+    /**
+     * Mint a child wallet: peek the sequential index, derive the child keys, register
+     * them, then mint.
+     *
+     * `onchain`: hardened-derive the user child (`m/<index>'`), register it
+     * public-only; backup and BitGo children are soft-derived on the server.
+     *
+     * `tss`: decrypt the user root blob, run the user/BitGo hard-derive ceremony,
+     * register the ordered child documents, then mint.
+     */
+    async createWallet(params) {
+        if (params.passphrase.length === 0) {
+            throw new Error('passphrase is required to mint a safe wallet');
+        }
+        if (params.type !== undefined && params.type !== 'hot') {
+            throw new Error('Safe wallets are hot-only in v1');
+        }
+        const multisigType = params.multisigType ?? 'onchain';
+        const isTss = multisigType === 'tss';
+        const coin = this.bitgo.coin(params.coin);
+        const slot = isTss ? (0, sdk_lib_safes_1.tssSlotForCoin)(coin.getChain()) : (0, sdk_lib_safes_1.onchainSlotForCoin)(coin.getChain());
+        const indexResponse = await this.bitgo.get(this.url('/derivation-index')).query({ slot }).result();
+        const peeked = (0, codecs_1.decodeWithCodec)(GetDerivationIndexResponse, indexResponse, 'GetDerivationIndexResponse');
+        if (peeked.slot !== slot) {
+            throw new Error(`derivation-index returned slot '${peeked.slot}', expected '${slot}'`);
+        }
+        const { index } = peeked;
+        const safeData = rootIdFromSafe(this._safe, slot, 0) !== undefined ? this._safe : await this.fetchSafeData();
+        const userRootId = rootIdFromSafe(safeData, slot, 0);
+        if (userRootId === undefined) {
+            throw new Error(`Safe ${this.id()} is missing rootKeys.hot.${slot}`);
+        }
+        if (isTss) {
+            const backupRootId = rootIdFromSafe(safeData, slot, 1);
+            const bitgoRootId = rootIdFromSafe(safeData, slot, 2);
+            if (backupRootId === undefined) {
+                throw new Error(`Safe ${this.id()} is missing rootKeys.hot.${slot} backup key`);
+            }
+            if (bitgoRootId === undefined) {
+                throw new Error(`Safe ${this.id()} is missing rootKeys.hot.${slot} bitgo key`);
+            }
+            return this.createTssWalletInSafe(coin, slot, userRootId, backupRootId, bitgoRootId, index, params);
+        }
+        const keychains = coin.keychains();
+        const rootKeychain = await keychains.get({ id: userRootId });
+        if (rootKeychain.source !== 'user') {
+            throw new safeKeychain_1.InvalidRootKeychainSourceError(rootKeychain.id, rootKeychain.source);
+        }
+        const rootPrv = await (0, keychain_1.decryptKeychainPrivateKey)(this.bitgo, rootKeychain, params.passphrase);
+        if (!rootPrv) {
+            throw new errors_1.IncorrectPasswordError();
+        }
+        const derived = slot === 'ed25519Multisig'
+            ? (0, sdk_lib_safes_1.deriveSafeChildEd25519Hardened)(rootPrv, index)
+            : (0, sdk_lib_safes_1.deriveAndSelfCheckSafeChildHardened)(rootPrv, index);
+        const derivedFromParentWithHardenedPath = (0, codecs_1.decodeWithCodec)(sdk_lib_safes_1.DerivedFromParentWithHardenedPath, derived.derivationPath, 'derivedFromParentWithHardenedPath');
+        const child = await keychains.add({
+            pub: derived.pub,
+            source: 'user',
+            keyType: 'independent',
+            parent: userRootId,
+            safeId: this.id(),
+            derivedFromParentWithPath: derivedFromParentWithHardenedPath,
+        });
+        const childId = child.id;
+        if (childId.length === 0) {
+            throw new Error('safe child key registration returned an empty id');
+        }
+        const keys = [childId];
+        const response = await (0, postWithCodec_1.postWithCodec)(this.bitgo, this.url('/wallets'), CreateWalletInSafeBody, {
+            coin: params.coin,
+            label: params.label,
+            type: 'hot',
+            multisigType,
+            keys,
+        }).result();
+        return new wallet_1.Wallet(this.bitgo, coin, response);
+    }
+    /**
+     * TSS wallet mint: decrypt the user root blob, run the user/BitGo hard-derive
+     * ceremony, register the ordered child documents, then mint.
+     */
+    async createTssWalletInSafe(coin, slot, userRootId, backupRootId, bitgoRootId, index, params) {
+        if (slot !== 'ecdsaMpc' && slot !== 'eddsaMpc') {
+            throw new Error(`Expected an MPC safe root slot, got '${slot}'`);
+        }
+        const keychains = coin.keychains();
+        const userRootKeychain = await keychains.get({ id: userRootId });
+        if (userRootKeychain.source !== 'user') {
+            throw new safeKeychain_1.InvalidRootKeychainSourceError(userRootKeychain.id, userRootKeychain.source);
+        }
+        const userRootPrv = await (0, keychain_1.decryptKeychainPrivateKey)(this.bitgo, userRootKeychain, params.passphrase);
+        if (!userRootPrv) {
+            throw new errors_1.IncorrectPasswordError();
+        }
+        const userRootMaterial = (0, utils_1.parseSafeMpcKeyEnvelopes)(userRootPrv);
+        const tssUtils = slot === 'eddsaMpc'
+            ? new utils_1.EDDSAUtils.EddsaVrfMPCv2Utils(this.bitgo, coin)
+            : new utils_1.ECDSAUtils.EcdsaVrfMPCv2Utils(this.bitgo, coin);
+        const { userKeychain, backupKeychain, bitgoKeychain } = await tssUtils.createSafeChildKeychains({
+            passphrase: params.passphrase,
+            enterprise: this.enterpriseId(),
+            safeId: this.id(),
+            parentKeyId: bitgoRootId,
+            derivationIndex: index,
+            userRootKeyId: userRootId,
+            backupRootKeyId: backupRootId,
+            userRootKeyShare: userRootMaterial.signing,
+            userRootVrfKeyShare: userRootMaterial.vrf,
+        });
+        if (userKeychain.id.length === 0 || backupKeychain.id.length === 0 || bitgoKeychain.id.length === 0) {
+            throw new Error('safe child key registration returned an empty id');
+        }
+        const keys = [userKeychain.id, backupKeychain.id, bitgoKeychain.id];
+        const response = await (0, postWithCodec_1.postWithCodec)(this.bitgo, this.url('/wallets'), CreateWalletInSafeBody, {
+            coin: params.coin,
+            label: params.label,
+            type: 'hot',
+            multisigType: 'tss',
+            keys,
+        }).result();
+        return new wallet_1.Wallet(this.bitgo, coin, response);
+    }
+    async fetchSafeData() {
+        const response = await this.bitgo.get(this.url()).result();
+        return (0, codecs_1.decodeWithCodec)(public_types_1.SafeData, response, 'SafeData');
+    }
+    /**
+     * Add a member to the whole safe (view/admin/spend). Spend opens a key share.
+     */
+    async addMember(params) {
+        throw new Error('Safe.addMember is not yet implemented');
+    }
+    /**
+     * Share ONE safe wallet with a non-member via the existing wallet-share handshake.
+     */
+    async addMemberToWallet(params) {
+        throw new Error('Safe.addMemberToWallet is not yet implemented');
+    }
+    /**
+     * List the safe key shares visible to the caller.
+     */
+    async listShares(params = {}) {
+        throw new Error('Safe.listShares is not yet implemented');
+    }
+    /**
+     * Accept a safe key share addressed to the caller.
+     */
+    async acceptShare(params) {
+        throw new Error('Safe.acceptShare is not yet implemented');
+    }
+    /**
+     * Update the safe label.
+     */
+    async update(params) {
+        const response = await this.bitgo.put(this.url()).send({ label: params.label }).result();
+        return (0, codecs_1.decodeWithCodec)(public_types_1.SafeData, response, 'SafeData');
+    }
+    /**
+     * Freeze the safe — blocks withdrawals on all safe wallets. Safe stays 'active'.
+     * @param params
+     */
+    async freeze(params = {}) {
+        const response = await (0, postWithCodec_1.postWithCodec)(this.bitgo, this.url('/freeze'), public_types_1.FreezeSafeBody, params).result();
+        return (0, codecs_1.decodeWithCodec)(public_types_1.SafeData, response, 'SafeData');
+    }
+    /**
+     * Archive the safe. Requires every safe wallet to already be archived; also the abandonment
+     * path for a stuck 'initializing' safe.
+     */
+    async archive() {
+        const response = await this.bitgo.post(this.url('/archive')).send().result();
+        return (0, codecs_1.decodeWithCodec)(public_types_1.SafeData, response, 'SafeData');
+    }
+    /**
+     * Register a PRF passkey on every user root of the safe.
+     *
+     * For each user root (position 0 of each populated slot), decrypt the root with the Safe
+     * password, then re-encrypt it under the PRF-derived password (bound to the enterprise via
+     * AES-GCM AAD). One PRF assertion serves the whole safe; the write set is the user roots only
+     * — backup and BitGo roots are never wrapped.
+     */
+    async registerPasskey(params) {
+        const { device, safePassphrase, provider, encryptionVersion } = params;
+        if (!device.id) {
+            throw new Error('device.id is required to register a passkey on the safe');
+        }
+        if (!device.prfSalt) {
+            throw new Error('PRF extension not supported by this device. Please use a different passkey.');
+        }
+        const enterpriseId = this.enterpriseId();
+        const prfSalt = (0, webauthn_1.deriveEnterpriseSalt)(device.prfSalt, enterpriseId);
+        const entries = [];
+        for (const slot of rootCoin_1.SAFE_ROOT_SLOTS) {
+            const userRootId = rootIdFromSafe(this._safe, slot, 0);
+            if (userRootId === undefined) {
+                continue;
+            }
+            const keychain = await (0, rootCoin_1.coinForRoot)(this.bitgo, slot).keychains().get({ id: userRootId });
+            if (keychain.source !== 'user') {
+                throw new safeKeychain_1.InvalidRootKeychainSourceError(keychain.id, keychain.source);
+            }
+            const rootPrv = await (0, keychain_1.decryptKeychainPrivateKey)(this.bitgo, keychain, safePassphrase);
+            if (!rootPrv) {
+                throw new errors_1.IncorrectPasswordError();
+            }
+            entries.push({ keyId: userRootId, encryptedPrv: rootPrv });
+        }
+        if (entries.length === 0) {
+            throw new Error(`Safe ${this.id()} has no user roots to attach a passkey to`);
+        }
+        const nodeBuf = (0, webauthn_1.base64UrlToBuffer)(device.credentialId);
+        const credentialIdBuffer = nodeBuf.buffer.slice(nodeBuf.byteOffset, nodeBuf.byteOffset + nodeBuf.byteLength);
+        const authResult = await provider.get({
+            publicKey: {
+                allowCredentials: [{ type: 'public-key', id: credentialIdBuffer }],
+            },
+            evalByCredential: { [device.credentialId]: prfSalt },
+        });
+        if (!authResult.prfResult) {
+            throw new Error('PRF assertion did not return a result.');
+        }
+        if ((0, webauthn_1.toBase64Url)(authResult.credentialId) !== (0, webauthn_1.toBase64Url)(device.credentialId)) {
+            throw new Error('PRF assertion returned an unexpected credential.');
+        }
+        const prfPassword = (0, webauthn_1.derivePassword)(authResult.prfResult);
+        const wrappedEntries = await Promise.all(entries.map(async ({ keyId, encryptedPrv }) => ({
+            keyId,
+            encryptedPrv: await this.bitgo.encrypt({
+                password: prfPassword,
+                input: encryptedPrv,
+                encryptionVersion,
+                adata: enterpriseId,
+            }),
+        })));
+        const response = await (0, postWithCodec_1.postWithCodec)(this.bitgo, this.url('/passkeys'), RegisterSafePasskeyBody, {
+            otpDeviceId: device.id,
+            prfSalt,
+            entries: wrappedEntries,
+        }).result();
+        return (0, codecs_1.decodeWithCodec)(RegisterSafePasskeyResponseCodec, response, 'RegisterSafePasskeyResponse');
+    }
+    /**
+     * Remove a PRF passkey from every user root of the safe.
+     *
+     * The Safe password is verified client-side (decrypt one user root) before the server is
+     * called; the server enforces owner authorization and performs the idempotent per-root `$pull`.
+     */
+    async removePasskey(params) {
+        const { device, safePassphrase } = params;
+        if (!device.id) {
+            throw new Error('device.id is required to remove a passkey from the safe');
+        }
+        const userRoots = rootCoin_1.SAFE_ROOT_SLOTS.flatMap((slot) => {
+            const userRootId = rootIdFromSafe(this._safe, slot, 0);
+            return userRootId === undefined ? [] : [{ slot, userRootId }];
+        });
+        if (userRoots.length === 0) {
+            throw new Error(`Safe ${this.id()} has no user roots to remove a passkey from`);
+        }
+        let verified = false;
+        for (const { slot, userRootId } of userRoots) {
+            const keychain = await (0, rootCoin_1.coinForRoot)(this.bitgo, slot).keychains().get({ id: userRootId });
+            const decrypted = await (0, keychain_1.decryptKeychainPrivateKey)(this.bitgo, keychain, safePassphrase);
+            if (decrypted) {
+                verified = true;
+                break;
+            }
+        }
+        if (!verified) {
+            throw new errors_1.IncorrectPasswordError();
+        }
+        await this.bitgo.del(this.url(`/passkeys/${device.id}`)).result();
+    }
+    toJSON() {
+        return this._safe;
+    }
+}
+exports.Safe = Safe;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safe.js","sourceRoot":"","sources":["../../../../src/bitgo/safe/safe.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * @experimental The safe client surface is experimental and may change (including breaking\n * changes) before the public release.\n */\nimport * as t from 'io-ts';\nimport { FreezeSafeBody, SafeData, SafeShareData, SafeShareState, type RootKeyType } from '@bitgo/public-types';\nimport { IBaseCoin } from '../baseCoin';\nimport { BitGoBase } from '../bitgoBase';\nimport { IncorrectPasswordError } from '../errors';\nimport { decryptKeychainPrivateKey } from '../keychain';\nimport { ECDSAUtils, parseSafeMpcKeyEnvelopes, EDDSAUtils } from '../utils';\nimport { boundedInt, decodeWithCodec } from '../utils/codecs';\nimport { postWithCodec } from '../utils/postWithCodec';\nimport { Wallet } from '../wallet';\nimport { InvalidRootKeychainSourceError } from '../wallet/safeKeychain';\nimport { base64UrlToBuffer, deriveEnterpriseSalt, derivePassword, toBase64Url } from '../webauthn';\nimport {\n  AcceptSafeShareOptions,\n  AddSafeMemberOptions,\n  AddSafeWalletMemberOptions,\n  CreateSafeWalletOptions,\n  ISafe,\n  RegisterSafePasskeyOptions,\n  RegisterSafePasskeyResponse,\n  RemoveSafePasskeyOptions,\n  UpdateSafeOptions,\n  WalletShareData,\n} from './iSafe';\nimport { coinForRoot, SAFE_ROOT_SLOTS } from './rootCoin';\nimport {\n  deriveAndSelfCheckSafeChildHardened,\n  deriveSafeChildEd25519Hardened,\n  DerivedFromParentWithHardenedPath,\n  onchainSlotForCoin,\n  tssSlotForCoin,\n} from '@bitgo-beta/sdk-lib-safes';\n\nconst SafeRootKeySlot = t.keyof({\n  secp256k1Multisig: null,\n  ecdsaMpc: null,\n  eddsaMpc: null,\n  ed25519Multisig: null,\n});\n\nconst GetDerivationIndexResponse = t.type({\n  slot: SafeRootKeySlot,\n  index: boundedInt(0, 0x7fffffff, 'derivationIndex'),\n});\n\nconst CreateWalletInSafeBody = t.union([\n  t.strict({\n    coin: t.string,\n    label: t.string,\n    type: t.literal('hot'),\n    multisigType: t.literal('onchain'),\n    keys: t.tuple([t.string]),\n  }),\n  // TSS mint uses ordered user, backup, and BitGo child documents.\n  t.strict({\n    coin: t.string,\n    label: t.string,\n    type: t.literal('hot'),\n    multisigType: t.literal('tss'),\n    keys: t.tuple([t.string, t.string, t.string]),\n  }),\n]);\n\nconst PasskeyEntryCodec = t.type({\n  keyId: t.string,\n  encryptedPrv: t.string,\n});\n\nconst RegisterSafePasskeyBody = t.type({\n  otpDeviceId: t.string,\n  prfSalt: t.string,\n  entries: t.array(PasskeyEntryCodec),\n});\n\nconst RegisterSafePasskeyResponseCodec = t.type({\n  otpDeviceId: t.string,\n  updatedKeys: t.array(t.string),\n});\n\nfunction rootIdFromSafe(safe: SafeData, slot: RootKeyType, position: 0 | 1 | 2): string | undefined {\n  const triplet = safe.rootKeys?.hot?.[slot];\n  if (!triplet || triplet.length !== 3) {\n    return undefined;\n  }\n  const rootId = triplet[position];\n  return rootId.length > 0 ? rootId : undefined;\n}\n\n/**\n * @experimental\n */\nexport class Safe implements ISafe {\n  private readonly bitgo: BitGoBase;\n  public readonly _safe: SafeData;\n\n  constructor(bitgo: BitGoBase, safeData: SafeData) {\n    this.bitgo = bitgo;\n    this._safe = safeData;\n  }\n\n  id(): string {\n    return this._safe.id;\n  }\n\n  enterpriseId(): string {\n    return this._safe.enterpriseId;\n  }\n\n  label(): string {\n    return this._safe.label;\n  }\n\n  status(): SafeData['status'] {\n    return this._safe.status;\n  }\n\n  /**\n   * Enterprise-scoped v2 URL for this safe, e.g. /api/v2/enterprise/:eId/safes/:safeId\n   * @param extra\n   */\n  url(extra = ''): string {\n    return this.bitgo.url(`/enterprise/${this.enterpriseId()}/safes/${this.id()}${extra}`, 2);\n  }\n\n  /**\n   * Mint a child wallet: peek the sequential index, derive the child keys, register\n   * them, then mint.\n   *\n   * `onchain`: hardened-derive the user child (`m/<index>'`), register it\n   * public-only; backup and BitGo children are soft-derived on the server.\n   *\n   * `tss`: decrypt the user root blob, run the user/BitGo hard-derive ceremony,\n   * register the ordered child documents, then mint.\n   */\n  async createWallet(params: CreateSafeWalletOptions): Promise<Wallet> {\n    if (params.passphrase.length === 0) {\n      throw new Error('passphrase is required to mint a safe wallet');\n    }\n    if (params.type !== undefined && params.type !== 'hot') {\n      throw new Error('Safe wallets are hot-only in v1');\n    }\n    const multisigType = params.multisigType ?? 'onchain';\n    const isTss = multisigType === 'tss';\n\n    const coin = this.bitgo.coin(params.coin);\n    const slot = isTss ? tssSlotForCoin(coin.getChain()) : onchainSlotForCoin(coin.getChain());\n\n    const indexResponse = await this.bitgo.get(this.url('/derivation-index')).query({ slot }).result();\n    const peeked = decodeWithCodec(GetDerivationIndexResponse, indexResponse, 'GetDerivationIndexResponse');\n    if (peeked.slot !== slot) {\n      throw new Error(`derivation-index returned slot '${peeked.slot}', expected '${slot}'`);\n    }\n    const { index } = peeked;\n\n    const safeData = rootIdFromSafe(this._safe, slot, 0) !== undefined ? this._safe : await this.fetchSafeData();\n    const userRootId = rootIdFromSafe(safeData, slot, 0);\n    if (userRootId === undefined) {\n      throw new Error(`Safe ${this.id()} is missing rootKeys.hot.${slot}`);\n    }\n\n    if (isTss) {\n      const backupRootId = rootIdFromSafe(safeData, slot, 1);\n      const bitgoRootId = rootIdFromSafe(safeData, slot, 2);\n      if (backupRootId === undefined) {\n        throw new Error(`Safe ${this.id()} is missing rootKeys.hot.${slot} backup key`);\n      }\n      if (bitgoRootId === undefined) {\n        throw new Error(`Safe ${this.id()} is missing rootKeys.hot.${slot} bitgo key`);\n      }\n      return this.createTssWalletInSafe(coin, slot, userRootId, backupRootId, bitgoRootId, index, params);\n    }\n\n    const keychains = coin.keychains();\n    const rootKeychain = await keychains.get({ id: userRootId });\n    if (rootKeychain.source !== 'user') {\n      throw new InvalidRootKeychainSourceError(rootKeychain.id, rootKeychain.source);\n    }\n    const rootPrv = await decryptKeychainPrivateKey(this.bitgo, rootKeychain, params.passphrase);\n    if (!rootPrv) {\n      throw new IncorrectPasswordError();\n    }\n\n    const derived =\n      slot === 'ed25519Multisig'\n        ? deriveSafeChildEd25519Hardened(rootPrv, index)\n        : deriveAndSelfCheckSafeChildHardened(rootPrv, index);\n    const derivedFromParentWithHardenedPath = decodeWithCodec(\n      DerivedFromParentWithHardenedPath,\n      derived.derivationPath,\n      'derivedFromParentWithHardenedPath'\n    );\n\n    const child = await keychains.add({\n      pub: derived.pub,\n      source: 'user',\n      keyType: 'independent',\n      parent: userRootId,\n      safeId: this.id(),\n      derivedFromParentWithPath: derivedFromParentWithHardenedPath,\n    });\n    const childId = child.id;\n    if (childId.length === 0) {\n      throw new Error('safe child key registration returned an empty id');\n    }\n    const keys: [string] = [childId];\n\n    const response = await postWithCodec(this.bitgo, this.url('/wallets'), CreateWalletInSafeBody, {\n      coin: params.coin,\n      label: params.label,\n      type: 'hot',\n      multisigType,\n      keys,\n    }).result();\n    return new Wallet(this.bitgo, coin, response);\n  }\n\n  /**\n   * TSS wallet mint: decrypt the user root blob, run the user/BitGo hard-derive\n   * ceremony, register the ordered child documents, then mint.\n   */\n  private async createTssWalletInSafe(\n    coin: IBaseCoin,\n    slot: RootKeyType,\n    userRootId: string,\n    backupRootId: string,\n    bitgoRootId: string,\n    index: number,\n    params: CreateSafeWalletOptions\n  ): Promise<Wallet> {\n    if (slot !== 'ecdsaMpc' && slot !== 'eddsaMpc') {\n      throw new Error(`Expected an MPC safe root slot, got '${slot}'`);\n    }\n\n    const keychains = coin.keychains();\n    const userRootKeychain = await keychains.get({ id: userRootId });\n    if (userRootKeychain.source !== 'user') {\n      throw new InvalidRootKeychainSourceError(userRootKeychain.id, userRootKeychain.source);\n    }\n\n    const userRootPrv = await decryptKeychainPrivateKey(this.bitgo, userRootKeychain, params.passphrase);\n    if (!userRootPrv) {\n      throw new IncorrectPasswordError();\n    }\n    const userRootMaterial = parseSafeMpcKeyEnvelopes(userRootPrv);\n\n    const tssUtils =\n      slot === 'eddsaMpc'\n        ? new EDDSAUtils.EddsaVrfMPCv2Utils(this.bitgo, coin)\n        : new ECDSAUtils.EcdsaVrfMPCv2Utils(this.bitgo, coin);\n    const { userKeychain, backupKeychain, bitgoKeychain } = await tssUtils.createSafeChildKeychains({\n      passphrase: params.passphrase,\n      enterprise: this.enterpriseId(),\n      safeId: this.id(),\n      parentKeyId: bitgoRootId,\n      derivationIndex: index,\n      userRootKeyId: userRootId,\n      backupRootKeyId: backupRootId,\n      userRootKeyShare: userRootMaterial.signing,\n      userRootVrfKeyShare: userRootMaterial.vrf,\n    });\n    if (userKeychain.id.length === 0 || backupKeychain.id.length === 0 || bitgoKeychain.id.length === 0) {\n      throw new Error('safe child key registration returned an empty id');\n    }\n    const keys: [string, string, string] = [userKeychain.id, backupKeychain.id, bitgoKeychain.id];\n\n    const response = await postWithCodec(this.bitgo, this.url('/wallets'), CreateWalletInSafeBody, {\n      coin: params.coin,\n      label: params.label,\n      type: 'hot',\n      multisigType: 'tss',\n      keys,\n    }).result();\n    return new Wallet(this.bitgo, coin, response);\n  }\n\n  private async fetchSafeData(): Promise<SafeData> {\n    const response = await this.bitgo.get(this.url()).result();\n    return decodeWithCodec(SafeData, response, 'SafeData');\n  }\n\n  /**\n   * Add a member to the whole safe (view/admin/spend). Spend opens a key share.\n   */\n  async addMember(params: AddSafeMemberOptions): Promise<SafeData> {\n    throw new Error('Safe.addMember is not yet implemented');\n  }\n\n  /**\n   * Share ONE safe wallet with a non-member via the existing wallet-share handshake.\n   */\n  async addMemberToWallet(params: AddSafeWalletMemberOptions): Promise<WalletShareData> {\n    throw new Error('Safe.addMemberToWallet is not yet implemented');\n  }\n\n  /**\n   * List the safe key shares visible to the caller.\n   */\n  async listShares(params: { state?: SafeShareState } = {}): Promise<SafeShareData[]> {\n    throw new Error('Safe.listShares is not yet implemented');\n  }\n\n  /**\n   * Accept a safe key share addressed to the caller.\n   */\n  async acceptShare(params: AcceptSafeShareOptions): Promise<SafeShareData> {\n    throw new Error('Safe.acceptShare is not yet implemented');\n  }\n\n  /**\n   * Update the safe label.\n   */\n  async update(params: UpdateSafeOptions): Promise<SafeData> {\n    const response = await this.bitgo.put(this.url()).send({ label: params.label }).result();\n    return decodeWithCodec(SafeData, response, 'SafeData');\n  }\n\n  /**\n   * Freeze the safe — blocks withdrawals on all safe wallets. Safe stays 'active'.\n   * @param params\n   */\n  async freeze(params: FreezeSafeBody = {}): Promise<SafeData> {\n    const response = await postWithCodec(this.bitgo, this.url('/freeze'), FreezeSafeBody, params).result();\n    return decodeWithCodec(SafeData, response, 'SafeData');\n  }\n\n  /**\n   * Archive the safe. Requires every safe wallet to already be archived; also the abandonment\n   * path for a stuck 'initializing' safe.\n   */\n  async archive(): Promise<SafeData> {\n    const response = await this.bitgo.post(this.url('/archive')).send().result();\n    return decodeWithCodec(SafeData, response, 'SafeData');\n  }\n\n  /**\n   * Register a PRF passkey on every user root of the safe.\n   *\n   * For each user root (position 0 of each populated slot), decrypt the root with the Safe\n   * password, then re-encrypt it under the PRF-derived password (bound to the enterprise via\n   * AES-GCM AAD). One PRF assertion serves the whole safe; the write set is the user roots only\n   * — backup and BitGo roots are never wrapped.\n   */\n  async registerPasskey(params: RegisterSafePasskeyOptions): Promise<RegisterSafePasskeyResponse> {\n    const { device, safePassphrase, provider, encryptionVersion } = params;\n\n    if (!device.id) {\n      throw new Error('device.id is required to register a passkey on the safe');\n    }\n    if (!device.prfSalt) {\n      throw new Error('PRF extension not supported by this device. Please use a different passkey.');\n    }\n    const enterpriseId = this.enterpriseId();\n    const prfSalt = deriveEnterpriseSalt(device.prfSalt, enterpriseId);\n\n    const entries: { keyId: string; encryptedPrv: string }[] = [];\n    for (const slot of SAFE_ROOT_SLOTS) {\n      const userRootId = rootIdFromSafe(this._safe, slot, 0);\n      if (userRootId === undefined) {\n        continue;\n      }\n      const keychain = await coinForRoot(this.bitgo, slot).keychains().get({ id: userRootId });\n      if (keychain.source !== 'user') {\n        throw new InvalidRootKeychainSourceError(keychain.id, keychain.source);\n      }\n      const rootPrv = await decryptKeychainPrivateKey(this.bitgo, keychain, safePassphrase);\n      if (!rootPrv) {\n        throw new IncorrectPasswordError();\n      }\n      entries.push({ keyId: userRootId, encryptedPrv: rootPrv });\n    }\n\n    if (entries.length === 0) {\n      throw new Error(`Safe ${this.id()} has no user roots to attach a passkey to`);\n    }\n\n    const nodeBuf = base64UrlToBuffer(device.credentialId);\n    const credentialIdBuffer = nodeBuf.buffer.slice(nodeBuf.byteOffset, nodeBuf.byteOffset + nodeBuf.byteLength);\n    const authResult = await provider.get({\n      publicKey: {\n        allowCredentials: [{ type: 'public-key', id: credentialIdBuffer }],\n      } as PublicKeyCredentialRequestOptions,\n      evalByCredential: { [device.credentialId]: prfSalt },\n    });\n    if (!authResult.prfResult) {\n      throw new Error('PRF assertion did not return a result.');\n    }\n    if (toBase64Url(authResult.credentialId) !== toBase64Url(device.credentialId)) {\n      throw new Error('PRF assertion returned an unexpected credential.');\n    }\n    const prfPassword = derivePassword(authResult.prfResult);\n\n    const wrappedEntries = await Promise.all(\n      entries.map(async ({ keyId, encryptedPrv }) => ({\n        keyId,\n        encryptedPrv: await this.bitgo.encrypt({\n          password: prfPassword,\n          input: encryptedPrv,\n          encryptionVersion,\n          adata: enterpriseId,\n        }),\n      }))\n    );\n\n    const response = await postWithCodec(this.bitgo, this.url('/passkeys'), RegisterSafePasskeyBody, {\n      otpDeviceId: device.id,\n      prfSalt,\n      entries: wrappedEntries,\n    }).result();\n    return decodeWithCodec(RegisterSafePasskeyResponseCodec, response, 'RegisterSafePasskeyResponse');\n  }\n\n  /**\n   * Remove a PRF passkey from every user root of the safe.\n   *\n   * The Safe password is verified client-side (decrypt one user root) before the server is\n   * called; the server enforces owner authorization and performs the idempotent per-root `$pull`.\n   */\n  async removePasskey(params: RemoveSafePasskeyOptions): Promise<void> {\n    const { device, safePassphrase } = params;\n    if (!device.id) {\n      throw new Error('device.id is required to remove a passkey from the safe');\n    }\n\n    const userRoots = SAFE_ROOT_SLOTS.flatMap((slot) => {\n      const userRootId = rootIdFromSafe(this._safe, slot, 0);\n      return userRootId === undefined ? [] : [{ slot, userRootId }];\n    });\n    if (userRoots.length === 0) {\n      throw new Error(`Safe ${this.id()} has no user roots to remove a passkey from`);\n    }\n\n    let verified = false;\n    for (const { slot, userRootId } of userRoots) {\n      const keychain = await coinForRoot(this.bitgo, slot).keychains().get({ id: userRootId });\n      const decrypted = await decryptKeychainPrivateKey(this.bitgo, keychain, safePassphrase);\n      if (decrypted) {\n        verified = true;\n        break;\n      }\n    }\n    if (!verified) {\n      throw new IncorrectPasswordError();\n    }\n\n    await this.bitgo.del(this.url(`/passkeys/${device.id}`)).result();\n  }\n\n  toJSON(): SafeData {\n    return this._safe;\n  }\n}\n"]}