@ukeyfe/react-native-nfc-litecard 1.0.5 → 1.0.7

package/dist/types.js

@@ -1,113 +0,0 @@
-"use strict";
-/**
- * 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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NfcStatusCode = void 0;
-exports.nfcResultRetryCountExhausted = nfcResultRetryCountExhausted;
-exports.errorToCode = errorToCode;
-const react_native_1 = require("react-native");
-// ---------------------------------------------------------------------------
-// Unified result codes
-// ---------------------------------------------------------------------------
-exports.NfcStatusCode = {
-    // Reader success (101xx)
-    READ_SUCCESS: 10102,
-    READ_NICKNAME_SUCCESS: 10103,
-    CHECK_EMPTY: 10104,
-    CHECK_HAS_DATA: 10105,
-    READ_RETRY_COUNT_SUCCESS: 10106,
-    GET_VERSION_SUCCESS: 10107,
-    READ_SIG_SUCCESS: 10108,
-    // Writer success (102xx)
-    INIT_SUCCESS: 10201,
-    WRITE_SUCCESS: 10203,
-    UPDATE_PASSWORD_SUCCESS: 10204,
-    WRITE_NICKNAME_SUCCESS: 10205,
-    RESET_SUCCESS: 10206,
-    /** Card already has a valid mnemonic backup; write was skipped */
-    PRECHECK_HAS_BACKUP: 10207,
-    // Failure (4xxxx – shared by reader & writer)
-    NFC_CONNECT_FAILED: 40001,
-    AUTH_WRONG_PASSWORD: 40002,
-    AUTH_INVALID_RESPONSE: 40003,
-    AUTH_VERIFY_FAILED: 40004,
-    READ_FAILED: 40005,
-    WRITE_FAILED: 40006,
-    INVALID_MNEMONIC: 40007,
-    UNSUPPORTED_MNEMONIC_LENGTH: 40008,
-    INVALID_CARD_DATA: 40009,
-    UNKNOWN_ERROR: 40010,
-    NFC_USER_CANCELED: 40011,
-    READ_TIMEOUT: 40012,
-    NFC_LOCK_TIMEOUT: 40013,
-    CRC16_CHECK_FAILED: 40014,
-    /** PIN retry counter is 0; no authentication attempts left */
-    RETRY_COUNT_EXHAUSTED: 40015,
-};
-/**
- * Unified failure result when the PIN retry counter has reached 0.
- * Used by readMnemonic, updateCard, updatePassword, and resetCard.
- */
-function nfcResultRetryCountExhausted() {
-    return {
-        code: exports.NfcStatusCode.RETRY_COUNT_EXHAUSTED,
-        success: false,
-        data: { retryCount: 0 },
-    };
-}
-// ---------------------------------------------------------------------------
-// Error → code mapping (internal use)
-// ---------------------------------------------------------------------------
-/**
- * Derive a NfcStatusCode from an error thrown during NFC operations.
- * Handles iOS-specific cancel detection, known error strings, and fallback.
- */
-function errorToCode(error) {
-    const msg = (typeof error === 'string'
-        ? error
-        : (error?.message || '')).trim();
-    // iOS user-cancel detection
-    if (react_native_1.Platform.OS === 'ios') {
-        if (error &&
-            typeof error === 'object' &&
-            (error.name === 'UserCancel' || error.constructor?.name === 'UserCancel')) {
-            return exports.NfcStatusCode.NFC_USER_CANCELED;
-        }
-        if (!msg || msg.includes('User Canceled') || msg.includes('Unknown empty error')) {
-            return exports.NfcStatusCode.NFC_USER_CANCELED;
-        }
-    }
-    if (msg.includes('NFC_USER_CANCELED_SIGNAL'))
-        return exports.NfcStatusCode.NFC_USER_CANCELED;
-    const keywords = [
-        ['RETRY_COUNT_EXHAUSTED', exports.NfcStatusCode.RETRY_COUNT_EXHAUSTED],
-        ['AUTH_WRONG_PASSWORD', exports.NfcStatusCode.AUTH_WRONG_PASSWORD],
-        ['AUTH_INVALID_RESPONSE', exports.NfcStatusCode.AUTH_INVALID_RESPONSE],
-        ['AUTH_VERIFY_FAILED', exports.NfcStatusCode.AUTH_VERIFY_FAILED],
-        ['READ_FAILED', exports.NfcStatusCode.READ_FAILED],
-        ['WRITE_FAILED', exports.NfcStatusCode.WRITE_FAILED],
-        ['CRC16_CHECK_FAILED', exports.NfcStatusCode.CRC16_CHECK_FAILED],
-        ['EMPTY_CARD', exports.NfcStatusCode.CHECK_EMPTY],
-        ['INVALID_CARD_DATA', exports.NfcStatusCode.INVALID_CARD_DATA],
-        ['INVALID_MNEMONIC', exports.NfcStatusCode.INVALID_MNEMONIC],
-        ['UNSUPPORTED_MNEMONIC_LENGTH', exports.NfcStatusCode.UNSUPPORTED_MNEMONIC_LENGTH],
-        ['NFC_LOCK_TIMEOUT', exports.NfcStatusCode.NFC_LOCK_TIMEOUT],
-        ['NFC_CONNECT_FAILED', exports.NfcStatusCode.NFC_CONNECT_FAILED],
-        ['connection failed', exports.NfcStatusCode.NFC_CONNECT_FAILED],
-        ['transceive fail', exports.NfcStatusCode.NFC_CONNECT_FAILED],
-    ];
-    for (const [keyword, code] of keywords) {
-        if (msg.includes(keyword))
-            return code;
-    }
-    return exports.NfcStatusCode.UNKNOWN_ERROR;
-}

