@bopen-io/wallet-toolbox 2.15.0-bopen.2 → 2.15.1

package/out/src/CWIStyleWalletManager.js

@@ -24,6 +24,18 @@ exports.ARGON2ID_MAX_PARALLELISM = 16;
 exports.KDF_MAX_HASH_LENGTH = 64;
 exports.PBKDF2_MAX_ITERATIONS = 10_000_000;
 exports.MAX_STATE_SNAPSHOT_BYTES = 16 * 1024 * 1024;
+const MAX_PENDING_REGISTRATION_TOKEN_BYTES = 64 * 1024;
+function readSerializedOutpoint(reader, allowUnpublished) {
+    const outpointLen = reader.readVarIntNumStrict(false);
+    const currentOutpoint = (0, utils_1.toUTF8)(reader.read(outpointLen));
+    if ((currentOutpoint.length === 0 && !allowUnpublished) ||
+        currentOutpoint.length > 128 ||
+        (currentOutpoint.length > 0 && !/^[^\s.:]+[.:]\d+$/.test(currentOutpoint)) ||
+        (allowUnpublished && !reader.eof())) {
+        throw new Error('Serialized UMP token contains an invalid outpoint.');
+    }
+    return currentOutpoint;
+}
 function isPositiveIntegerInRange(value, maximum) {
     return typeof value === 'number' && Number.isInteger(value) && value > 0 && value <= maximum;
 }
