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

package/dist/reader.js

@@ -1,619 +0,0 @@
-"use strict";
-/**
- * NFC Reader Module
- *
- * Public API:
- *   - checkCard()          – detect whether a card is empty or contains data
- *   - readMnemonic()       – read mnemonic (password required)
- *   - readUserNickname()   – read user nickname (password optional)
- *   - readMnemonicRetryCount() – read the PIN retry counter
- *   - resetRetryCountTo10()    – reset the retry counter to default
- *   - cardInfoToJson()     – serialise card-info to JSON
- *
- * 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.DEFAULT_PIN_RETRY_COUNT = exports.clearNfcOperationCancelledByCleanup = exports.getNfcOperationCancelledByCleanupTimestamp = exports.consumeNfcOperationCancelledByCleanup = exports.markNfcOperationCancelledByCleanup = exports.releaseNfcOperationLock = exports.isNfcOperationLocked = exports.NfcStatusCode = void 0;
-exports.cardInfoToJson = cardInfoToJson;
-exports.checkCard = checkCard;
-exports.readMnemonic = readMnemonic;
-exports.readUserNickname = readUserNickname;
-exports.readMnemonicRetryCount = readMnemonicRetryCount;
-exports.resetRetryCountTo10 = resetRetryCountTo10;
-exports.getCardVersion = getCardVersion;
-exports.readOriginality = readOriginality;
-const bip39 = __importStar(require("bip39"));
-const constants_1 = require("./constants");
-Object.defineProperty(exports, "DEFAULT_PIN_RETRY_COUNT", { enumerable: true, get: function () { return constants_1.DEFAULT_PIN_RETRY_COUNT; } });
-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 
-    // re-export lock helpers so consumers can manage lock from outside
-    nfc_core_1.isNfcOperationLocked; } });
-Object.defineProperty(exports, "releaseNfcOperationLock", { enumerable: true, get: function () { return nfc_core_1.releaseNfcOperationLock; } });
-Object.defineProperty(exports, "markNfcOperationCancelledByCleanup", { enumerable: true, get: function () { return nfc_core_1.markNfcOperationCancelledByCleanup; } });
-Object.defineProperty(exports, "consumeNfcOperationCancelledByCleanup", { enumerable: true, get: function () { return nfc_core_1.consumeNfcOperationCancelledByCleanup; } });
-Object.defineProperty(exports, "getNfcOperationCancelledByCleanupTimestamp", { enumerable: true, get: function () { return nfc_core_1.getNfcOperationCancelledByCleanupTimestamp; } });
-Object.defineProperty(exports, "clearNfcOperationCancelledByCleanup", { enumerable: true, get: function () { return nfc_core_1.clearNfcOperationCancelledByCleanup; } });
-// ===========================================================================
-// Internal read helpers
-// ===========================================================================
-/** FAST_READ pages 0x04–0x07 (card info area). */
-async function readUserCardInfo() {
-    const response = await (0, nfc_core_1.transceive)([constants_1.CMD_FAST_READ, constants_1.USER_CARD_INFO_PAGE_START, constants_1.USER_CARD_INFO_PAGE_END]);
-    if (!response || response.length < constants_1.USER_CARD_INFO_SIZE)
-        throw new Error('READ_FAILED');
-    return new Uint8Array(response.slice(0, constants_1.USER_CARD_INFO_SIZE));
-}
-/** FAST_READ nickname pages (last 3 pages of user memory). */
-async function readUserNicknameInternal() {
-    const response = await (0, nfc_core_1.transceive)([constants_1.CMD_FAST_READ, constants_1.USER_NICKNAME_PAGE_START, constants_1.USER_NICKNAME_PAGE_END]);
-    if (!response || response.length < constants_1.USER_NICKNAME_MAX_LENGTH)
-        throw new Error('READ_FAILED');
-    const responseArray = Array.isArray(response) ? response : Array.from(response);
-    const nicknameBytes = new Uint8Array(responseArray.slice(0, constants_1.USER_NICKNAME_MAX_LENGTH));
-    // Find actual length (ignore trailing 0x00 padding)
-    let actualLength = 0;
-    for (let i = 0; i < constants_1.USER_NICKNAME_MAX_LENGTH; i++) {
-        if (nicknameBytes[i] !== 0x00)
-            actualLength = i + 1;
-    }
-    if (actualLength === 0)
-        return '';
-    try {
-        return new TextDecoder('utf-8').decode(nicknameBytes.slice(0, actualLength));
-    }
-    catch {
-        // Fallback: ASCII-compatible manual conversion
-        let result = '';
-        for (let i = 0; i < actualLength; i++)
-            result += String.fromCharCode(nicknameBytes[i]);
-        return result;
-    }
-}
-// ===========================================================================
-// Entropy → mnemonic conversion
-// ===========================================================================
-/**
- * Decode on-card data into a BIP-39 mnemonic.
- *
- * Data layout: [type 1B] [entropy 16-32B] [CRC16 2B]
- */
-function entropyToMnemonic(data) {
-    if (data.length < 19)
-        throw new Error('INVALID_CARD_DATA');
-    if (data.every(b => b === 0))
-        throw new Error('EMPTY_CARD');
-    const { entropyLength, description } = (0, utils_1.getMnemonicTypeInfo)(data[0]);
-    const expectedTotal = 1 + entropyLength + 2;
-    if (data.length < expectedTotal)
-        throw new Error('INVALID_CARD_DATA');
-    const dataBlock = data.slice(0, 1 + entropyLength);
-    const storedCRC = (0, utils_1.extractCRC16)(data.slice(1 + entropyLength, expectedTotal));
-    const calcCRC = (0, utils_1.calculateCRC16)(dataBlock);
-    if (storedCRC !== calcCRC)
-        throw new Error('CRC16_CHECK_FAILED');
-    const entropyBytes = data.slice(1, 1 + entropyLength);
-    const entropyHex = (0, utils_1.bytesToHex)(Array.from(entropyBytes));
-    const rawBytes = (0, utils_1.bytesToHex)(Array.from(dataBlock));
-    const mnemonic = bip39.entropyToMnemonic(entropyHex);
-    return { mnemonic, entropyHex, type: description, rawBytes, crc16: calcCRC };
-}
-// ===========================================================================
-// Card info parsing
-// ===========================================================================
-const CARD_TYPE_MAP = {
-    0x00: 'Unknown',
-    0x01: 'Standard',
-    0x02: 'Encrypted',
-    0x10: 'Test',
-    0x14: 'UKey',
-    0x20: 'Development',
-};
-function parseCardInfo(data) {
-    if (!data || data.length < constants_1.USER_CARD_INFO_SIZE)
-        throw new Error('INVALID_CARD_DATA');
-    const version = data[0];
-    const cardType = data[1];
-    const infoBytes = data.slice(2, constants_1.USER_CARD_INFO_SIZE);
-    const rawBytes = (0, utils_1.bytesToHex)(Array.from(data.slice(0, constants_1.USER_CARD_INFO_SIZE)));
-    const pageBreakdown = [];
-    for (let i = 0; i < Math.ceil(constants_1.USER_CARD_INFO_SIZE / constants_1.PAGE_SIZE); i++) {
-        const off = i * constants_1.PAGE_SIZE;
-        const pageBytes = Array.from(data.slice(off, off + constants_1.PAGE_SIZE));
-        pageBreakdown.push({
-            page: constants_1.USER_CARD_INFO_PAGE_START + i,
-            bytes: pageBytes,
-            hex: (0, utils_1.bytesToHex)(pageBytes),
-        });
-    }
-    return {
-        version,
-        cardType,
-        rawBytes,
-        infoBytes,
-        json: {
-            pageInfo: {
-                startPage: constants_1.USER_CARD_INFO_PAGE_START,
-                endPage: constants_1.USER_CARD_INFO_PAGE_END,
-                totalPages: Math.ceil(constants_1.USER_CARD_INFO_SIZE / constants_1.PAGE_SIZE),
-                totalBytes: constants_1.USER_CARD_INFO_SIZE,
-            },
-            version: { value: version, hex: `0x${version.toString(16).padStart(2, '0')}` },
-            cardType: {
-                value: cardType,
-                hex: `0x${cardType.toString(16).padStart(2, '0')}`,
-                description: CARD_TYPE_MAP[cardType] || `Unknown (0x${cardType.toString(16).padStart(2, '0')})`,
-                known: cardType in CARD_TYPE_MAP,
-            },
-            additionalInfo: { hex: (0, utils_1.bytesToHex)(Array.from(infoBytes)), bytes: Array.from(infoBytes) },
-            rawData: { hex: rawBytes, bytes: Array.from(data.slice(0, constants_1.USER_CARD_INFO_SIZE)), length: constants_1.USER_CARD_INFO_SIZE },
-            pageBreakdown,
-        },
-    };
-}
-/** Serialise parseCardInfo result to JSON. */
-function cardInfoToJson(cardInfo, pretty = true) {
-    return pretty ? JSON.stringify(cardInfo.json, null, 2) : JSON.stringify(cardInfo.json);
-}
-// ===========================================================================
-// Public API
-// ===========================================================================
-/**
- * Detect whether the card is empty or already contains data.
- *
- * Without password: tries to read without auth.
- *   - Read succeeds & first byte is a valid mnemonic type → HAS_DATA
- *   - Read succeeds & first byte is other → EMPTY
- *   - Read fails (auth required) → HAS_DATA (read-protection is on, cannot determine)
- *
- * With password: authenticates first, then reads and validates with CRC16.
- *   - Valid mnemonic payload → HAS_DATA (with type info)
- *   - Empty or invalid data → EMPTY
- *   - Auth failure → AUTH_WRONG_PASSWORD
- */
-async function checkCard(password, 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 {
-            if (password) {
-                // Authenticated check: decrement retry → authenticate → read → validate CRC16
-                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?.();
-                const data = await (0, nfc_core_1.readUserMemory)();
-                try {
-                    const decoded = (0, utils_1.validateMnemonicPayload)(data);
-                    await (0, nfc_core_1.releaseNfcTech)();
-                    (0, nfc_core_1.releaseNfcLock)();
-                    return { code: types_1.NfcStatusCode.CHECK_HAS_DATA, success: true, data: { type: decoded.type } };
-                }
-                catch {
-                    await (0, nfc_core_1.releaseNfcTech)();
-                    (0, nfc_core_1.releaseNfcLock)();
-                    return { code: types_1.NfcStatusCode.CHECK_EMPTY, success: true };
-                }
-            }
-            else {
-                // Unauthenticated check: try to read first page directly
-                onCardIdentified?.();
-                let response = null;
-                try {
-                    response = await (0, nfc_core_1.transceive)([constants_1.CMD_READ, constants_1.USER_PAGE_START]);
-                }
-                catch { /* read-protected */ }
-                await (0, nfc_core_1.releaseNfcTech)();
-                (0, nfc_core_1.releaseNfcLock)();
-                if (response && response.length >= 4) {
-                    let hasData = false;
-                    try {
-                        (0, utils_1.getMnemonicTypeInfo)(response[0]);
-                        hasData = true;
-                    }
-                    catch { /* not a valid type */ }
-                    return { code: hasData ? types_1.NfcStatusCode.CHECK_HAS_DATA : types_1.NfcStatusCode.CHECK_EMPTY, success: true };
-                }
-                // Read failed = protection is on, assume has data
-                return { code: types_1.NfcStatusCode.CHECK_HAS_DATA, 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;
-    }
-}
-/**
- * Read the mnemonic from a password-protected card.
- *
- * Flow: connect → pre-decrement retry counter → authenticate → read →
- *       decode entropy → read nickname → reset retry counter → release
- */
-async function readMnemonic(password, 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 {
-            // Pre-decrement retry counter before auth attempt
-            try {
-                const next = await (0, nfc_core_1.decrementRetryCountInSession)();
-                if (typeof next === 'number')
-                    retryCountAfterPreDecrement = next;
-            }
-            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);
-            onCardIdentified?.();
-            const data = await (0, nfc_core_1.readUserMemory)();
-            const result = entropyToMnemonic(data);
-            let nickname;
-            try {
-                nickname = await readUserNicknameInternal();
-            }
-            catch { /* non-fatal */ }
-            // Auth succeeded – reset counter to default
-            let finalRetryCount;
-            try {
-                await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
-                finalRetryCount = constants_1.DEFAULT_PIN_RETRY_COUNT;
-            }
-            catch { /* non-fatal */ }
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.READ_SUCCESS,
-                success: true,
-                data: {
-                    mnemonic: result.mnemonic,
-                    type: result.type,
-                    entropyHex: result.entropyHex,
-                    rawBytes: result.rawBytes,
-                    nickname,
-                    retryCount: finalRetryCount,
-                },
-            };
-        }
-        catch (error) {
-            const isTimeout = error?.message?.includes('TRANSCEIVE_TIMEOUT') ||
-                error?.message?.includes('timeout') ||
-                error?.message?.includes('TagLost');
-            await (0, nfc_core_1.releaseNfcTech)(isTimeout);
-            (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;
-    }
-}
-/**
- * Read the user nickname from the card.
- * @param password – supply if the card has read-protection enabled.
- */
-async function readUserNickname(password, 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 {
-            if (password) {
-                const aesKey = (0, crypto_1.passwordToAesKey)(password);
-                await (0, nfc_core_1.authenticate)(aesKey);
-            }
-            onCardIdentified?.();
-            const nickname = await readUserNicknameInternal();
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.READ_NICKNAME_SUCCESS,
-                success: true,
-                data: { nickname },
-            };
-        }
-        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;
-    }
-}
-/** Read the current PIN retry counter from the card. */
-async function readMnemonicRetryCount(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 {
-            onCardIdentified?.();
-            const pageBlock = await (0, nfc_core_1.transceive)([constants_1.CMD_READ, constants_1.RETRY_COUNTER_PAGE]);
-            if (!pageBlock || pageBlock.length < constants_1.PAGE_SIZE) {
-                await (0, nfc_core_1.releaseNfcTech)();
-                (0, nfc_core_1.releaseNfcLock)();
-                return {
-                    code: types_1.NfcStatusCode.READ_RETRY_COUNT_SUCCESS,
-                    success: true,
-                    data: { retryCount: 0 },
-                };
-            }
-            const retryCount = typeof pageBlock[constants_1.RETRY_COUNTER_OFFSET] === 'number' ? pageBlock[constants_1.RETRY_COUNTER_OFFSET] & 0xff : 0;
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.READ_RETRY_COUNT_SUCCESS,
-                success: true,
-                data: { retryCount },
-            };
-        }
-        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 the PIN retry counter to the default value (10). */
-async function resetRetryCountTo10(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 {
-            onCardIdentified?.();
-            await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.READ_RETRY_COUNT_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 code = (0, types_1.errorToCode)(error);
-            return { code, success: false };
-        }
-    }
-    catch (error) {
-        (0, nfc_core_1.releaseNfcLock)();
-        throw error;
-    }
-}
-/**
- * Read card product version info (GET_VERSION command).
- * No authentication required.
- */
-async function getCardVersion(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 {
-            onCardIdentified?.();
-            const response = await (0, nfc_core_1.transceive)([constants_1.CMD_GET_VERSION]);
-            if (!response || response.length < 8) {
-                throw new Error('READ_FAILED');
-            }
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.GET_VERSION_SUCCESS,
-                success: true,
-                data: {
-                    version: {
-                        vendorId: response[1],
-                        productType: response[2],
-                        productSubtype: response[3],
-                        majorVersion: response[4],
-                        minorVersion: response[5],
-                        storageSize: response[6],
-                        protocolType: response[7],
-                    },
-                },
-            };
-        }
-        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;
-    }
-}
-/**
- * Read the ECC originality signature (READ_SIG command).
- * Verifies the card is a genuine NXP product.
- * No authentication required (unless Random ID is enabled).
- */
-async function readOriginality(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 {
-            onCardIdentified?.();
-            const response = await (0, nfc_core_1.transceive)([constants_1.CMD_READ_SIG, 0x00]);
-            if (!response || response.length < 48) {
-                throw new Error('READ_FAILED');
-            }
-            const signatureHex = (0, utils_1.bytesToHex)(response.slice(0, 48));
-            await (0, nfc_core_1.releaseNfcTech)();
-            (0, nfc_core_1.releaseNfcLock)();
-            return {
-                code: types_1.NfcStatusCode.READ_SIG_SUCCESS,
-                success: true,
-                data: { signature: signatureHex },
-            };
-        }
-        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;
-    }
-}