package/dist/utils.d.ts

@@ -1,43 +0,0 @@
-/**
- * Pure utility functions – no NFC or platform dependencies.
- */
-export declare function bytesToHex(bytes: Uint8Array | number[]): string;
-export declare function hexToBytes(hex: string): Uint8Array;
-/**
- * CRC16-Modbus checksum.
- * Polynomial 0xA001, initial value 0xFFFF, right-shift algorithm.
- */
-export declare function calculateCRC16(data: Uint8Array): number;
-/** Convert CRC16 to 2-byte little-endian array. */
-export declare function crc16ToBytes(crc16: number): Uint8Array;
-/**
- * Extract CRC16 from the last 2 bytes of a data buffer (little-endian).
- * @throws if buffer is shorter than 2 bytes.
- */
-export declare function extractCRC16(data: Uint8Array): number;
-/**
- * Get entropy length and description for a mnemonic type ID.
- * @throws INVALID_CARD_DATA if the type ID is unknown.
- */
-export declare function getMnemonicTypeInfo(typeId: number): {
-    entropyLength: number;
-    description: string;
-};
-/**
- * Get type ID and description for a given entropy byte length.
- * @throws UNSUPPORTED_MNEMONIC_LENGTH if the length is not recognized.
- */
-export declare function getMnemonicTypeByEntropyLength(entropyLength: number): {
-    typeId: number;
-    description: string;
-};
-/**
- * Validate whether raw card data contains a valid mnemonic payload.
- * Checks type byte, length, and CRC16 — does NOT decode the mnemonic.
- *
- * @throws INVALID_CARD_DATA / EMPTY_CARD / CRC16_CHECK_FAILED
- * @returns The mnemonic type description string.
- */
-export declare function validateMnemonicPayload(data: Uint8Array): {
-    type: string;
-};

package/dist/utils.js

@@ -1,124 +0,0 @@
-"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;
-exports.getMnemonicTypeInfo = getMnemonicTypeInfo;
-exports.getMnemonicTypeByEntropyLength = getMnemonicTypeByEntropyLength;
-exports.validateMnemonicPayload = validateMnemonicPayload;
-const constants_1 = require("./constants");
-// ---------------------------------------------------------------------------
-// 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.substring(i, 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);
-}
-// ---------------------------------------------------------------------------
-// Mnemonic type info
-// ---------------------------------------------------------------------------
-/** Mnemonic type info table: [typeId, entropyLength, description] */
-const MNEMONIC_TYPE_TABLE = [
-    [constants_1.MNEMONIC_TYPE_12, 16, '12 words (128-bit)'],
-    [constants_1.MNEMONIC_TYPE_15, 20, '15 words (160-bit)'],
-    [constants_1.MNEMONIC_TYPE_18, 24, '18 words (192-bit)'],
-    [constants_1.MNEMONIC_TYPE_21, 28, '21 words (224-bit)'],
-    [constants_1.MNEMONIC_TYPE_24, 32, '24 words (256-bit)'],
-];
-/**
- * Get entropy length and description for a mnemonic type ID.
- * @throws INVALID_CARD_DATA if the type ID is unknown.
- */
-function getMnemonicTypeInfo(typeId) {
-    const entry = MNEMONIC_TYPE_TABLE.find(([id]) => id === typeId);
-    if (!entry)
-        throw new Error('INVALID_CARD_DATA');
-    return { entropyLength: entry[1], description: entry[2] };
-}
-/**
- * Get type ID and description for a given entropy byte length.
- * @throws UNSUPPORTED_MNEMONIC_LENGTH if the length is not recognized.
- */
-function getMnemonicTypeByEntropyLength(entropyLength) {
-    const entry = MNEMONIC_TYPE_TABLE.find(([, len]) => len === entropyLength);
-    if (!entry)
-        throw new Error('UNSUPPORTED_MNEMONIC_LENGTH');
-    return { typeId: entry[0], description: entry[2] };
-}
-// ---------------------------------------------------------------------------
-// Mnemonic payload validation
-// ---------------------------------------------------------------------------
-/**
- * Validate whether raw card data contains a valid mnemonic payload.
- * Checks type byte, length, and CRC16 — does NOT decode the mnemonic.
- *
- * @throws INVALID_CARD_DATA / EMPTY_CARD / CRC16_CHECK_FAILED
- * @returns The mnemonic type description string.
- */
-function validateMnemonicPayload(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 } = 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 = extractCRC16(data.slice(1 + entropyLength, expectedTotal));
-    const calcCRC = calculateCRC16(dataBlock);
-    if (storedCRC !== calcCRC)
-        throw new Error('CRC16_CHECK_FAILED');
-    return { type: description };
-}

package/dist/writer.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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 { NfcStatusCode, type NfcResult } from './types';
-import { isNfcOperationLocked, releaseNfcOperationLock } from './nfc-core';
-export { NfcStatusCode, type NfcResult, isNfcOperationLocked, releaseNfcOperationLock };
-/**
- * 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.
- */
-export declare function initializeCard(mnemonic: string, newPassword: string, defaultPassword: string, onCardIdentified?: () => void): Promise<NfcResult>;
-/**
- * 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.
- */
-export declare function updateCard(oldPassword: string, newPassword: string, newMnemonic: string, onCardIdentified?: () => void, options?: {
-    precheckExistingMnemonic?: boolean;
-}): 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, onCardIdentified?: () => void): Promise<NfcResult>;
-/**
- * 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.
- */
-export declare function resetCard(password: string | undefined, newPassword: string, onCardIdentified?: () => void): Promise<NfcResult>;