@@ -355,14 +367,15 @@ class OverlayUMPTokenInteractor {
         // spent by another candidate's transaction history. Only unrelated (forked)
         // tokens remain indeterminate.
         if (matchingTokens.length > 1) {
-            const newest = this.resolveNewestToken(matchingTokens, resolution.answer.outputs);
+            const pinnedLineage = await this.findPinnedLineage(matchingTokens, resolution.answer.outputs, options?.pinnedOutpoint);
+            const newest = this.resolveNewestToken(pinnedLineage ?? matchingTokens, resolution.answer.outputs);
             if (newest != null) {
                 this.lookupDone(lookupKind, 'found', diagnostics, startedAt, {
                     supersededTokens: matchingTokens.length - 1
                 });
                 return newest;
             }
-            const pinned = options?.pinnedOutpoint
+            const pinned = pinnedLineage == null && options?.pinnedOutpoint
                 ? matchingTokens.find(token => token.currentOutpoint === options.pinnedOutpoint)
                 : undefined;
             if (pinned != null) {
@@ -388,6 +401,162 @@ class OverlayUMPTokenInteractor {
         this.lookupFailed(lookupKind, reason, diagnostics, startedAt);
         throw new UMPTokenLookupError(reason, diagnostics);
     }
+    /** Keep a verified pin and its proven descendants together, excluding unrelated forks. */
+    async findPinnedLineage(tokens, outputs, pinnedOutpoint) {
+        if (pinnedOutpoint == null)
+            return undefined;
+        const candidates = new Map(tokens.map(token => [token.currentOutpoint, token]));
+        const pinSource = candidates.has(pinnedOutpoint) ? this.findLookupTransaction(outputs, pinnedOutpoint) : undefined;
+        const relationships = await Promise.all(outputs.map(output => this.pinRelationship(output, candidates, pinnedOutpoint, pinSource)));
+        const related = new Set();
+        let anchorSeen = false;
+        for (const relationship of relationships) {
+            if (relationship == null)
+                continue;
+            anchorSeen = true;
+            if (relationship.selected)
+                related.add(relationship.outpoint);
+        }
+        return anchorSeen ? tokens.filter(token => related.has(token.currentOutpoint)) : undefined;
+    }
+    async pinRelationship(output, candidates, pin, pinSource) {
+        try {
+            const tx = this.readTokenHistory(output.beef);
+            const outpoint = `${tx.id('hex')}.${output.outputIndex}`;
+            if (!candidates.has(outpoint))
+                return undefined;
+            if (outpoint === pin)
+                return { outpoint, selected: true };
+            const descent = this.descendsFromPin(tx, pin, pinSource);
+            if (descent == null)
+                return undefined;
+            return { outpoint, selected: descent === 'verified' && (await this.hasCompleteUpdateEvidence(tx)) };
+        }
+        catch {
+            // A malformed copy cannot establish an anchor or hide a deeper copy.
+            return undefined;
+        }
+    }
+    /** Preserve unmined funding-ancestry checks without adding a network dependency. */
+    async hasCompleteUpdateEvidence(tx) {
+        try {
+            return await tx.verify('scripts only');
+        }
+        catch {
+            // An input reference alone does not establish a usable token update.
+            return false;
+        }
+    }
+    descendsFromPin(tx, pin, pinSource) {
+        const pending = [tx];
+        const visited = new Set();
+        let incomplete = false;
+        while (pending.length > 0) {
+            const current = pending.pop();
+            const txid = current.id('hex');
+            if (visited.has(txid))
+                continue;
+            visited.add(txid);
+            for (const [inputIndex] of current.inputs.entries()) {
+                const step = this.pinInputDescent(current, inputIndex, pin, pinSource);
+                if (step.descent === 'verified')
+                    return step.descent;
+                incomplete = incomplete || step.descent === 'incomplete';
+                if (step.predecessor != null)
+                    pending.push(step.predecessor);
+            }
+        }
+        return incomplete ? 'incomplete' : undefined;
+    }
+    pinInputDescent(tx, inputIndex, pin, pinSource) {
+        const input = tx.inputs[inputIndex];
+        const sourceTxid = input.sourceTXID ?? input.sourceTransaction?.id('hex');
+        const isPin = sourceTxid != null && `${sourceTxid}.${input.sourceOutputIndex}` === pin;
+        const source = input.sourceTransaction ?? (isPin ? pinSource : undefined);
+        const refused = { descent: isPin ? 'incomplete' : undefined };
+        if (source == null || !this.isAuthenticatedUMPOutput(source.outputs[input.sourceOutputIndex]))
+            return refused;
+        if (!this.verifyUMPSpend(tx, inputIndex, source))
+            return refused;
+        return isPin ? { descent: 'verified' } : { predecessor: source };
+    }
+    isAuthenticatedUMPOutput(output) {
+        if (output?.satoshis !== 1)
+            return false;
+        try {
+            const { fields } = decodeAuthenticatedUMPFields(output.lockingScript);
+            return (fields.length >= 11 &&
+                fields[6]?.length === 32 &&
+                fields[7]?.length === 32 &&
+                fields.slice(0, 11).every(field => field.length > 0 && field.length <= exports.MAX_STATE_SNAPSHOT_BYTES));
+        }
+        catch {
+            // A funding input or unauthenticated predecessor is not a UMP anchor.
+            return false;
+        }
+    }
+    /** Check token-control continuity at every edge, including confirmed transactions. */
+    verifyUMPSpend(tx, inputIndex, source) {
+        try {
+            const input = tx.inputs[inputIndex];
+            const sourceTxid = source.id('hex');
+            if (input.unlockingScript == null || (input.sourceTXID != null && input.sourceTXID !== sourceTxid))
+                return false;
+            const output = source.outputs[input.sourceOutputIndex];
+            return new sdk_1.Spend({
+                sourceTXID: sourceTxid,
+                sourceOutputIndex: input.sourceOutputIndex,
+                sourceSatoshis: output.satoshis ?? 0,
+                lockingScript: output.lockingScript,
+                transactionVersion: tx.version,
+                otherInputs: tx.inputs.filter((_, index) => index !== inputIndex),
+                unlockingScript: input.unlockingScript,
+                inputSequence: input.sequence ?? 0xffffffff,
+                inputIndex,
+                outputs: tx.outputs,
+                lockTime: tx.lockTime
+            }).validate();
+        }
+        catch {
+            return false;
+        }
+    }
+    findLookupTransaction(outputs, outpoint) {
+        for (const output of outputs) {
+            try {
+                const tx = this.readTokenHistory(output.beef);
+                if (`${tx.id('hex')}.${output.outputIndex}` === outpoint)
+                    return tx;
+            }
+            catch {
+                // A malformed copy does not hide another host's usable anchor.
+            }
+        }
+        return undefined;
+    }
+    /** Link explicit overlay history even when an ancestor already has a Merkle proof. */
+    readTokenHistory(bytes) {
+        const tx = sdk_1.Transaction.fromBEEF(bytes);
+        const beef = sdk_1.Beef.fromBinary(bytes);
+        const pending = [tx];
+        const visited = new Set();
+        while (pending.length > 0) {
+            const current = pending.pop();
+            const txid = current.id('hex');
+            if (visited.has(txid))
+                continue;
+            visited.add(txid);
+            for (const input of current.inputs) {
+                const sourceTxid = input.sourceTXID ?? input.sourceTransaction?.id('hex');
+                if (input.sourceTransaction == null && sourceTxid != null) {
+                    input.sourceTransaction = beef.findAtomicTransaction(sourceTxid);
+                }
+                if (input.sourceTransaction != null)
+                    pending.push(input.sourceTransaction);
+            }
+        }
+        return tx;
+    }
     /**
      * Picks the newest rendition among distinct verified tokens, when possible.
      *
@@ -413,7 +582,7 @@ class OverlayUMPTokenInteractor {
         const evidenceByCandidate = new Map();
         for (const output of outputs) {
             try {
-                const tx = sdk_1.Transaction.fromBEEF(output.beef);
+                const tx = this.readTokenHistory(output.beef);
                 const outpoint = `${tx.id('hex')}.${output.outputIndex}`;
                 if (!candidates.has(outpoint))
                     continue;
@@ -916,6 +1085,8 @@ class CWIStyleWalletManager {
      * Optional function to fund a new Wallet after the new-user flow.
      */
     newWalletFunder;
+    /** Persists only encrypted UMP fields before an irreversible funding attempt. */
+    pendingRegistrationTokenSaver;
     /**
      * Builds the underlying wallet for a specific profile.
      */
@@ -932,6 +1103,8 @@ class CWIStyleWalletManager {
      * The current UMP token in use.
      */
     currentUMPToken;
+    /** Unpublished token retained through an interrupted new-user registration. */
+    pendingRegistrationToken;
     /**
      * Temporarily retained presentation key.
      */
@@ -952,6 +1125,7 @@ class CWIStyleWalletManager {
      * List of loaded non-default profiles.
      */
     profiles = [];
+    pendingProfileNames = new Set();
     /**
      * The underlying wallet instance for the *active* profile.
      */
@@ -975,8 +1149,9 @@ class CWIStyleWalletManager {
      * @param newWalletFunder   Optional function to fund a new wallet.
      * @param stateSnapshot     Optional previously saved state snapshot.
      * @param kdfConfig         Optional KDF configuration for new UMP tokens.
+     * @param pendingRegistrationTokenSaver Optional durable store for an unpublished UMP token.
      */
-    constructor(...[adminOriginator, walletBuilder, interactor, recoveryKeySaver, passwordRetriever, newWalletFunder, stateSnapshot, kdfConfig, telemetry]) {
+    constructor(...[adminOriginator, walletBuilder, interactor, recoveryKeySaver, passwordRetriever, newWalletFunder, stateSnapshot, kdfConfig, telemetry, pendingRegistrationTokenSaver]) {
         this.adminOriginator = adminOriginator;
         this.walletBuilder = walletBuilder;
         this.telemetry = new sdk_1.Telemetry(telemetry);
@@ -985,6 +1160,7 @@ class CWIStyleWalletManager {
         this.passwordRetriever = passwordRetriever;
         this.authenticated = false;
         this.newWalletFunder = newWalletFunder;
+        this.pendingRegistrationTokenSaver = pendingRegistrationTokenSaver;
         // Initialize KDF config with Argon2id defaults for v3 tokens
         const kdfAlgorithm = kdfConfig?.algorithm ?? 'argon2id';
         this.kdfConfig = {
@@ -1027,6 +1203,40 @@ class CWIStyleWalletManager {
         }
     }
     // --- Authentication Methods ---
+    /**
+     * Restores an unpublished UMP token before authentication. The token contains
+     * an encrypted wallet root, but no plaintext root, snapshot key, or on-chain outpoint.
+     */
+    loadPendingRegistrationToken(bytes) {
+        if (this.authenticated || this.authenticationFlow !== 'unknown' || this.currentUMPToken != null) {
+            throw new Error('Pending registration token must be loaded before authentication.');
+        }
+        if (!Array.isArray(bytes) ||
+            bytes.length === 0 ||
+            bytes.length > MAX_PENDING_REGISTRATION_TOKEN_BYTES ||
+            bytes.some(byte => !Number.isInteger(byte) || byte < 0 || byte > 255)) {
+            throw new Error('Pending registration token is invalid.');
+        }
+        try {
+            const token = this.deserializeUMPToken(bytes, true);
+            if (token.currentOutpoint != null ||
+                token.umpVersion !== 3 ||
+                !isValidKdfConfig(token.passwordKdf) ||
+                token.profilesEncrypted != null ||
+                token.passwordSalt.length !== 32 ||
+                token.presentationHash.length !== 32 ||
+                token.recoveryHash.length !== 32) {
+                throw new Error('Invalid unpublished token fields.');
+            }
+            this.pendingRegistrationToken = token;
+        }
+        catch {
+            throw new Error('Pending registration token is invalid.');
+        }
+    }
+    hasPendingRegistrationToken() {
+        return this.pendingRegistrationToken != null;
+    }
     /**
      * Provides the presentation key. A WAB operator pin may be supplied by the
      * authentication manager; normal lookup and lineage resolution always run
@@ -1044,6 +1254,7 @@ class CWIStyleWalletManager {
         }
         this.authenticationFlow = 'unknown';
         const hash = (0, Hash_1.sha256)(key);
+        const pendingTokenMatches = this.pendingRegistrationToken == null || (0, utils_1.toHex)(this.pendingRegistrationToken.presentationHash) === (0, utils_1.toHex)(hash);
         const startedAt = Date.now();
         this.telemetry.capture({
             name: 'wallet-toolbox.authentication.account-lookup.started',
@@ -1070,14 +1281,19 @@ class CWIStyleWalletManager {
         }
         if (token == null) {
             // No token found -> New user
+            if (!pendingTokenMatches) {
+                throw new Error('Pending registration token belongs to another presentation key.');
+            }
             this.authenticationFlow = 'new-user';
             this.presentationKey = key;
+            this.currentUMPToken = this.pendingRegistrationToken;
         }
         else {
             // Found token -> existing user
             this.authenticationFlow = 'existing-user';
             this.presentationKey = key;
             this.currentUMPToken = token;
+            this.clearPublishedPendingRegistration(token);
         }
         this.telemetry.capture({
             name: 'wallet-toolbox.authentication.account-lookup.completed',
@@ -1139,6 +1355,62 @@ class CWIStyleWalletManager {
         }
         if (this.presentationKey == null)
             throw new Error('No presentation key provided for new-user flow.');
+        let newToken;
+        let rootPrimaryKey;
+        if (this.pendingRegistrationToken != null) {
+            newToken = this.pendingRegistrationToken;
+            rootPrimaryKey = await this.unlockPendingRegistrationToken(newToken, this.presentationKey, password);
+        }
+        else {
+            const generated = await this.buildPendingRegistrationToken(password, this.presentationKey);
+            newToken = generated.token;
+            rootPrimaryKey = generated.rootPrimaryKey;
+            this.pendingRegistrationToken = newToken;
+        }
+        this.currentUMPToken = newToken;
+        // The caller must durably store the same encrypted token before a faucet
+        // output can be redeemed. Repeating the write also repairs a prior failed
+        // persistence attempt before any retry reaches the funder.
+        if (this.pendingRegistrationTokenSaver != null) {
+            await this.pendingRegistrationTokenSaver(this.serializeUMPToken(newToken, true));
+        }
+        await this.setupRoot(rootPrimaryKey, undefined, false);
+        await this.activateProfile(exports.DEFAULT_PROFILE_ID);
+        // Fund the *default* wallet if funder provided
+        if (this.newWalletFunder != null && this.underlying != null) {
+            try {
+                await this.newWalletFunder(this.presentationKey, this.underlying, this.adminOriginator);
+            }
+            catch (error) {
+                this.telemetry.capture({
+                    name: 'wallet-toolbox.authentication.new-wallet-funding.failed',
+                    component: CWI_COMPONENT,
+                    severity: 'error',
+                    error: new Error('New wallet funding failed.')
+                });
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to fund new wallet before publishing UMP token: ${message}`, { cause: error });
+            }
+        }
+        if (this.underlying == null)
+            throw new Error('Default profile wallet not built before attempting to publish UMP token.');
+        newToken.currentOutpoint = await this.UMPTokenInteractor.buildAndSend(this.underlying, this.adminOriginator, newToken);
+        this.pendingRegistrationToken = undefined;
+        this.authenticated = true;
+    }
+    async unlockPendingRegistrationToken(token, presentationKey, password) {
+        try {
+            const passwordKey = await derivePasswordKey(token, (0, utils_1.toArray)(password, 'utf8'));
+            const rootPrimaryKey = new sdk_1.SymmetricKey(this.XOR(presentationKey, passwordKey)).decrypt(token.passwordPresentationPrimary);
+            if (rootPrimaryKey.length !== 32)
+                throw new Error('Invalid root key length.');
+            return rootPrimaryKey;
+        }
+        catch {
+            throw new Error('Pending registration token could not be unlocked with this password.');
+        }
+    }
+    async buildPendingRegistrationToken(password, presentationKey) {
         // Generate new keys/salt
         const recoveryKey = (0, sdk_1.Random)(32);
         await this.recoveryKeySaver(recoveryKey);
@@ -1147,52 +1419,31 @@ class CWIStyleWalletManager {
         const rootPrimaryKey = (0, sdk_1.Random)(32);
         const rootPrivilegedKey = (0, sdk_1.Random)(32);
         // Build XOR-combined symmetric keys
-        const presentationPassword = new sdk_1.SymmetricKey(this.XOR(this.presentationKey, passwordKey));
-        const presentationRecovery = new sdk_1.SymmetricKey(this.XOR(this.presentationKey, recoveryKey));
+        const presentationPassword = new sdk_1.SymmetricKey(this.XOR(presentationKey, passwordKey));
+        const presentationRecovery = new sdk_1.SymmetricKey(this.XOR(presentationKey, recoveryKey));
         const recoveryPassword = new sdk_1.SymmetricKey(this.XOR(recoveryKey, passwordKey));
         const primaryPassword = new sdk_1.SymmetricKey(this.XOR(rootPrimaryKey, passwordKey));
         const tempPrivilegedKeyManager = new PrivilegedKeyManager_1.PrivilegedKeyManager(async () => new sdk_1.PrivateKey(rootPrivilegedKey));
         const wrapKey = async (plaintext) => (await tempPrivilegedKeyManager.encrypt({ plaintext, protocolID: [2, 'admin key wrapping'], keyID: '1' }))
             .ciphertext;
         // Build new UMP token (v3 with KDF metadata, no profiles initially)
-        const newToken = {
+        const token = {
             passwordSalt,
             passwordPresentationPrimary: presentationPassword.encrypt(rootPrimaryKey),
             passwordRecoveryPrimary: recoveryPassword.encrypt(rootPrimaryKey),
             presentationRecoveryPrimary: presentationRecovery.encrypt(rootPrimaryKey),
             passwordPrimaryPrivileged: primaryPassword.encrypt(rootPrivilegedKey),
             presentationRecoveryPrivileged: presentationRecovery.encrypt(rootPrivilegedKey),
-            presentationHash: (0, Hash_1.sha256)(this.presentationKey),
+            presentationHash: (0, Hash_1.sha256)(presentationKey),
             recoveryHash: (0, Hash_1.sha256)(recoveryKey),
-            presentationKeyEncrypted: await wrapKey(this.presentationKey),
+            presentationKeyEncrypted: await wrapKey(presentationKey),
             passwordKeyEncrypted: await wrapKey(passwordKey),
             recoveryKeyEncrypted: await wrapKey(recoveryKey),
             profilesEncrypted: undefined,
             umpVersion: 3,
             passwordKdf: this.kdfConfig
         };
-        this.currentUMPToken = newToken;
-        await this.setupRoot(rootPrimaryKey);
-        await this.switchProfile(exports.DEFAULT_PROFILE_ID);
-        // Fund the *default* wallet if funder provided
-        if (this.newWalletFunder != null && this.underlying != null) {
-            try {
-                await this.newWalletFunder(this.presentationKey, this.underlying, this.adminOriginator);
-            }
-            catch (error) {
-                this.telemetry.capture({
-                    name: 'wallet-toolbox.authentication.new-wallet-funding.failed',
-                    component: CWI_COMPONENT,
-                    severity: 'error',
-                    error: new Error('New wallet funding failed.')
-                });
-                const message = error instanceof Error ? error.message : String(error);
-                throw new Error(`Failed to fund new wallet before publishing UMP token: ${message}`, { cause: error });
-            }
-        }
-        if (this.underlying == null)
-            throw new Error('Default profile wallet not built before attempting to publish UMP token.');
-        this.currentUMPToken.currentOutpoint = await this.UMPTokenInteractor.buildAndSend(this.underlying, this.adminOriginator, newToken);
+        return { token, rootPrimaryKey };
     }
     /**
      * Provides the recovery key.
@@ -1325,6 +1576,7 @@ class CWIStyleWalletManager {
             // Setup root infrastructure, load profiles, and switch to the loaded active profile
             await this.setupRoot(rootPrimaryKey); // Will automatically load profiles
             await this.switchProfile(activeProfileId); // Switch to the profile saved in the snapshot
+            this.clearPublishedPendingRegistration(token);
             this.authenticationFlow = 'existing-user'; // Loading implies existing user
             this.telemetry.capture({
                 name: 'wallet-toolbox.snapshot.loaded',
@@ -1373,6 +1625,15 @@ class CWIStyleWalletManager {
         this.saveSnapshot();
         return true;
     }
+    clearPublishedPendingRegistration(token) {
+        // A conflicting wallet root can share the same presentation key; match the
+        // encrypted root field before discarding the unpublished token.
+        if (this.pendingRegistrationToken != null &&
+            (0, utils_1.toHex)(this.pendingRegistrationToken.presentationHash) === (0, utils_1.toHex)(token.presentationHash) &&
+            (0, utils_1.toHex)(this.pendingRegistrationToken.passwordPresentationPrimary) === (0, utils_1.toHex)(token.passwordPresentationPrimary)) {
+            this.pendingRegistrationToken = undefined;
+        }
+    }
     /**
      * Destroys the wallet state, clearing keys, tokens, and profiles.
      */
@@ -1382,6 +1643,7 @@ class CWIStyleWalletManager {
         this.authenticated = false;
         this.rootPrimaryKey = undefined;
         this.currentUMPToken = undefined;
+        this.pendingRegistrationToken = undefined;
         this.presentationKey = undefined;
         this.recoveryKey = undefined;
         this.profiles = [];
@@ -1434,7 +1696,10 @@ class CWIStyleWalletManager {
             throw new Error('Wallet not fully initialized or authenticated.');
         }
         // Ensure name is unique (including 'default')
-        if (name === 'default' || this.profiles.some(p => p.name.toLowerCase() === name.toLowerCase())) {
+        const normalizedName = name.toLowerCase();
+        if (name === 'default' ||
+            this.pendingProfileNames.has(normalizedName) ||
+            this.profiles.some(p => p.name.toLowerCase() === normalizedName)) {
             throw new Error(`Profile name "${name}" is already in use.`);
         }
         const newProfile = {
@@ -1444,14 +1709,26 @@ class CWIStyleWalletManager {
             privilegedPad: (0, sdk_1.Random)(32),
             createdAt: Math.floor(Date.now() / 1000)
         };
-        this.profiles.push(newProfile);
-        // Update the UMP token with the new profile list
-        await this.updateFactors(this.currentUMPToken.passwordSalt, 
-        // Need to re-derive/decrypt factors needed for re-encryption
-        await this.getFactor('passwordKey'), await this.getFactor('presentationKey'), await this.getFactor('recoveryKey'), this.rootPrimaryKey, await this.getFactor('privilegedKey'), // Get ROOT privileged key
-        this.profiles // Pass the updated profile list
-        );
-        return newProfile.id;
+        // Reserve the case-insensitive name before the first await. The profile
+        // itself remains unpublished until updateFactors accepts the new token.
+        this.pendingProfileNames.add(normalizedName);
+        try {
+            // Only keep the new profile once the UMP token holds it, so a failed update
+            // leaves the list as it was and a retry is not rejected as a duplicate.
+            // Update the UMP token with the new profile list
+            await this.updateFactors(this.currentUMPToken.passwordSalt, 
+            // Need to re-derive/decrypt factors needed for re-encryption
+            await this.getFactor('passwordKey'), await this.getFactor('presentationKey'), await this.getFactor('recoveryKey'), this.rootPrimaryKey, await this.getFactor('privilegedKey'), // Get ROOT privileged key
+            // Built last, after the awaits above: arguments are evaluated left to
+            // right, and updateFactors captures the token it consumes before its first
+            // await, so this list and that token are one consistent snapshot. Built
+            // earlier, a profile added by an overlapping call would be dropped.
+            [...this.profiles, newProfile]);
+            return newProfile.id;
+        }
+        finally {
+            this.pendingProfileNames.delete(normalizedName);
+        }
     }
     /**
      * Deletes a profile by its ID.
@@ -1474,16 +1751,27 @@ class CWIStyleWalletManager {
         if (profileIndex === -1) {
             throw new Error('Profile not found.');
         }
-        // Remove the profile
-        this.profiles.splice(profileIndex, 1);
+        // Remove the profile only once the UMP token no longer holds it, so a
+        // failed update leaves the profile (and the active wallet) in place.
+        const wasActive = this.activeProfileId.every((x, i) => x === profileId[i]);
         // If the deleted profile was active, switch to default
-        if (this.activeProfileId.every((x, i) => x === profileId[i])) {
+        if (wasActive) {
             await this.switchProfile(exports.DEFAULT_PROFILE_ID); // This rebuilds the wallet
         }
         // Update the UMP token
-        await this.updateFactors(this.currentUMPToken.passwordSalt, await this.getFactor('passwordKey'), await this.getFactor('presentationKey'), await this.getFactor('recoveryKey'), this.rootPrimaryKey, await this.getFactor('privilegedKey'), // Get ROOT privileged key
-        this.profiles // Pass updated list
-        );
+        try {
+            await this.updateFactors(this.currentUMPToken.passwordSalt, await this.getFactor('passwordKey'), await this.getFactor('presentationKey'), await this.getFactor('recoveryKey'), this.rootPrimaryKey, await this.getFactor('privilegedKey'), // Get ROOT privileged key
+            // Built last, after the awaits, for the same reason as in addProfile.
+            this.profiles.filter(p => !p.id.every((x, i) => x === profileId[i])));
+        }
+        catch (error) {
+            // Back to the profile we left, unless the token was published before the
+            // failure. A failed switch back must not hide the original error.
+            if (wasActive && this.profiles.some(p => p.id.every((x, i) => x === profileId[i]))) {
+                await this.switchProfile(profileId).catch(() => { });
+            }
+            throw error;
+        }
     }
     /**
      * Switches the active profile. This re-derives keys and rebuilds the underlying wallet.
@@ -1494,6 +1782,13 @@ class CWIStyleWalletManager {
         if (!this.authenticated || this.rootPrimaryKey == null || this.rootPrivilegedKeyManager == null) {
             throw new Error('Cannot switch profile: Wallet not authenticated or root keys missing.');
         }
+        await this.activateProfile(profileId);
+    }
+    /** Build an internal profile wallet while an unpublished registration is not yet authenticated. */
+    async activateProfile(profileId) {
+        if (this.rootPrimaryKey == null || this.rootPrivilegedKeyManager == null) {
+            throw new Error('Cannot activate profile: root keys are missing.');
+        }
         let profilePrimaryKey;
         let profilePrivilegedPad; // Pad for the target profile
         if (profileId.every(x => x === 0)) {
@@ -1770,7 +2065,12 @@ class CWIStyleWalletManager {
             );
             // Update the manager's state
             this.currentUMPToken = newTokenData;
-            // Profiles are already updated in this.profiles if they were passed in
+            // Keep the profiles in step with the token that now holds them. Callers
+            // pass a new list rather than changing this.profiles up front, so a
+            // failed update leaves it untouched.
+            if (profiles != null) {
+                this.profiles = profiles;
+            }
         }
         finally {
             // Switch back if we temporarily switched
@@ -1789,8 +2089,8 @@ class CWIStyleWalletManager {
      * Serializes a UMP token to binary format (Version 3 with KDF metadata, Version 2 with profiles).
      * V3 Layout: [1 byte version=3] + [11 * (varint len + bytes) for standard fields] + [1 byte profile_flag] + [IF flag=1 THEN varint len + profile bytes] + [1 byte kdf_flag] + [IF flag=1 THEN kdf metadata] + [varint len + outpoint bytes]
      */
-    serializeUMPToken(token) {
-        if (!token.currentOutpoint) {
+    serializeUMPToken(token, allowUnpublished = false) {
+        if (!token.currentOutpoint && !allowUnpublished) {
             throw new Error('Token must have outpoint for serialization');
         }
         const writer = new utils_1.Writer();
@@ -1847,7 +2147,7 @@ class CWIStyleWalletManager {
             writer.writeUInt8(0); // Flag indicating no KDF metadata
         }
         // Write outpoint string
-        const outpointBytes = (0, utils_1.toArray)(token.currentOutpoint, 'utf8');
+        const outpointBytes = (0, utils_1.toArray)(token.currentOutpoint ?? '', 'utf8');
         writer.writeVarIntNum(outpointBytes.length);
         writer.write(outpointBytes);
         return writer.toArray();
@@ -1855,7 +2155,7 @@ class CWIStyleWalletManager {
     /**
      * Deserializes a UMP token from binary format (Handles Version 1, 2, and 3).
      */
-    deserializeUMPToken(bin) {
+    deserializeUMPToken(bin, allowUnpublished = false) {
         const reader = new utils_1.Reader(bin);
         const version = reader.readUInt8();
         if (version !== 1 && version !== 2 && version !== 3) {
@@ -1913,12 +2213,7 @@ class CWIStyleWalletManager {
             }
         }
         // Read outpoint string
-        const outpointLen = reader.readVarIntNumStrict(false);
-        const outpointBytes = reader.read(outpointLen);
-        const currentOutpoint = (0, utils_1.toUTF8)(outpointBytes);
-        if (currentOutpoint.length > 128 || !/^[^\s.:]+[.:]\d+$/.test(currentOutpoint)) {
-            throw new Error('Serialized UMP token contains an invalid outpoint.');
-        }
+        const currentOutpoint = readSerializedOutpoint(reader, allowUnpublished);
         const token = {
             passwordSalt,
             passwordPresentationPrimary,
@@ -1932,7 +2227,7 @@ class CWIStyleWalletManager {
             passwordKeyEncrypted,
             recoveryKeyEncrypted,
             profilesEncrypted,
-            currentOutpoint,
+            ...(currentOutpoint.length > 0 ? { currentOutpoint } : {}),
             umpVersion,
             passwordKdf
         };
@@ -1946,7 +2241,7 @@ class CWIStyleWalletManager {
      * @param rootPrimaryKey      The user's root primary key (32 bytes).
      * @param ephemeralRootPrivilegedKey Optional root privileged key (e.g., during recovery flows).
      */
-    async setupRoot(rootKey, ephemeralRootPrivilegedKey) {
+    setupRoot(rootKey, ephemeralRootPrivilegedKey, authenticated = true) {
         if (this.currentUMPToken == null) {
             throw new Error('A UMP token must exist before setting up root infrastructure!');
         }
@@ -2006,9 +2301,10 @@ class CWIStyleWalletManager {
                 throw new Error(`Failed to load profiles: ${message}`, { cause: error });
             }
         }
-        this.authenticated = true;
+        this.authenticated = authenticated;
         // Note: We don't call switchProfile here anymore.
         // It's called by the auth methods (providePassword/provideRecoveryKey) or loadSnapshot after this.
+        return Promise.resolve();
     }
     /*
      * ---------------------------------------------------------------------------------------