@ukeyfe/react-native-nfc-litecard 1.0.0

package/dist/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Pure utility functions – no NFC or platform dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesToHex = bytesToHex;
+exports.hexToBytes = hexToBytes;
+exports.calculateCRC16 = calculateCRC16;
+exports.crc16ToBytes = crc16ToBytes;
+exports.extractCRC16 = extractCRC16;
+// ---------------------------------------------------------------------------
+// Hex ↔ bytes
+// ---------------------------------------------------------------------------
+function bytesToHex(bytes) {
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += bytes[i].toString(16).padStart(2, '0');
+    }
+    return hex;
+}
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+    }
+    return bytes;
+}
+// ---------------------------------------------------------------------------
+// CRC16-Modbus
+// ---------------------------------------------------------------------------
+/**
+ * CRC16-Modbus checksum.
+ * Polynomial 0xA001, initial value 0xFFFF, right-shift algorithm.
+ */
+function calculateCRC16(data) {
+    let crc = 0xffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            if ((crc & 0x0001) !== 0) {
+                crc = (crc >> 1) ^ 0xa001;
+            }
+            else {
+                crc = crc >> 1;
+            }
+        }
+    }
+    return crc & 0xffff;
+}
+/** Convert CRC16 to 2-byte little-endian array. */
+function crc16ToBytes(crc16) {
+    return new Uint8Array([crc16 & 0xff, (crc16 >> 8) & 0xff]);
+}
+/**
+ * Extract CRC16 from the last 2 bytes of a data buffer (little-endian).
+ * @throws if buffer is shorter than 2 bytes.
+ */
+function extractCRC16(data) {
+    if (data.length < 2) {
+        throw new Error('INVALID_CARD_DATA');
+    }
+    return data[data.length - 2] | (data[data.length - 1] << 8);
+}

package/dist/writer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+import { ResultCode, type NfcResult } from './types';
+import { isNfcOperationLocked, releaseNfcOperationLock } from './nfc-core';
+export { ResultCode, type NfcResult, isNfcOperationLocked, releaseNfcOperationLock };
+/**
+ * Initialize a blank card: write mnemonic + set password protection.
+ */
+export declare function initializeCard(mnemonic: string, password: string, onCardIdentified?: () => void): Promise<NfcResult>;
+/**
+ * Update card: authenticate with old password, then write new mnemonic + new password.
+ */
+export declare function updateCard(oldPassword: string, newPassword: string, newMnemonic: string, onCardIdentified?: () => void): Promise<NfcResult>;
+/** Change password only (old password required). */
+export declare function updatePassword(oldPassword: string, newPassword: string, onCardIdentified?: () => void): Promise<NfcResult>;
+/** Write a user nickname (password required for authentication). */
+export declare function writeUserNickname(password: string, nickname: string): Promise<NfcResult>;
+/**
+ * Reset card: wipe user data, set password to "000000".
+ * @param password – current card password (required if protection is enabled).
+ */
+export declare function resetCard(password?: string, onCardIdentified?: () => void): Promise<NfcResult>;

package/dist/writer.js

