@ukeyfe/react-native-nfc-litecard 1.0.6 → 1.0.8

package/dist/writer.js

@@ -1,623 +0,0 @@
-"use strict";
-/**
- * NFC Writer Module
- *
- * Public API:
- *   - initializeCard()     – write mnemonic + set password on a blank card
- *   - updateCard()         – update mnemonic & password (old password required)
- *   - updatePassword()     – change password only
- *   - writeUserNickname()  – write user nickname (password required)
- *   - resetCard()          – wipe card and set password to "000000"
- *
- * Based on MIFARE Ultralight AES (MF0AES(H)20) datasheet.
- */
-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.releaseNfcOperationLock = exports.isNfcOperationLocked = exports.NfcStatusCode = void 0;
-exports.initializeCard = initializeCard;
-exports.updateCard = updateCard;
-exports.updatePassword = updatePassword;
-exports.writeUserNickname = writeUserNickname;
-exports.resetCard = resetCard;
-const react_native_1 = require("react-native");
-const bip39 = __importStar(require("bip39"));
-const constants_1 = require("./constants");
-const types_1 = require("./types");
-Object.defineProperty(exports, "NfcStatusCode", { enumerable: true, get: function () { return types_1.NfcStatusCode; } });
-const utils_1 = require("./utils");
-const crypto_1 = require("./crypto");
-const nfc_core_1 = require("./nfc-core");
-Object.defineProperty(exports, "isNfcOperationLocked", { enumerable: true, get: function () { return nfc_core_1.isNfcOperationLocked; } });
-Object.defineProperty(exports, "releaseNfcOperationLock", { enumerable: true, get: function () { return nfc_core_1.releaseNfcOperationLock; } });
-// ===========================================================================
-// Internal write helpers
-// ===========================================================================
-async function readPage(page) {
-    return await (0, nfc_core_1.transceive)([constants_1.CMD_READ, page]);
-}
-async function writePage(page, data) {
-    if (data.length !== 4)
-        throw new Error('INVALID_CARD_DATA');
-    await (0, nfc_core_1.transceive)([constants_1.CMD_WRITE, page, ...data]);
-}
-/**
- * Write data to mnemonic area (pages 0x08–0x24).
- * Does NOT touch the nickname area (pages 0x25–0x27).
- * iOS: inserts small delays and periodic keep-alive reads.
- */
-async function writeUserMemory(data) {
-    const buffer = new Uint8Array(constants_1.MNEMONIC_MEMORY_SIZE);
-    buffer.set(data.slice(0, constants_1.MNEMONIC_MEMORY_SIZE), 0);
-    const totalPages = constants_1.MNEMONIC_PAGE_END - constants_1.USER_PAGE_START + 1;
-    for (let i = 0; i < totalPages; i++) {
-        const page = constants_1.USER_PAGE_START + i;
-        const offset = i * constants_1.PAGE_SIZE;
-        const pageData = Array.from(buffer.slice(offset, offset + constants_1.PAGE_SIZE));
-        await writePage(page, pageData);
-        if (react_native_1.Platform.OS === 'ios' && i < totalPages - 1) {
-            await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_PAGE_WRITE));
-            // Keep-alive every 4 pages to prevent iOS session timeout
-            if ((i + 1) % constants_1.DELAY.KEEPALIVE_FREQ === 0) {
-                try {
-                    await (0, nfc_core_1.transceive)([constants_1.CMD_READ, 0x00]);
-                }
-                catch { /* non-fatal */ }
-            }
-        }
-    }
-}
-/**
- * Write a 16-byte AES key to AES_KEY0 (pages 0x30–0x33).
- * Byte order is reversed per the datasheet.
- */
-async function writeAesKey(key) {
-    for (let i = 0; i < 4; i++) {
-        const page = constants_1.PAGE_AES_KEY0_START + i;
-        const off = (3 - i) * 4;
-        const pageData = [key[off + 3], key[off + 2], key[off + 1], key[off + 0]];
-        await writePage(page, pageData);
-        if (react_native_1.Platform.OS === 'ios' && i < 3)
-            await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_KEY_WRITE));
-    }
-}
-/** Write a UTF-8 nickname into the last 3 pages of user memory. */
-async function writeNicknameToCard(nickname) {
-    const safeNickname = nickname || '';
-    const encoder = new TextEncoder();
-    let nicknameBytes = encoder.encode(String(safeNickname));
-    if (nicknameBytes.length > constants_1.USER_NICKNAME_MAX_LENGTH) {
-        nicknameBytes = nicknameBytes.slice(0, constants_1.USER_NICKNAME_MAX_LENGTH);
-    }
-    const buffer = new Uint8Array(constants_1.USER_NICKNAME_MAX_LENGTH);
-    buffer.set(nicknameBytes, 0);
-    const totalPages = constants_1.USER_NICKNAME_PAGE_END - constants_1.USER_NICKNAME_PAGE_START + 1;
-    for (let i = 0; i < totalPages; i++) {
-        const page = constants_1.USER_NICKNAME_PAGE_START + i;
-        const offset = i * constants_1.PAGE_SIZE;
-        await writePage(page, Array.from(buffer.slice(offset, offset + constants_1.PAGE_SIZE)));
-        if (react_native_1.Platform.OS === 'ios' && i < totalPages - 1)
-            await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_NICKNAME_WRITE));
-    }
-}
-// ===========================================================================
-// Auth configuration
-// ===========================================================================
-/** Enable read+write protection and secure messaging starting from USER_PAGE_START. */
-async function configureAuth() {
-    const cfg0 = await readPage(constants_1.PAGE_CFG0);
-    cfg0[0] = cfg0[0] | constants_1.SEC_MSG_ACT_MASK; // Enable CMAC secure messaging
-    cfg0[3] = constants_1.USER_PAGE_START;
-    await writePage(constants_1.PAGE_CFG0, cfg0.slice(0, 4));
-    if (react_native_1.Platform.OS === 'ios')
-        await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_CONFIG));
-    const cfg1 = await readPage(constants_1.PAGE_CFG1);
-    cfg1[0] = cfg1[0] | 0x80; // PROT bit = 1
-    await writePage(constants_1.PAGE_CFG1, cfg1.slice(0, 4));
-}
-/** Disable auth protection (AUTH0 = 0x3C, PROT = 0). */
-async function disableAuth() {
-    if (react_native_1.Platform.OS === 'ios') {
-        try {
-            await (0, nfc_core_1.transceive)([constants_1.CMD_READ, 0x00]);
-        }
-        catch { /* keep-alive */ }
-    }
-    const cfg0 = await readPage(constants_1.PAGE_CFG0);
-    cfg0[3] = 0x3c;
-    await writePage(constants_1.PAGE_CFG0, cfg0.slice(0, 4));
-    if (react_native_1.Platform.OS === 'ios')
-        await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_CONFIG));
-    const cfg1 = await readPage(constants_1.PAGE_CFG1);
-    cfg1[0] = cfg1[0] & 0x7f; // Clear PROT bit
-    await writePage(constants_1.PAGE_CFG1, cfg1.slice(0, 4));
-}
-// ===========================================================================
-// Mnemonic → entropy conversion
-// ===========================================================================
-/**
- * Convert a BIP-39 mnemonic into the on-card storage format:
- * [type 1B] [entropy 16-32B] [CRC16 2B]
- */
-function mnemonicToEntropyWithCRC(mnemonic) {
-    if (!bip39.validateMnemonic(mnemonic))
-        throw new Error('INVALID_MNEMONIC');
-    const entropyHex = bip39.mnemonicToEntropy(mnemonic);
-    const entropyBytes = (0, utils_1.hexToBytes)(entropyHex);
-    const { typeId, description: typeStr } = (0, utils_1.getMnemonicTypeByEntropyLength)(entropyBytes.length);
-    const dataBlock = new Uint8Array(1 + entropyBytes.length);
-    dataBlock[0] = typeId;
-    dataBlock.set(entropyBytes, 1);
-    const crc16 = (0, utils_1.calculateCRC16)(dataBlock);
-    const result = new Uint8Array(dataBlock.length + 2);
-    result.set(dataBlock, 0);
-    result.set((0, utils_1.crc16ToBytes)(crc16), dataBlock.length);
-    return { data: result, type: typeStr, entropyHex, rawBytes: (0, utils_1.bytesToHex)(result), crc16 };
-}
-// ===========================================================================
-// Public API
-// ===========================================================================
-/**
- * Initialize a card: authenticate with the default password, then write
- * mnemonic and set a new password.
- *
- * @param mnemonic       BIP-39 mnemonic to write.
- * @param newPassword    Password to protect the card with after initialization.
- * @param defaultPassword Current (factory-default) password on the card.
- */
-async function initializeCard(mnemonic, newPassword, defaultPassword, onCardIdentified) {
-    try {
-        await (0, nfc_core_1.acquireNfcLock)();
-    }
-    catch {
-        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
-    }
-    let retryCountAfterPreDecrement;
-    try {
-        try {
-            await (0, nfc_core_1.requestNfcTech)();
-        }
-        catch {
-            (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
-        }
-        try {
-            const entropyResult = mnemonicToEntropyWithCRC(mnemonic);
-            // Decrement retry counter before auth
-            try {
-                const n = await (0, nfc_core_1.decrementRetryCountInSession)();
-                if (typeof n === 'number')
-                    retryCountAfterPreDecrement = n;
-            }
-            catch (error) {
-                const code = (0, types_1.errorToCode)(error);
-                if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
-                    await (0, nfc_core_1.releaseNfcTech)();
-                    (0, nfc_core_1.releaseNfcLock)();
-                    return (0, types_1.nfcResultRetryCountExhausted)();
-                }
-            }
-            // Authenticate with factory-default password
-            const oldKey = (0, crypto_1.passwordToAesKey)(defaultPassword);
-            await (0, nfc_core_1.authenticate)(oldKey);
-            // Auth succeeded – reset retry counter
-            try {
-                await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
-                retryCountAfterPreDecrement = constants_1.DEFAULT_PIN_RETRY_COUNT;
-            }
-            catch { /* non-fatal */ }
-            onCardIdentified?.();
-            // Write mnemonic (while still authenticated)
-            await writeUserMemory(entropyResult.data);
-            // Switch to new password
-            const newKey = (0, crypto_1.passwordToAesKey)(newPassword);
-            await disableAuth();
-            await writeAesKey(newKey);
-            await configureAuth();
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.INIT_SUCCESS,
-                success: true,
-                data: {
-                    type: entropyResult.type,
-                    entropyHex: entropyResult.entropyHex,
-                    rawBytes: entropyResult.rawBytes,
-                    crc16: entropyResult.crc16,
-                    retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT,
-                },
-            };
-        }
-        catch (error) {
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            const code = (0, types_1.errorToCode)(error);
-            return {
-                code,
-                success: false,
-                data: typeof retryCountAfterPreDecrement === 'number' ? { retryCount: retryCountAfterPreDecrement } : undefined,
-            };
-        }
-    }
-    catch (error) {
-        (0, nfc_core_1.releaseNfcLock)();
-        throw error;
-    }
-}
-/**
- * Update card: authenticate with old password, then write new mnemonic + new password.
- *
- * When `options.precheckExistingMnemonic` is true, the card is read after authentication.
- * If a valid mnemonic backup already exists, the write is skipped and PRECHECK_HAS_BACKUP
- * is returned (`success: true` — operation completed; distinguish outcome by `code`).
- * Otherwise the normal write flow proceeds.
- */
-async function updateCard(oldPassword, newPassword, newMnemonic, onCardIdentified, options) {
-    try {
-        await (0, nfc_core_1.acquireNfcLock)();
-    }
-    catch {
-        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
-    }
-    let retryCountAfterPreDecrement;
-    try {
-        try {
-            await (0, nfc_core_1.requestNfcTech)();
-        }
-        catch {
-            (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
-        }
-        try {
-            try {
-                const n = await (0, nfc_core_1.decrementRetryCountInSession)();
-                if (typeof n === 'number')
-                    retryCountAfterPreDecrement = n;
-            }
-            catch (error) {
-                const code = (0, types_1.errorToCode)(error);
-                if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
-                    await (0, nfc_core_1.releaseNfcTech)();
-                    (0, nfc_core_1.releaseNfcLock)();
-                    return (0, types_1.nfcResultRetryCountExhausted)();
-                }
-                // Communication failure — counter was not decremented, continue to auth
-            }
-            const oldKey = (0, crypto_1.passwordToAesKey)(oldPassword);
-            await (0, nfc_core_1.authenticate)(oldKey);
-            try {
-                await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
-                retryCountAfterPreDecrement = constants_1.DEFAULT_PIN_RETRY_COUNT;
-            }
-            catch { /* non-fatal */ }
-            onCardIdentified?.();
-            if (options?.precheckExistingMnemonic) {
-                try {
-                    const data = await (0, nfc_core_1.readUserMemory)();
-                    const decoded = (0, utils_1.validateMnemonicPayload)(data);
-                    await (0, nfc_core_1.releaseNfcTech)();
-                    (0, nfc_core_1.releaseNfcLock)();
-                    return {
-                        code: types_1.NfcStatusCode.PRECHECK_HAS_BACKUP,
-                        success: true,
-                        data: { type: decoded.type, retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT },
-                    };
-                }
-                catch (e) {
-                    const c = (0, types_1.errorToCode)(e);
-                    if (c === types_1.NfcStatusCode.CHECK_EMPTY ||
-                        c === types_1.NfcStatusCode.CRC16_CHECK_FAILED ||
-                        c === types_1.NfcStatusCode.INVALID_CARD_DATA) {
-                        // No valid mnemonic on card — fall through to write
-                    }
-                    else {
-                        await (0, nfc_core_1.releaseNfcTech)();
-                        (0, nfc_core_1.releaseNfcLock)();
-                        return { code: c, success: false };
-                    }
-                }
-            }
-            const entropyResult = mnemonicToEntropyWithCRC(newMnemonic);
-            await writeUserMemory(entropyResult.data);
-            await disableAuth();
-            const newKey = (0, crypto_1.passwordToAesKey)(newPassword);
-            const aesKeyHex = (0, utils_1.bytesToHex)(newKey);
-            await writeAesKey(newKey);
-            await configureAuth();
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.WRITE_SUCCESS,
-                success: true,
-                data: {
-                    type: entropyResult.type,
-                    entropyHex: entropyResult.entropyHex,
-                    rawBytes: entropyResult.rawBytes,
-                    aesKeyHex,
-                    retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT,
-                },
-            };
-        }
-        catch (error) {
-            const isTransceiveErr = error?.message?.includes('transceive fail') ||
-                error?.message?.includes('TagLost');
-            await (0, nfc_core_1.releaseNfcTech)(isTransceiveErr);
-            (0, nfc_core_1.releaseNfcLock)();
-            const code = (0, types_1.errorToCode)(error);
-            return {
-                code,
-                success: false,
-                data: typeof retryCountAfterPreDecrement === 'number' ? { retryCount: retryCountAfterPreDecrement } : undefined,
-            };
-        }
-    }
-    catch (error) {
-        (0, nfc_core_1.releaseNfcLock)();
-        throw error;
-    }
-}
-/** Change password only (old password required). */
-async function updatePassword(oldPassword, newPassword, onCardIdentified) {
-    try {
-        await (0, nfc_core_1.acquireNfcLock)();
-    }
-    catch {
-        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
-    }
-    let retryCountAfterPreDecrement;
-    try {
-        try {
-            await (0, nfc_core_1.requestNfcTech)();
-        }
-        catch {
-            (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
-        }
-        try {
-            try {
-                const n = await (0, nfc_core_1.decrementRetryCountInSession)();
-                if (typeof n === 'number')
-                    retryCountAfterPreDecrement = n;
-            }
-            catch (error) {
-                const code = (0, types_1.errorToCode)(error);
-                if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
-                    await (0, nfc_core_1.releaseNfcTech)();
-                    (0, nfc_core_1.releaseNfcLock)();
-                    return (0, types_1.nfcResultRetryCountExhausted)();
-                }
-                // Communication failure — counter was not decremented, continue to auth
-            }
-            const oldKey = (0, crypto_1.passwordToAesKey)(oldPassword);
-            await (0, nfc_core_1.authenticate)(oldKey);
-            try {
-                await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
-                retryCountAfterPreDecrement = constants_1.DEFAULT_PIN_RETRY_COUNT;
-            }
-            catch { /* non-fatal */ }
-            onCardIdentified?.();
-            await disableAuth();
-            const newKey = (0, crypto_1.passwordToAesKey)(newPassword);
-            const aesKeyHex = (0, utils_1.bytesToHex)(newKey);
-            await writeAesKey(newKey);
-            await configureAuth();
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.UPDATE_PASSWORD_SUCCESS,
-                success: true,
-                data: { aesKeyHex, retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT },
-            };
-        }
-        catch (error) {
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            const code = (0, types_1.errorToCode)(error);
-            return {
-                code,
-                success: false,
-                data: typeof retryCountAfterPreDecrement === 'number' ? { retryCount: retryCountAfterPreDecrement } : undefined,
-            };
-        }
-    }
-    catch (error) {
-        (0, nfc_core_1.releaseNfcLock)();
-        throw error;
-    }
-}
-/** Write a user nickname (password required for authentication). */
-async function writeUserNickname(password, nickname, onCardIdentified) {
-    try {
-        await (0, nfc_core_1.acquireNfcLock)();
-    }
-    catch {
-        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
-    }
-    try {
-        try {
-            await (0, nfc_core_1.requestNfcTech)();
-        }
-        catch {
-            (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
-        }
-        try {
-            // Pre-decrement retry counter before auth
-            try {
-                await (0, nfc_core_1.decrementRetryCountInSession)();
-            }
-            catch (error) {
-                const code = (0, types_1.errorToCode)(error);
-                if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
-                    await (0, nfc_core_1.releaseNfcTech)();
-                    (0, nfc_core_1.releaseNfcLock)();
-                    return (0, types_1.nfcResultRetryCountExhausted)();
-                }
-            }
-            const aesKey = (0, crypto_1.passwordToAesKey)(password);
-            await (0, nfc_core_1.authenticate)(aesKey);
-            // Auth succeeded – reset retry counter
-            try {
-                await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
-            }
-            catch { /* non-fatal */ }
-            onCardIdentified?.();
-            await disableAuth();
-            await writeNicknameToCard(nickname);
-            await configureAuth();
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.WRITE_NICKNAME_SUCCESS,
-                success: true,
-            };
-        }
-        catch (error) {
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            const code = (0, types_1.errorToCode)(error);
-            return { code, success: false };
-        }
-    }
-    catch (error) {
-        (0, nfc_core_1.releaseNfcLock)();
-        throw error;
-    }
-}
-/**
- * Reset card: wipe mnemonic data and set a new password.
- * @param password – current card password (required if protection is enabled).
- * @param newPassword – password to set after reset.
- * @param onCardIdentified – callback when card is identified.
- */
-async function resetCard(password, newPassword, onCardIdentified) {
-    try {
-        await (0, nfc_core_1.acquireNfcLock)();
-    }
-    catch {
-        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
-    }
-    let retryCountAfterPreDecrement;
-    try {
-        try {
-            await (0, nfc_core_1.requestNfcTech)();
-        }
-        catch {
-            (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
-        }
-        try {
-            if (password) {
-                try {
-                    const n = await (0, nfc_core_1.decrementRetryCountInSession)();
-                    if (typeof n === 'number')
-                        retryCountAfterPreDecrement = n;
-                }
-                catch (error) {
-                    const code = (0, types_1.errorToCode)(error);
-                    if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
-                        await (0, nfc_core_1.releaseNfcTech)();
-                        (0, nfc_core_1.releaseNfcLock)();
-                        return (0, types_1.nfcResultRetryCountExhausted)();
-                    }
-                    // Communication failure — counter was not decremented, continue to auth
-                }
-                const aesKey = (0, crypto_1.passwordToAesKey)(password);
-                try {
-                    await (0, nfc_core_1.authenticate)(aesKey);
-                    try {
-                        await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
-                        retryCountAfterPreDecrement = constants_1.DEFAULT_PIN_RETRY_COUNT;
-                    }
-                    catch { /* non-fatal */ }
-                }
-                catch (authError) {
-                    const msg = authError?.message || '';
-                    if (msg.includes('AUTH_WRONG_PASSWORD') ||
-                        (react_native_1.Platform.OS === 'ios' && (msg.includes('AUTH_INVALID_RESPONSE') || !msg.trim()))) {
-                        throw new Error('AUTH_WRONG_PASSWORD');
-                    }
-                    throw authError;
-                }
-                onCardIdentified?.();
-                // iOS: verify connection after auth
-                if (react_native_1.Platform.OS === 'ios') {
-                    try {
-                        await readPage(constants_1.USER_PAGE_START);
-                    }
-                    catch { /* non-fatal */ }
-                }
-            }
-            else {
-                try {
-                    await (0, nfc_core_1.authenticate)((0, crypto_1.passwordToAesKey)(newPassword));
-                }
-                catch {
-                    throw new Error('AUTH_WRONG_PASSWORD');
-                }
-                onCardIdentified?.();
-            }
-            // Wipe mnemonic data (nickname is preserved)
-            await writeUserMemory(new Uint8Array(constants_1.MNEMONIC_MEMORY_SIZE));
-            // Set new password and keep protection enabled
-            const resetKey = (0, crypto_1.passwordToAesKey)(newPassword);
-            await disableAuth();
-            await writeAesKey(resetKey);
-            await configureAuth();
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.RESET_SUCCESS,
-                success: true,
-                data: { retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT },
-            };
-        }
-        catch (error) {
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            const rawMsg = error.message || '';
-            const isWriteErr = rawMsg.includes('WRITE_FAILED') || rawMsg.includes('transceive');
-            const code = (0, types_1.errorToCode)(isWriteErr ? new Error('WRITE_FAILED') : error);
-            return {
-                code,
-                success: false,
-                data: typeof retryCountAfterPreDecrement === 'number' ? { retryCount: retryCountAfterPreDecrement } : undefined,
-            };
-        }
-    }
-    catch (error) {
-        (0, nfc_core_1.releaseNfcLock)();
-        throw error;
-    }
-}