package/dist/types.d.ts

@@ -1,80 +0,0 @@
-/**
- * Unified result codes, NfcResult interface, and error mapping helpers.
- *
- * All codes are unique across reader and writer to prevent ambiguity.
- *   - Reader success : 101xx
- *   - Writer success : 102xx
- *   - Failure        : 4xxxx (shared)
- *
- * This library does NOT provide user-facing messages.
- * The caller should map NfcStatusCode to their own localised strings.
- */
-export declare const NfcStatusCode: {
-    readonly READ_SUCCESS: 10102;
-    readonly READ_NICKNAME_SUCCESS: 10103;
-    readonly CHECK_EMPTY: 10104;
-    readonly CHECK_HAS_DATA: 10105;
-    readonly READ_RETRY_COUNT_SUCCESS: 10106;
-    readonly GET_VERSION_SUCCESS: 10107;
-    readonly READ_SIG_SUCCESS: 10108;
-    readonly INIT_SUCCESS: 10201;
-    readonly WRITE_SUCCESS: 10203;
-    readonly UPDATE_PASSWORD_SUCCESS: 10204;
-    readonly WRITE_NICKNAME_SUCCESS: 10205;
-    readonly RESET_SUCCESS: 10206;
-    /** Card already has a valid mnemonic backup; write was skipped */
-    readonly PRECHECK_HAS_BACKUP: 10207;
-    readonly NFC_CONNECT_FAILED: 40001;
-    readonly AUTH_WRONG_PASSWORD: 40002;
-    readonly AUTH_INVALID_RESPONSE: 40003;
-    readonly AUTH_VERIFY_FAILED: 40004;
-    readonly READ_FAILED: 40005;
-    readonly WRITE_FAILED: 40006;
-    readonly INVALID_MNEMONIC: 40007;
-    readonly UNSUPPORTED_MNEMONIC_LENGTH: 40008;
-    readonly INVALID_CARD_DATA: 40009;
-    readonly UNKNOWN_ERROR: 40010;
-    readonly NFC_USER_CANCELED: 40011;
-    readonly READ_TIMEOUT: 40012;
-    readonly NFC_LOCK_TIMEOUT: 40013;
-    readonly CRC16_CHECK_FAILED: 40014;
-    /** PIN retry counter is 0; no authentication attempts left */
-    readonly RETRY_COUNT_EXHAUSTED: 40015;
-};
-export interface NfcResult {
-    /** Numeric result code – compare against NfcStatusCode constants */
-    code: number;
-    /** Whether the operation succeeded */
-    success: boolean;
-    /** Returned data (optional, only present for some operations) */
-    data?: {
-        mnemonic?: string;
-        type?: string;
-        entropyHex?: string;
-        rawBytes?: string;
-        nickname?: string;
-        retryCount?: number;
-        aesKeyHex?: string;
-        crc16?: number;
-        version?: {
-            vendorId: number;
-            productType: number;
-            productSubtype: number;
-            majorVersion: number;
-            minorVersion: number;
-            storageSize: number;
-            protocolType: number;
-        };
-        signature?: string;
-    };
-}
-/**
- * Unified failure result when the PIN retry counter has reached 0.
- * Used by readMnemonic, updateCard, updatePassword, and resetCard.
- */
-export declare function nfcResultRetryCountExhausted(): NfcResult;
-/**
- * Derive a NfcStatusCode from an error thrown during NFC operations.
- * Handles iOS-specific cancel detection, known error strings, and fallback.
- */
-export declare function errorToCode(error: any): number;