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

package/dist/index.js

@@ -1,50 +1,1450 @@
 "use strict";
-/**
- * @ukeyfe/react-native-nfc-litecard
- *
- * NFC read/write library for MIFARE Ultralight AES (LiteCard mnemonic storage).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PIN_RETRY_COUNT = exports.clearNfcOperationCancelledByCleanup = exports.getNfcOperationCancelledByCleanupTimestamp = exports.consumeNfcOperationCancelledByCleanup = exports.markNfcOperationCancelledByCleanup = exports.releaseNfcOperationLock = exports.isNfcOperationLocked = exports.resetCard = exports.writeUserNickname = exports.updatePassword = exports.updateCard = exports.initializeCard = exports.readOriginality = exports.getCardVersion = exports.cardInfoToJson = exports.resetRetryCountTo10 = exports.readMnemonicRetryCount = exports.readUserNickname = exports.readMnemonic = exports.checkCard = exports.nfcResultRetryCountExhausted = exports.NfcStatusCode = void 0;
-// ---------------------------------------------------------------------------
-// Unified types & constants (consumers can use a single NfcStatusCode)
-// ---------------------------------------------------------------------------
-var types_1 = require("./types");
-Object.defineProperty(exports, "NfcStatusCode", { enumerable: true, get: function () { return types_1.NfcStatusCode; } });
-Object.defineProperty(exports, "nfcResultRetryCountExhausted", { enumerable: true, get: function () { return types_1.nfcResultRetryCountExhausted; } });
-// ---------------------------------------------------------------------------
-// Reader API
-// ---------------------------------------------------------------------------
-var reader_1 = require("./reader");
-Object.defineProperty(exports, "checkCard", { enumerable: true, get: function () { return reader_1.checkCard; } });
-Object.defineProperty(exports, "readMnemonic", { enumerable: true, get: function () { return reader_1.readMnemonic; } });
-Object.defineProperty(exports, "readUserNickname", { enumerable: true, get: function () { return reader_1.readUserNickname; } });
-Object.defineProperty(exports, "readMnemonicRetryCount", { enumerable: true, get: function () { return reader_1.readMnemonicRetryCount; } });
-Object.defineProperty(exports, "resetRetryCountTo10", { enumerable: true, get: function () { return reader_1.resetRetryCountTo10; } });
-Object.defineProperty(exports, "cardInfoToJson", { enumerable: true, get: function () { return reader_1.cardInfoToJson; } });
-Object.defineProperty(exports, "getCardVersion", { enumerable: true, get: function () { return reader_1.getCardVersion; } });
-Object.defineProperty(exports, "readOriginality", { enumerable: true, get: function () { return reader_1.readOriginality; } });
-// ---------------------------------------------------------------------------
-// Writer API
-// ---------------------------------------------------------------------------
-var writer_1 = require("./writer");
-Object.defineProperty(exports, "initializeCard", { enumerable: true, get: function () { return writer_1.initializeCard; } });
-Object.defineProperty(exports, "updateCard", { enumerable: true, get: function () { return writer_1.updateCard; } });
-Object.defineProperty(exports, "updatePassword", { enumerable: true, get: function () { return writer_1.updatePassword; } });
-Object.defineProperty(exports, "writeUserNickname", { enumerable: true, get: function () { return writer_1.writeUserNickname; } });
-Object.defineProperty(exports, "resetCard", { enumerable: true, get: function () { return writer_1.resetCard; } });
-// ---------------------------------------------------------------------------
-// NFC lock & cleanup helpers (for app-level lifecycle management)
-// ---------------------------------------------------------------------------
-var 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; } });
-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; } });
-// ---------------------------------------------------------------------------
-// Constants that apps may need
-// ---------------------------------------------------------------------------
-var constants_1 = require("./constants");
-Object.defineProperty(exports, "DEFAULT_PIN_RETRY_COUNT", { enumerable: true, get: function () { return constants_1.DEFAULT_PIN_RETRY_COUNT; } });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_PIN_RETRY_COUNT: () => DEFAULT_PIN_RETRY_COUNT,
+  NfcStatusCode: () => NfcStatusCode,
+  cardInfoToJson: () => cardInfoToJson,
+  checkCard: () => checkCard,
+  clearNfcOperationCancelledByCleanup: () => clearNfcOperationCancelledByCleanup,
+  consumeNfcOperationCancelledByCleanup: () => consumeNfcOperationCancelledByCleanup,
+  getCardVersion: () => getCardVersion,
+  getNfcOperationCancelledByCleanupTimestamp: () => getNfcOperationCancelledByCleanupTimestamp,
+  initializeCard: () => initializeCard,
+  isNfcOperationLocked: () => isNfcOperationLocked,
+  markNfcOperationCancelledByCleanup: () => markNfcOperationCancelledByCleanup,
+  nfcResultRetryCountExhausted: () => nfcResultRetryCountExhausted,
+  readMnemonic: () => readMnemonic,
+  readMnemonicRetryCount: () => readMnemonicRetryCount,
+  readOriginality: () => readOriginality,
+  readUserNickname: () => readUserNickname,
+  releaseNfcOperationLock: () => releaseNfcOperationLock,
+  resetCard: () => resetCard,
+  resetRetryCountTo10: () => resetRetryCountTo10,
+  updateCard: () => updateCard,
+  updatePassword: () => updatePassword,
+  writeUserNickname: () => writeUserNickname
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var import_react_native = require("react-native");
+var 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,
+  /** CMAC verification failed – response integrity compromised */
+  CMAC_VERIFY_FAILED: 40016
+};
+function nfcResultRetryCountExhausted() {
+  return {
+    code: NfcStatusCode.RETRY_COUNT_EXHAUSTED,
+    success: false,
+    data: { retryCount: 0 }
+  };
+}
+function errorToCode(error) {
+  const msg = (typeof error === "string" ? error : error?.message || "").trim();
+  if (import_react_native.Platform.OS === "ios") {
+    if (error && typeof error === "object" && (error.name === "UserCancel" || error.constructor?.name === "UserCancel")) {
+      return NfcStatusCode.NFC_USER_CANCELED;
+    }
+    if (!msg || msg.includes("User Canceled") || msg.includes("Unknown empty error")) {
+      return NfcStatusCode.NFC_USER_CANCELED;
+    }
+  }
+  if (msg.includes("NFC_USER_CANCELED_SIGNAL")) return NfcStatusCode.NFC_USER_CANCELED;
+  const keywords = [
+    ["CMAC_VERIFY_FAILED", NfcStatusCode.CMAC_VERIFY_FAILED],
+    ["RETRY_COUNT_EXHAUSTED", NfcStatusCode.RETRY_COUNT_EXHAUSTED],
+    ["AUTH_WRONG_PASSWORD", NfcStatusCode.AUTH_WRONG_PASSWORD],
+    ["AUTH_INVALID_RESPONSE", NfcStatusCode.AUTH_INVALID_RESPONSE],
+    ["AUTH_VERIFY_FAILED", NfcStatusCode.AUTH_VERIFY_FAILED],
+    ["READ_FAILED", NfcStatusCode.READ_FAILED],
+    ["WRITE_FAILED", NfcStatusCode.WRITE_FAILED],
+    ["CRC16_CHECK_FAILED", NfcStatusCode.CRC16_CHECK_FAILED],
+    ["EMPTY_CARD", NfcStatusCode.CHECK_EMPTY],
+    ["INVALID_CARD_DATA", NfcStatusCode.INVALID_CARD_DATA],
+    ["INVALID_MNEMONIC", NfcStatusCode.INVALID_MNEMONIC],
+    ["UNSUPPORTED_MNEMONIC_LENGTH", NfcStatusCode.UNSUPPORTED_MNEMONIC_LENGTH],
+    ["NFC_LOCK_TIMEOUT", NfcStatusCode.NFC_LOCK_TIMEOUT],
+    ["NFC_CONNECT_FAILED", NfcStatusCode.NFC_CONNECT_FAILED],
+    ["connection failed", NfcStatusCode.NFC_CONNECT_FAILED],
+    ["transceive fail", NfcStatusCode.NFC_CONNECT_FAILED]
+  ];
+  for (const [keyword, code] of keywords) {
+    if (msg.includes(keyword)) return code;
+  }
+  return NfcStatusCode.UNKNOWN_ERROR;
+}
+
+// src/reader.ts
+var bip39 = __toESM(require("bip39"));
+
+// src/constants.ts
+var CMD_READ = 48;
+var CMD_WRITE = 162;
+var CMD_FAST_READ = 58;
+var CMD_AUTH_PART1 = 26;
+var CMD_AUTH_PART2 = 175;
+var CMD_GET_VERSION = 96;
+var CMD_READ_SIG = 60;
+var KEY_NO_DATA_PROT = 0;
+var PAGE_SIZE = 4;
+var USER_PAGE_START = 8;
+var USER_PAGE_END = 39;
+var USER_CARD_INFO_PAGE_START = 4;
+var USER_CARD_INFO_PAGE_END = 7;
+var PAGE_CFG0 = 41;
+var PAGE_CFG1 = 42;
+var PAGE_AES_KEY0_START = 48;
+var USER_MEMORY_SIZE = (USER_PAGE_END - USER_PAGE_START + 1) * PAGE_SIZE;
+var USER_CARD_INFO_SIZE = (USER_CARD_INFO_PAGE_END - USER_CARD_INFO_PAGE_START + 1) * PAGE_SIZE;
+var MNEMONIC_TYPE_12 = 1;
+var MNEMONIC_TYPE_15 = 2;
+var MNEMONIC_TYPE_18 = 3;
+var MNEMONIC_TYPE_21 = 4;
+var MNEMONIC_TYPE_24 = 5;
+var MNEMONIC_PAGE_END = USER_PAGE_END - 3;
+var MNEMONIC_MEMORY_SIZE = (MNEMONIC_PAGE_END - USER_PAGE_START + 1) * PAGE_SIZE;
+var USER_NICKNAME_PAGE_START = USER_PAGE_END - 2;
+var USER_NICKNAME_PAGE_END = USER_PAGE_END;
+var USER_NICKNAME_MAX_LENGTH = 12;
+var RETRY_COUNTER_PAGE = USER_PAGE_START - 1;
+var RETRY_COUNTER_OFFSET = PAGE_SIZE - 1;
+var DEFAULT_PIN_RETRY_COUNT = 10;
+var SEC_MSG_ACT_MASK = 2;
+var DELAY = {
+  /** Delay after requestNfcTech on Android */
+  ANDROID_POST_TECH: 300,
+  /** Delay after releaseNfcTech (normal) */
+  IOS_POST_RELEASE: 100,
+  ANDROID_POST_RELEASE: 800,
+  /** Delay after releaseNfcTech (forced, e.g. after timeout) */
+  IOS_POST_RELEASE_FORCED: 300,
+  ANDROID_POST_RELEASE_FORCED: 1e3,
+  /** Delay between page writes on iOS */
+  IOS_PAGE_WRITE: 20,
+  /** Delay between AES key page writes on iOS */
+  IOS_KEY_WRITE: 10,
+  /** Delay between nickname page writes on iOS */
+  IOS_NICKNAME_WRITE: 100,
+  /** Delay between config operations on iOS */
+  IOS_CONFIG: 80,
+  /** Keep-alive frequency (every N pages) during writes */
+  KEEPALIVE_FREQ: 4
+};
+
+// src/utils.ts
+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;
+}
+function calculateCRC16(data) {
+  let crc = 65535;
+  for (let i = 0; i < data.length; i++) {
+    crc ^= data[i];
+    for (let j = 0; j < 8; j++) {
+      if ((crc & 1) !== 0) {
+        crc = crc >> 1 ^ 40961;
+      } else {
+        crc = crc >> 1;
+      }
+    }
+  }
+  return crc & 65535;
+}
+function crc16ToBytes(crc16) {
+  return new Uint8Array([crc16 & 255, crc16 >> 8 & 255]);
+}
+function extractCRC16(data) {
+  if (data.length < 2) {
+    throw new Error("INVALID_CARD_DATA");
+  }
+  return data[data.length - 2] | data[data.length - 1] << 8;
+}
+var MNEMONIC_TYPE_TABLE = [
+  [MNEMONIC_TYPE_12, 16, "12 words (128-bit)"],
+  [MNEMONIC_TYPE_15, 20, "15 words (160-bit)"],
+  [MNEMONIC_TYPE_18, 24, "18 words (192-bit)"],
+  [MNEMONIC_TYPE_21, 28, "21 words (224-bit)"],
+  [MNEMONIC_TYPE_24, 32, "24 words (256-bit)"]
+];
+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] };
+}
+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] };
+}
+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 };
+}
+
+// src/crypto.ts
+var import_aes_js = __toESM(require("aes-js"));
+var import_js_sha256 = require("js-sha256");
+function passwordToAesKey(password) {
+  const safePassword = password || "";
+  const hashBytes = import_js_sha256.sha256.arrayBuffer(String(safePassword));
+  return new Uint8Array(hashBytes).slice(0, 16);
+}
+function aesDecrypt(key, data, iv) {
+  const aesCbc = new import_aes_js.default.ModeOfOperation.cbc(Array.from(key), Array.from(iv));
+  return new Uint8Array(aesCbc.decrypt(Array.from(data)));
+}
+function aesEncrypt(key, data, iv) {
+  const aesCbc = new import_aes_js.default.ModeOfOperation.cbc(Array.from(key), Array.from(iv));
+  return new Uint8Array(aesCbc.encrypt(Array.from(data)));
+}
+function rotateLeft8(data) {
+  const result = new Uint8Array(data.length);
+  for (let i = 0; i < data.length - 1; i++) {
+    result[i] = data[i + 1];
+  }
+  result[data.length - 1] = data[0];
+  return result;
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function aesEcbEncrypt(key, data) {
+  const aesEcb = new import_aes_js.default.ModeOfOperation.ecb(Array.from(key));
+  return new Uint8Array(aesEcb.encrypt(Array.from(data)));
+}
+var CONST_RB = 135;
+function shiftLeft1(data) {
+  const result = new Uint8Array(16);
+  let carry = 0;
+  for (let i = 15; i >= 0; i--) {
+    const shifted = data[i] << 1 | carry;
+    result[i] = shifted & 255;
+    carry = data[i] & 128 ? 1 : 0;
+  }
+  return result;
+}
+function xor16(a, b) {
+  const result = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) {
+    result[i] = a[i] ^ b[i];
+  }
+  return result;
+}
+function generateCmacSubkeys(key) {
+  const zero = new Uint8Array(16);
+  const L = aesEcbEncrypt(key, zero);
+  let k1 = shiftLeft1(L);
+  if (L[0] & 128) {
+    k1[15] ^= CONST_RB;
+  }
+  let k2 = shiftLeft1(k1);
+  if (k1[0] & 128) {
+    k2[15] ^= CONST_RB;
+  }
+  return { k1, k2 };
+}
+function aesCmac(key, message) {
+  const { k1, k2 } = generateCmacSubkeys(key);
+  const n = message.length === 0 ? 1 : Math.ceil(message.length / 16);
+  const lastBlockComplete = message.length > 0 && message.length % 16 === 0;
+  const lastBlock = new Uint8Array(16);
+  if (lastBlockComplete) {
+    const offset = (n - 1) * 16;
+    for (let i = 0; i < 16; i++) {
+      lastBlock[i] = message[offset + i] ^ k1[i];
+    }
+  } else {
+    const offset = (n - 1) * 16;
+    const remaining = message.length - offset;
+    for (let i = 0; i < 16; i++) {
+      if (i < remaining) {
+        lastBlock[i] = message[offset + i];
+      } else if (i === remaining) {
+        lastBlock[i] = 128;
+      } else {
+        lastBlock[i] = 0;
+      }
+    }
+    for (let i = 0; i < 16; i++) {
+      lastBlock[i] ^= k2[i];
+    }
+  }
+  const iv0 = new Uint8Array(16);
+  let x = iv0;
+  for (let i = 0; i < n - 1; i++) {
+    const block = new Uint8Array(message.slice(i * 16, (i + 1) * 16));
+    const y2 = xor16(x, block);
+    x = aesEcbEncrypt(key, y2);
+  }
+  const y = xor16(x, lastBlock);
+  return aesEcbEncrypt(key, y);
+}
+function deriveSessionKey(authKey, rndA, rndB) {
+  const sv2 = new Uint8Array(32);
+  sv2[0] = 90;
+  sv2[1] = 165;
+  sv2[2] = 0;
+  sv2[3] = 1;
+  sv2[4] = 0;
+  sv2[5] = 128;
+  sv2[6] = rndA[0];
+  sv2[7] = rndA[1];
+  for (let i = 0; i < 6; i++) {
+    sv2[8 + i] = rndA[2 + i] ^ rndB[i];
+  }
+  for (let i = 0; i < 10; i++) {
+    sv2[14 + i] = rndB[6 + i];
+  }
+  for (let i = 0; i < 8; i++) {
+    sv2[24 + i] = rndA[8 + i];
+  }
+  return aesCmac(authKey, sv2);
+}
+function generateRandom16() {
+  if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.getRandomValues !== "function") {
+    throw new Error(
+      "[nfc-litecard] crypto.getRandomValues is not available. Please add the react-native-get-random-values polyfill or use Hermes >= 0.72."
+    );
+  }
+  try {
+    const arr = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(arr);
+    return arr;
+  } catch (e) {
+    throw e;
+  }
+}
+
+// src/nfc-core.ts
+var import_react_native_nfc_manager = __toESM(require("react-native-nfc-manager"));
+var import_react_native2 = require("react-native");
+var nfcOperationLock = false;
+async function acquireNfcLock() {
+  const maxWait = 1e4;
+  const interval = 100;
+  let waited = 0;
+  while (nfcOperationLock) {
+    if (waited >= maxWait) throw new Error("NFC_LOCK_TIMEOUT");
+    await new Promise((r) => setTimeout(r, interval));
+    waited += interval;
+  }
+  nfcOperationLock = true;
+  clearNfcOperationCancelledByCleanup();
+}
+function releaseNfcLock() {
+  nfcOperationLock = false;
+}
+function isNfcOperationLocked() {
+  return nfcOperationLock;
+}
+function releaseNfcOperationLock() {
+  releaseNfcLock();
+}
+var nfcCancelledByCleanup = false;
+var nfcCancelledByCleanupTimestamp = 0;
+function markNfcOperationCancelledByCleanup() {
+  nfcCancelledByCleanup = true;
+  nfcCancelledByCleanupTimestamp = Date.now();
+}
+function consumeNfcOperationCancelledByCleanup() {
+  const cancelled = nfcCancelledByCleanup;
+  nfcCancelledByCleanup = false;
+  nfcCancelledByCleanupTimestamp = 0;
+  return cancelled;
+}
+function getNfcOperationCancelledByCleanupTimestamp() {
+  return nfcCancelledByCleanupTimestamp;
+}
+function clearNfcOperationCancelledByCleanup() {
+  nfcCancelledByCleanup = false;
+  nfcCancelledByCleanupTimestamp = 0;
+}
+var cmacSessionKey = null;
+var cmacCmdCtr = 0;
+function clearCmacSession() {
+  cmacSessionKey = null;
+  cmacCmdCtr = 0;
+}
+function computeCommandCmac(sessionKey, cmdCtr, command) {
+  const ctrLo = cmdCtr & 255;
+  const ctrHi = cmdCtr >> 8 & 255;
+  const input = new Uint8Array(2 + command.length);
+  input[0] = ctrLo;
+  input[1] = ctrHi;
+  input.set(command, 2);
+  const mac = aesCmac(sessionKey, input);
+  return truncateCmac(mac);
+}
+function truncateCmac(mac) {
+  return new Uint8Array([mac[1], mac[3], mac[5], mac[7], mac[9], mac[11], mac[13], mac[15]]);
+}
+function computeResponseCmac(sessionKey, cmdCtr, responseData) {
+  const ctrLo = cmdCtr & 255;
+  const ctrHi = cmdCtr >> 8 & 255;
+  const input = new Uint8Array(2 + responseData.length);
+  input[0] = ctrLo;
+  input[1] = ctrHi;
+  input.set(responseData, 2);
+  const mac = aesCmac(sessionKey, input);
+  return truncateCmac(mac);
+}
+async function transceive(command, _timeoutMs = 2e3, retryCount = 0) {
+  let cmdToSend = command;
+  const cmdHex = command.map((b) => b.toString(16).padStart(2, "0")).join(" ");
+  if (cmacSessionKey) {
+    const mac = computeCommandCmac(cmacSessionKey, cmacCmdCtr, command);
+    cmdToSend = [...command, ...Array.from(mac)];
+    const macHex = Array.from(mac).map((b) => b.toString(16).padStart(2, "0")).join(" ");
+  } else {
+  }
+  try {
+    const result = import_react_native2.Platform.OS === "ios" ? await import_react_native_nfc_manager.default.sendMifareCommandIOS(cmdToSend) : await import_react_native_nfc_manager.default.nfcAHandler.transceive(cmdToSend);
+    const resultHex = result ? result.map((b) => b.toString(16).padStart(2, "0")).join(" ") : "null";
+    if (cmacSessionKey) {
+      cmacCmdCtr++;
+      if (result && result.length >= 8) {
+        const dataLen = result.length - 8;
+        const responseData = result.slice(0, dataLen);
+        const responseMac = result.slice(dataLen);
+        const expectedMac = computeResponseCmac(cmacSessionKey, cmacCmdCtr, responseData);
+        const rMacHex = responseMac.map((b) => b.toString(16).padStart(2, "0")).join(" ");
+        const eMacHex = Array.from(expectedMac).map((b) => b.toString(16).padStart(2, "0")).join(" ");
+        let diff = 0;
+        for (let i = 0; i < 8; i++) {
+          diff |= responseMac[i] ^ expectedMac[i];
+        }
+        if (diff !== 0) {
+          throw new Error("CMAC_VERIFY_FAILED");
+        }
+        cmacCmdCtr++;
+        return responseData;
+      }
+      cmacCmdCtr++;
+      return result;
+    }
+    return result;
+  } catch (error) {
+    const maxRetries = import_react_native2.Platform.OS === "ios" ? 1 : 2;
+    if (retryCount < maxRetries && error?.message !== "CMAC_VERIFY_FAILED") {
+      const wait = 200 * (retryCount + 1);
+      await new Promise((r) => setTimeout(r, wait));
+      return transceive(command, _timeoutMs, retryCount + 1);
+    }
+    throw error;
+  }
+}
+async function requestNfcTech() {
+  await new Promise((r) => setTimeout(r, 100));
+  if (import_react_native2.Platform.OS === "ios") {
+    await import_react_native_nfc_manager.default.requestTechnology(import_react_native_nfc_manager.NfcTech.MifareIOS);
+  } else {
+    await import_react_native_nfc_manager.default.requestTechnology(import_react_native_nfc_manager.NfcTech.NfcA);
+  }
+  if (import_react_native2.Platform.OS === "android") {
+    await new Promise((r) => setTimeout(r, DELAY.ANDROID_POST_TECH));
+  } else {
+    try {
+      await import_react_native_nfc_manager.default.sendMifareCommandIOS([CMD_READ, 0]);
+    } catch (_) {
+    }
+  }
+}
+async function releaseNfcTech(forceLongDelay = false) {
+  clearCmacSession();
+  try {
+    await import_react_native_nfc_manager.default.cancelTechnologyRequest();
+    const delay = import_react_native2.Platform.OS === "ios" ? forceLongDelay ? DELAY.IOS_POST_RELEASE_FORCED : DELAY.IOS_POST_RELEASE : forceLongDelay ? DELAY.ANDROID_POST_RELEASE_FORCED : DELAY.ANDROID_POST_RELEASE;
+    await new Promise((r) => setTimeout(r, delay));
+  } catch (error) {
+  }
+}
+async function authenticate(key) {
+  clearCmacSession();
+  const iv0 = new Uint8Array(16);
+  const response1 = await transceive([CMD_AUTH_PART1, KEY_NO_DATA_PROT]);
+  if (!response1 || response1.length < 17 || response1[0] !== 175) {
+    throw new Error("AUTH_INVALID_RESPONSE");
+  }
+  const ekRndB = new Uint8Array(response1.slice(1, 17));
+  const rndB = aesDecrypt(key, ekRndB, iv0);
+  const rndBRot = rotateLeft8(rndB);
+  const rndA = generateRandom16();
+  const rndAB = new Uint8Array(32);
+  rndAB.set(rndA, 0);
+  rndAB.set(rndBRot, 16);
+  const ekPart1 = aesEncrypt(key, rndAB.slice(0, 16), iv0);
+  const ekPart2 = aesEncrypt(key, rndAB.slice(16, 32), ekPart1);
+  const ekRndAB = new Uint8Array(32);
+  ekRndAB.set(ekPart1, 0);
+  ekRndAB.set(ekPart2, 16);
+  let response2;
+  try {
+    response2 = await transceive([CMD_AUTH_PART2, ...Array.from(ekRndAB)]);
+  } catch (authErr) {
+    throw new Error("AUTH_WRONG_PASSWORD");
+  }
+  if (response2.length < 17 || response2[0] !== 0) {
+    throw new Error("AUTH_WRONG_PASSWORD");
+  }
+  const ekRndARot = new Uint8Array(response2.slice(1, 17));
+  const rndARot = aesDecrypt(key, ekRndARot, iv0);
+  const expectedRndARot = rotateLeft8(rndA);
+  if (!arraysEqual(rndARot, expectedRndARot)) {
+    throw new Error("AUTH_VERIFY_FAILED");
+  }
+  cmacSessionKey = deriveSessionKey(key, rndA, rndB);
+  cmacCmdCtr = 0;
+}
+async function readUserMemory() {
+  const response = await transceive([CMD_FAST_READ, USER_PAGE_START, USER_PAGE_END]);
+  if (!response || response.length < USER_MEMORY_SIZE) throw new Error("READ_FAILED");
+  return new Uint8Array(response.slice(0, USER_MEMORY_SIZE));
+}
+async function decrementRetryCountInSession() {
+  const pageBlock = await transceive([CMD_READ, RETRY_COUNTER_PAGE]);
+  if (!pageBlock || pageBlock.length < PAGE_SIZE) return void 0;
+  const page = pageBlock.slice(0, PAGE_SIZE);
+  const raw = page[RETRY_COUNTER_OFFSET];
+  const current = typeof raw === "number" ? raw & 255 : 0;
+  if (current <= 0) throw new Error("RETRY_COUNT_EXHAUSTED");
+  const next = current - 1;
+  page[RETRY_COUNTER_OFFSET] = next & 255;
+  await transceive([CMD_WRITE, RETRY_COUNTER_PAGE, ...page]);
+  return next;
+}
+async function writeRetryCountInSession(count) {
+  const safeCount = Math.max(0, Math.min(255, count | 0));
+  const pageBlock = await transceive([CMD_READ, RETRY_COUNTER_PAGE]);
+  if (!pageBlock || pageBlock.length < PAGE_SIZE) throw new Error("READ_FAILED");
+  const page = pageBlock.slice(0, PAGE_SIZE);
+  page[RETRY_COUNTER_OFFSET] = safeCount & 255;
+  await transceive([CMD_WRITE, RETRY_COUNTER_PAGE, ...page]);
+}
+
+// src/reader.ts
+async function readUserNicknameInternal() {
+  const response = await transceive([CMD_FAST_READ, USER_NICKNAME_PAGE_START, USER_NICKNAME_PAGE_END]);
+  if (!response || response.length < 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, USER_NICKNAME_MAX_LENGTH));
+  let actualLength = 0;
+  for (let i = 0; i < USER_NICKNAME_MAX_LENGTH; i++) {
+    if (nicknameBytes[i] !== 0) actualLength = i + 1;
+  }
+  if (actualLength === 0) return "";
+  try {
+    return new TextDecoder("utf-8").decode(nicknameBytes.slice(0, actualLength));
+  } catch {
+    let result = "";
+    for (let i = 0; i < actualLength; i++) result += String.fromCharCode(nicknameBytes[i]);
+    return result;
+  }
+}
+function entropyToMnemonic2(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");
+  const entropyBytes = data.slice(1, 1 + entropyLength);
+  const entropyHex = bytesToHex(Array.from(entropyBytes));
+  const rawBytes = bytesToHex(Array.from(dataBlock));
+  const mnemonic = bip39.entropyToMnemonic(entropyHex);
+  return { mnemonic, entropyHex, type: description, rawBytes, crc16: calcCRC };
+}
+function cardInfoToJson(cardInfo, pretty = true) {
+  return pretty ? JSON.stringify(cardInfo.json, null, 2) : JSON.stringify(cardInfo.json);
+}
+async function checkCard(password, onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      if (password) {
+        try {
+          await decrementRetryCountInSession();
+        } catch (error) {
+          const code = errorToCode(error);
+          if (code === NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+            await releaseNfcTech();
+            releaseNfcLock();
+            return nfcResultRetryCountExhausted();
+          }
+        }
+        const aesKey = passwordToAesKey(password);
+        await authenticate(aesKey);
+        try {
+          await writeRetryCountInSession(DEFAULT_PIN_RETRY_COUNT);
+        } catch {
+        }
+        onCardIdentified?.();
+        const data = await readUserMemory();
+        try {
+          const decoded = validateMnemonicPayload(data);
+          await releaseNfcTech();
+          releaseNfcLock();
+          return { code: NfcStatusCode.CHECK_HAS_DATA, success: true, data: { type: decoded.type } };
+        } catch {
+          await releaseNfcTech();
+          releaseNfcLock();
+          return { code: NfcStatusCode.CHECK_EMPTY, success: true };
+        }
+      } else {
+        onCardIdentified?.();
+        let response = null;
+        try {
+          response = await transceive([CMD_READ, USER_PAGE_START]);
+        } catch {
+        }
+        await releaseNfcTech();
+        releaseNfcLock();
+        if (response && response.length >= 4) {
+          let hasData = false;
+          try {
+            getMnemonicTypeInfo(response[0]);
+            hasData = true;
+          } catch {
+          }
+          return { code: hasData ? NfcStatusCode.CHECK_HAS_DATA : NfcStatusCode.CHECK_EMPTY, success: true };
+        }
+        return { code: NfcStatusCode.CHECK_HAS_DATA, success: true };
+      }
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return { code, success: false };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function readMnemonic(password, onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  let retryCountAfterPreDecrement;
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      try {
+        const next = await decrementRetryCountInSession();
+        if (typeof next === "number") retryCountAfterPreDecrement = next;
+      } catch (error) {
+        const code = errorToCode(error);
+        if (code === NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+          await releaseNfcTech();
+          releaseNfcLock();
+          return nfcResultRetryCountExhausted();
+        }
+      }
+      const aesKey = passwordToAesKey(password);
+      await authenticate(aesKey);
+      onCardIdentified?.();
+      const data = await readUserMemory();
+      const mnemonicData = data.slice(0, MNEMONIC_MEMORY_SIZE);
+      if (mnemonicData.every((b) => b === 0)) {
+        await releaseNfcTech();
+        releaseNfcLock();
+        return { code: NfcStatusCode.CHECK_EMPTY, success: false };
+      }
+      const result = entropyToMnemonic2(data);
+      let nickname;
+      try {
+        nickname = await readUserNicknameInternal();
+      } catch {
+      }
+      let finalRetryCount;
+      try {
+        await writeRetryCountInSession(DEFAULT_PIN_RETRY_COUNT);
+        finalRetryCount = DEFAULT_PIN_RETRY_COUNT;
+      } catch {
+      }
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: 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 releaseNfcTech(isTimeout);
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return {
+        code,
+        success: false,
+        data: typeof retryCountAfterPreDecrement === "number" ? { retryCount: retryCountAfterPreDecrement } : void 0
+      };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function readUserNickname(password, onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      if (password) {
+        const aesKey = passwordToAesKey(password);
+        await authenticate(aesKey);
+      }
+      onCardIdentified?.();
+      const nickname = await readUserNicknameInternal();
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.READ_NICKNAME_SUCCESS,
+        success: true,
+        data: { nickname }
+      };
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return { code, success: false };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function readMnemonicRetryCount(onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      onCardIdentified?.();
+      const pageBlock = await transceive([CMD_READ, RETRY_COUNTER_PAGE]);
+      if (!pageBlock || pageBlock.length < PAGE_SIZE) {
+        await releaseNfcTech();
+        releaseNfcLock();
+        return {
+          code: NfcStatusCode.READ_RETRY_COUNT_SUCCESS,
+          success: true,
+          data: { retryCount: 0 }
+        };
+      }
+      const retryCount = typeof pageBlock[RETRY_COUNTER_OFFSET] === "number" ? pageBlock[RETRY_COUNTER_OFFSET] & 255 : 0;
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.READ_RETRY_COUNT_SUCCESS,
+        success: true,
+        data: { retryCount }
+      };
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return { code, success: false };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function resetRetryCountTo10(onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      onCardIdentified?.();
+      await writeRetryCountInSession(DEFAULT_PIN_RETRY_COUNT);
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.READ_RETRY_COUNT_SUCCESS,
+        success: true,
+        data: { retryCount: DEFAULT_PIN_RETRY_COUNT }
+      };
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return { code, success: false };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function getCardVersion(onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      onCardIdentified?.();
+      const response = await transceive([CMD_GET_VERSION]);
+      if (!response || response.length < 8) {
+        throw new Error("READ_FAILED");
+      }
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: 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 releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return { code, success: false };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function readOriginality(onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      onCardIdentified?.();
+      const response = await transceive([CMD_READ_SIG, 0]);
+      if (!response || response.length < 48) {
+        throw new Error("READ_FAILED");
+      }
+      const signatureHex = bytesToHex(response.slice(0, 48));
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.READ_SIG_SUCCESS,
+        success: true,
+        data: { signature: signatureHex }
+      };
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return { code, success: false };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+
+// src/writer.ts
+var import_react_native3 = require("react-native");
+var bip392 = __toESM(require("bip39"));
+async function readPage(page) {
+  return await transceive([CMD_READ, page]);
+}
+async function writePage(page, data) {
+  if (data.length !== 4) throw new Error("INVALID_CARD_DATA");
+  await transceive([CMD_WRITE, page, ...data]);
+}
+async function writeUserMemory(data) {
+  const buffer = new Uint8Array(MNEMONIC_MEMORY_SIZE);
+  buffer.set(data.slice(0, MNEMONIC_MEMORY_SIZE), 0);
+  const totalPages = MNEMONIC_PAGE_END - USER_PAGE_START + 1;
+  for (let i = 0; i < totalPages; i++) {
+    const page = USER_PAGE_START + i;
+    const offset = i * PAGE_SIZE;
+    const pageData = Array.from(buffer.slice(offset, offset + PAGE_SIZE));
+    await writePage(page, pageData);
+  }
+}
+async function writeAesKey(key) {
+  for (let i = 0; i < 4; i++) {
+    const page = 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 (import_react_native3.Platform.OS === "ios" && i < 3) await new Promise((r) => setTimeout(r, DELAY.IOS_KEY_WRITE));
+  }
+}
+async function writeNicknameToCard(nickname) {
+  const safeNickname = nickname || "";
+  const encoder = new TextEncoder();
+  let nicknameBytes = encoder.encode(String(safeNickname));
+  if (nicknameBytes.length > USER_NICKNAME_MAX_LENGTH) {
+    nicknameBytes = nicknameBytes.slice(0, USER_NICKNAME_MAX_LENGTH);
+  }
+  const buffer = new Uint8Array(USER_NICKNAME_MAX_LENGTH);
+  buffer.set(nicknameBytes, 0);
+  const totalPages = USER_NICKNAME_PAGE_END - USER_NICKNAME_PAGE_START + 1;
+  for (let i = 0; i < totalPages; i++) {
+    const page = USER_NICKNAME_PAGE_START + i;
+    const offset = i * PAGE_SIZE;
+    await writePage(page, Array.from(buffer.slice(offset, offset + PAGE_SIZE)));
+    if (import_react_native3.Platform.OS === "ios" && i < totalPages - 1) await new Promise((r) => setTimeout(r, DELAY.IOS_NICKNAME_WRITE));
+  }
+}
+async function configureAuth() {
+  await writePage(PAGE_CFG0, [SEC_MSG_ACT_MASK, 0, 0, USER_PAGE_START]);
+  await writePage(PAGE_CFG1, [128, 0, 0, 0]);
+}
+async function disableAuth() {
+  await writePage(PAGE_CFG0, [SEC_MSG_ACT_MASK, 0, 0, 60]);
+  await writePage(PAGE_CFG1, [0, 0, 0, 0]);
+}
+function mnemonicToEntropyWithCRC(mnemonic) {
+  if (!bip392.validateMnemonic(mnemonic)) throw new Error("INVALID_MNEMONIC");
+  const entropyHex = bip392.mnemonicToEntropy(mnemonic);
+  const entropyBytes = hexToBytes(entropyHex);
+  const { typeId, description: typeStr } = getMnemonicTypeByEntropyLength(entropyBytes.length);
+  const dataBlock = new Uint8Array(1 + entropyBytes.length);
+  dataBlock[0] = typeId;
+  dataBlock.set(entropyBytes, 1);
+  const crc16 = calculateCRC16(dataBlock);
+  const result = new Uint8Array(dataBlock.length + 2);
+  result.set(dataBlock, 0);
+  result.set(crc16ToBytes(crc16), dataBlock.length);
+  return { data: result, type: typeStr, entropyHex, rawBytes: bytesToHex(result), crc16 };
+}
+async function initializeCard(mnemonic, newPassword, defaultPassword, onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  let retryCountAfterPreDecrement;
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      const entropyResult = mnemonicToEntropyWithCRC(mnemonic);
+      try {
+        const n = await decrementRetryCountInSession();
+        if (typeof n === "number") retryCountAfterPreDecrement = n;
+      } catch (error) {
+        const code = errorToCode(error);
+        if (code === NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+          await releaseNfcTech();
+          releaseNfcLock();
+          return nfcResultRetryCountExhausted();
+        }
+      }
+      const oldKey = passwordToAesKey(defaultPassword);
+      await authenticate(oldKey);
+      try {
+        await writeRetryCountInSession(DEFAULT_PIN_RETRY_COUNT);
+        retryCountAfterPreDecrement = DEFAULT_PIN_RETRY_COUNT;
+      } catch {
+      }
+      onCardIdentified?.();
+      await writeUserMemory(entropyResult.data);
+      const newKey = passwordToAesKey(newPassword);
+      await disableAuth();
+      await writeAesKey(newKey);
+      await configureAuth();
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.INIT_SUCCESS,
+        success: true,
+        data: {
+          type: entropyResult.type,
+          entropyHex: entropyResult.entropyHex,
+          rawBytes: entropyResult.rawBytes,
+          crc16: entropyResult.crc16,
+          retryCount: DEFAULT_PIN_RETRY_COUNT
+        }
+      };
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return {
+        code,
+        success: false,
+        data: typeof retryCountAfterPreDecrement === "number" ? { retryCount: retryCountAfterPreDecrement } : void 0
+      };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function updateCard(oldPassword, newPassword, newMnemonic, onCardIdentified, options) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  let retryCountAfterPreDecrement;
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      try {
+        const n = await decrementRetryCountInSession();
+        if (typeof n === "number") retryCountAfterPreDecrement = n;
+      } catch (error) {
+        const code = errorToCode(error);
+        if (code === NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+          await releaseNfcTech();
+          releaseNfcLock();
+          return nfcResultRetryCountExhausted();
+        }
+      }
+      const oldKey = passwordToAesKey(oldPassword);
+      await authenticate(oldKey);
+      try {
+        await writeRetryCountInSession(DEFAULT_PIN_RETRY_COUNT);
+        retryCountAfterPreDecrement = DEFAULT_PIN_RETRY_COUNT;
+      } catch {
+      }
+      onCardIdentified?.();
+      if (options?.precheckExistingMnemonic) {
+        try {
+          const data = await readUserMemory();
+          const decoded = validateMnemonicPayload(data);
+          await releaseNfcTech();
+          releaseNfcLock();
+          return {
+            code: NfcStatusCode.PRECHECK_HAS_BACKUP,
+            success: true,
+            data: { type: decoded.type, retryCount: DEFAULT_PIN_RETRY_COUNT }
+          };
+        } catch (e) {
+          const c = errorToCode(e);
+          if (c === NfcStatusCode.CHECK_EMPTY || c === NfcStatusCode.CRC16_CHECK_FAILED || c === NfcStatusCode.INVALID_CARD_DATA) {
+          } else {
+            await releaseNfcTech();
+            releaseNfcLock();
+            return { code: c, success: false };
+          }
+        }
+      }
+      const entropyResult = mnemonicToEntropyWithCRC(newMnemonic);
+      await writeUserMemory(entropyResult.data);
+      await disableAuth();
+      const newKey = passwordToAesKey(newPassword);
+      const aesKeyHex = bytesToHex(newKey);
+      await writeAesKey(newKey);
+      await configureAuth();
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.WRITE_SUCCESS,
+        success: true,
+        data: {
+          type: entropyResult.type,
+          entropyHex: entropyResult.entropyHex,
+          rawBytes: entropyResult.rawBytes,
+          aesKeyHex,
+          retryCount: DEFAULT_PIN_RETRY_COUNT
+        }
+      };
+    } catch (error) {
+      const isTransceiveErr = error?.message?.includes("transceive fail") || error?.message?.includes("TagLost");
+      await releaseNfcTech(isTransceiveErr);
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return {
+        code,
+        success: false,
+        data: typeof retryCountAfterPreDecrement === "number" ? { retryCount: retryCountAfterPreDecrement } : void 0
+      };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function updatePassword(oldPassword, newPassword, onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  let retryCountAfterPreDecrement;
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      try {
+        const n = await decrementRetryCountInSession();
+        if (typeof n === "number") retryCountAfterPreDecrement = n;
+      } catch (error) {
+        const code = errorToCode(error);
+        if (code === NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+          await releaseNfcTech();
+          releaseNfcLock();
+          return nfcResultRetryCountExhausted();
+        }
+      }
+      const oldKey = passwordToAesKey(oldPassword);
+      await authenticate(oldKey);
+      try {
+        await writeRetryCountInSession(DEFAULT_PIN_RETRY_COUNT);
+        retryCountAfterPreDecrement = DEFAULT_PIN_RETRY_COUNT;
+      } catch {
+      }
+      onCardIdentified?.();
+      await disableAuth();
+      const newKey = passwordToAesKey(newPassword);
+      const aesKeyHex = bytesToHex(newKey);
+      await writeAesKey(newKey);
+      await configureAuth();
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.UPDATE_PASSWORD_SUCCESS,
+        success: true,
+        data: { aesKeyHex, retryCount: DEFAULT_PIN_RETRY_COUNT }
+      };
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return {
+        code,
+        success: false,
+        data: typeof retryCountAfterPreDecrement === "number" ? { retryCount: retryCountAfterPreDecrement } : void 0
+      };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function writeUserNickname(password, nickname, onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      try {
+        await decrementRetryCountInSession();
+      } catch (error) {
+        const code = errorToCode(error);
+        if (code === NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+          await releaseNfcTech();
+          releaseNfcLock();
+          return nfcResultRetryCountExhausted();
+        }
+      }
+      const aesKey = passwordToAesKey(password);
+      await authenticate(aesKey);
+      try {
+        await writeRetryCountInSession(DEFAULT_PIN_RETRY_COUNT);
+      } catch {
+      }
+      onCardIdentified?.();
+      await disableAuth();
+      await writeNicknameToCard(nickname);
+      await configureAuth();
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.WRITE_NICKNAME_SUCCESS,
+        success: true
+      };
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const code = errorToCode(error);
+      return { code, success: false };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+async function resetCard(password, newPassword, onCardIdentified) {
+  try {
+    await acquireNfcLock();
+  } catch {
+    return { code: NfcStatusCode.UNKNOWN_ERROR, success: false };
+  }
+  let retryCountAfterPreDecrement;
+  try {
+    try {
+      await requestNfcTech();
+    } catch {
+      releaseNfcLock();
+      return { code: NfcStatusCode.NFC_CONNECT_FAILED, success: false };
+    }
+    try {
+      if (password) {
+        try {
+          const n = await decrementRetryCountInSession();
+          if (typeof n === "number") retryCountAfterPreDecrement = n;
+        } catch (error) {
+          const code = errorToCode(error);
+          if (code === NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+            await releaseNfcTech();
+            releaseNfcLock();
+            return nfcResultRetryCountExhausted();
+          }
+        }
+        const aesKey = passwordToAesKey(password);
+        try {
+          await authenticate(aesKey);
+          try {
+            await writeRetryCountInSession(DEFAULT_PIN_RETRY_COUNT);
+            retryCountAfterPreDecrement = DEFAULT_PIN_RETRY_COUNT;
+          } catch {
+          }
+        } catch (authError) {
+          const msg = authError?.message || "";
+          if (msg.includes("AUTH_WRONG_PASSWORD") || import_react_native3.Platform.OS === "ios" && (msg.includes("AUTH_INVALID_RESPONSE") || !msg.trim())) {
+            throw new Error("AUTH_WRONG_PASSWORD");
+          }
+          throw authError;
+        }
+        onCardIdentified?.();
+        if (import_react_native3.Platform.OS === "ios") {
+          try {
+            await readPage(USER_PAGE_START);
+          } catch {
+          }
+        }
+      } else {
+        try {
+          await authenticate(passwordToAesKey(newPassword));
+        } catch {
+          throw new Error("AUTH_WRONG_PASSWORD");
+        }
+        onCardIdentified?.();
+      }
+      await writeUserMemory(new Uint8Array(MNEMONIC_MEMORY_SIZE));
+      const resetKey = passwordToAesKey(newPassword);
+      await disableAuth();
+      await writeAesKey(resetKey);
+      await configureAuth();
+      await releaseNfcTech();
+      releaseNfcLock();
+      return {
+        code: NfcStatusCode.RESET_SUCCESS,
+        success: true,
+        data: { retryCount: DEFAULT_PIN_RETRY_COUNT }
+      };
+    } catch (error) {
+      await releaseNfcTech();
+      releaseNfcLock();
+      const rawMsg = error.message || "";
+      const isWriteErr = rawMsg.includes("WRITE_FAILED") || rawMsg.includes("transceive");
+      const code = errorToCode(isWriteErr ? new Error("WRITE_FAILED") : error);
+      return {
+        code,
+        success: false,
+        data: typeof retryCountAfterPreDecrement === "number" ? { retryCount: retryCountAfterPreDecrement } : void 0
+      };
+    }
+  } catch (error) {
+    releaseNfcLock();
+    throw error;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PIN_RETRY_COUNT,
+  NfcStatusCode,
+  cardInfoToJson,
+  checkCard,
+  clearNfcOperationCancelledByCleanup,
+  consumeNfcOperationCancelledByCleanup,
+  getCardVersion,
+  getNfcOperationCancelledByCleanupTimestamp,
+  initializeCard,
+  isNfcOperationLocked,
+  markNfcOperationCancelledByCleanup,
+  nfcResultRetryCountExhausted,
+  readMnemonic,
+  readMnemonicRetryCount,
+  readOriginality,
+  readUserNickname,
+  releaseNfcOperationLock,
+  resetCard,
+  resetRetryCountTo10,
+  updateCard,
+  updatePassword,
+  writeUserNickname
+});