@@ -0,0 +1,545 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseNfcOperationLock = exports.isNfcOperationLocked = exports.ResultCode = void 0;
+exports.initializeCard = initializeCard;
+exports.updateCard = updateCard;
+exports.updatePassword = updatePassword;
+exports.writeUserNickname = writeUserNickname;
+exports.resetCard = resetCard;
+const react_native_nfc_manager_1 = __importDefault(require("react-native-nfc-manager"));
+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, "ResultCode", { enumerable: true, get: function () { return types_1.ResultCode; } });
+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 user memory (pages 0x08–0x27).
+ * iOS: inserts small delays and periodic keep-alive reads.
+ */
+async function writeUserMemory(data) {
+    const buffer = new Uint8Array(constants_1.USER_MEMORY_SIZE);
+    buffer.set(data, 0);
+    const totalPages = constants_1.USER_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, 20));
+            // Keep-alive every 4 pages to prevent iOS session timeout
+            if ((i + 1) % 4 === 0) {
+                try {
+                    await react_native_nfc_manager_1.default.sendMifareCommandIOS([0x30, 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, 10));
+    }
+}
+/** 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, 100));
+    }
+}
+// ===========================================================================
+// Auth configuration
+// ===========================================================================
+/** Enable read+write protection starting from USER_PAGE_START. */
+async function configureAuth() {
+    const cfg0 = await readPage(constants_1.PAGE_CFG0);
+    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, 80));
+    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, 80));
+    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);
+    let typeId;
+    let typeStr;
+    switch (entropyBytes.length) {
+        case 16:
+            typeId = constants_1.MNEMONIC_TYPE_12;
+            typeStr = '12 words (128-bit)';
+            break;
+        case 20:
+            typeId = constants_1.MNEMONIC_TYPE_15;
+            typeStr = '15 words (160-bit)';
+            break;
+        case 24:
+            typeId = constants_1.MNEMONIC_TYPE_18;
+            typeStr = '18 words (192-bit)';
+            break;
+        case 28:
+            typeId = constants_1.MNEMONIC_TYPE_21;
+            typeStr = '21 words (224-bit)';
+            break;
+        case 32:
+            typeId = constants_1.MNEMONIC_TYPE_24;
+            typeStr = '24 words (256-bit)';
+            break;
+        default: throw new Error('UNSUPPORTED_MNEMONIC_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 blank card: write mnemonic + set password protection.
+ */
+async function initializeCard(mnemonic, password, onCardIdentified) {
+    try {
+        await (0, nfc_core_1.acquireNfcLock)();
+    }
+    catch {
+        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+    }
+    try {
+        try {
+            await (0, nfc_core_1.requestNfcTech)();
+        }
+        catch {
+            (0, nfc_core_1.releaseNfcLock)();
+            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+        }
+        try {
+            const entropyResult = mnemonicToEntropyWithCRC(mnemonic);
+            const aesKey = (0, crypto_1.passwordToAesKey)(password);
+            const aesKeyHex = (0, utils_1.bytesToHex)(aesKey);
+            onCardIdentified?.();
+            await writeUserMemory(entropyResult.data);
+            await writeAesKey(aesKey);
+            await configureAuth();
+            try {
+                await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
+            }
+            catch { /* non-fatal */ }
+            await (0, nfc_core_1.releaseNfcTech)();
+            (0, nfc_core_1.releaseNfcLock)();
+            return {
+                code: types_1.ResultCode.INIT_SUCCESS,
+                success: true,
+                data: {
+                    type: entropyResult.type,
+                    entropyHex: entropyResult.entropyHex,
+                    rawBytes: entropyResult.rawBytes,
+                    crc16: entropyResult.crc16,
+                    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 };
+        }
+    }
+    catch (error) {
+        (0, nfc_core_1.releaseNfcLock)();
+        throw error;
+    }
+}
+/**
+ * Update card: authenticate with old password, then write new mnemonic + new password.
+ */
+async function updateCard(oldPassword, newPassword, newMnemonic, onCardIdentified) {
+    try {
+        await (0, nfc_core_1.acquireNfcLock)();
+    }
+    catch {
+        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+    }
+    let retryCountAfterPreDecrement;
+    try {
+        try {
+            await (0, nfc_core_1.requestNfcTech)();
+        }
+        catch {
+            (0, nfc_core_1.releaseNfcLock)();
+            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+        }
+        try {
+            const entropyResult = mnemonicToEntropyWithCRC(newMnemonic);
+            try {
+                const n = await (0, nfc_core_1.decrementRetryCountInSession)();
+                if (typeof n === 'number')
+                    retryCountAfterPreDecrement = n;
+            }
+            catch { /* non-fatal */ }
+            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);
+            }
+            catch { /* non-fatal */ }
+            onCardIdentified?.();
+            await disableAuth();
+            await writeUserMemory(entropyResult.data);
+            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.ResultCode.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.ResultCode.UNKNOWN_ERROR, success: false };
+    }
+    let retryCountAfterPreDecrement;
+    try {
+        try {
+            await (0, nfc_core_1.requestNfcTech)();
+        }
+        catch {
+            (0, nfc_core_1.releaseNfcLock)();
+            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+        }
+        try {
+            try {
+                const n = await (0, nfc_core_1.decrementRetryCountInSession)();
+                if (typeof n === 'number')
+                    retryCountAfterPreDecrement = n;
+            }
+            catch { /* non-fatal */ }
+            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);
+            }
+            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.ResultCode.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) {
+    try {
+        await (0, nfc_core_1.acquireNfcLock)();
+    }
+    catch {
+        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+    }
+    try {
+        try {
+            await (0, nfc_core_1.requestNfcTech)();
+        }
+        catch {
+            (0, nfc_core_1.releaseNfcLock)();
+            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+        }
+        try {
+            const aesKey = (0, crypto_1.passwordToAesKey)(password);
+            await (0, nfc_core_1.authenticate)(aesKey);
+            await disableAuth();
+            await writeNicknameToCard(nickname);
+            await configureAuth();
+            await (0, nfc_core_1.releaseNfcTech)();
+            (0, nfc_core_1.releaseNfcLock)();
+            return {
+                code: types_1.ResultCode.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 user data, set password to "000000".
+ * @param password – current card password (required if protection is enabled).
+ */
+async function resetCard(password, onCardIdentified) {
+    try {
+        await (0, nfc_core_1.acquireNfcLock)();
+    }
+    catch {
+        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+    }
+    let retryCountAfterPreDecrement;
+    try {
+        try {
+            await (0, nfc_core_1.requestNfcTech)();
+        }
+        catch {
+            (0, nfc_core_1.releaseNfcLock)();
+            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+        }
+        try {
+            if (password) {
+                try {
+                    const n = await (0, nfc_core_1.decrementRetryCountInSession)();
+                    if (typeof n === 'number')
+                        retryCountAfterPreDecrement = n;
+                }
+                catch { /* non-fatal */ }
+                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);
+                    }
+                    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 */ }
+                }
+                await disableAuth();
+            }
+            else {
+                try {
+                    await disableAuth();
+                }
+                catch {
+                    throw new Error('AUTH_WRONG_PASSWORD');
+                }
+                onCardIdentified?.();
+            }
+            // Wipe user memory
+            await writeUserMemory(new Uint8Array(constants_1.USER_MEMORY_SIZE));
+            // Set default password "000000"
+            const defaultKey = (0, crypto_1.passwordToAesKey)('000000');
+            await writeAesKey(defaultKey);
+            // Ensure protection is disabled
+            try {
+                await disableAuth();
+            }
+            catch { /* may already be off */ }
+            await (0, nfc_core_1.releaseNfcTech)();
+            (0, nfc_core_1.releaseNfcLock)();
+            return {
+                code: types_1.ResultCode.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;
+    }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@ukeyfe/react-native-nfc-litecard",
+  "version": "1.0.0",
+  "description": "NFC read/write for MIFARE Ultralight AES (LiteCard mnemonic storage)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bestyourwallet/react-native-nfc-litecard.git"
+  },
+  "dependencies": {
+    "bip39": "^3.1.0",
+    "crypto-js": "^4.2.0"
+  },
+  "devDependencies": {
+    "@types/crypto-js": "^4",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.70.0",
+    "react-native-nfc-manager": ">=3.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}