react-native-wallet-keystore 0.1.0

package/lib/module/NativeWalletKeystore.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * Codegen contract.
+ *
+ * Everything crossing the bridge is a plain `string` on purpose: codegen
+ * supports a narrow set of types, and string-literal unions are handled
+ * inconsistently across React Native versions. The typed surface lives in
+ * `keystore.ts`, which narrows these values.
+ */
+
+export default TurboModuleRegistry.getEnforcing('WalletKeystore');
+//# sourceMappingURL=NativeWalletKeystore.js.map

package/lib/module/NativeWalletKeystore.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeWalletKeystore.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;;AAEpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAiCA,eAAeA,mBAAmB,CAACC,YAAY,CAAO,gBAAgB,CAAC","ignoreList":[]}

package/lib/module/errors.js

@@ -0,0 +1,57 @@
+"use strict";
+
+/**
+ * Stable, cross-platform error codes.
+ *
+ * The distinctions are load-bearing: `USER_CANCELED` means re-prompt,
+ * `NOT_ENROLLED` means send the user to Settings, and `KEY_INVALIDATED` means
+ * the secret is gone and recovery must start. Collapsing them makes callers
+ * guess.
+ */
+const CODES = ['NOT_AVAILABLE', 'NOT_ENROLLED', 'USER_CANCELED', 'USER_FALLBACK', 'LOCKOUT', 'LOCKOUT_PERMANENT', 'SYSTEM_CANCEL', 'KEY_NOT_FOUND', 'KEY_ALREADY_EXISTS', 'KEY_INVALIDATED', 'STORAGE_ERROR', 'INVALID_KEY', 'UNKNOWN'];
+const KNOWN_CODES = new Set(CODES);
+export class KeystoreError extends Error {
+  /** The raw native code, kept even when `code` has fallen back to `UNKNOWN`. */
+
+  constructor(code, message, options) {
+    super(message);
+    this.name = 'KeystoreError';
+    this.code = code;
+    this.nativeCode = options?.nativeCode;
+    if (options && 'cause' in options) {
+      // Assigned rather than passed to super() to support pre-ES2022 targets.
+      this.cause = options.cause;
+    }
+
+    // Without this, extending a built-in breaks `instanceof` once compiled to
+    // ES5 — silently, and only for consumers.
+    Object.setPrototypeOf(this, KeystoreError.prototype);
+    const capture = Error.captureStackTrace;
+    if (typeof capture === 'function') {
+      capture(this, KeystoreError);
+    }
+  }
+}
+function isKeystoreErrorCode(value) {
+  return typeof value === 'string' && KNOWN_CODES.has(value);
+}
+
+/**
+ * Normalizes any rejection into a `KeystoreError`.
+ *
+ * React Native surfaces `reject(code, message)` as an `Error` carrying `code`,
+ * but a JS-side failure can produce any shape at all, so everything degrades to
+ * `UNKNOWN` rather than throwing while building the error.
+ */
+export function toKeystoreError(value) {
+  if (value instanceof KeystoreError) {
+    return value;
+  }
+  const raw = value?.code;
+  const message = value?.message ?? 'The keystore operation failed.';
+  return new KeystoreError(isKeystoreErrorCode(raw) ? raw : 'UNKNOWN', typeof message === 'string' ? message : String(message), {
+    nativeCode: typeof raw === 'string' ? raw : undefined,
+    cause: value
+  });
+}
+//# sourceMappingURL=errors.js.map

package/lib/module/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CODES","KNOWN_CODES","Set","KeystoreError","Error","constructor","code","message","options","name","nativeCode","cause","Object","setPrototypeOf","prototype","capture","captureStackTrace","isKeystoreErrorCode","value","has","toKeystoreError","raw","String","undefined"],"sourceRoot":"../../src","sources":["errors.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,KAAK,GAAG,CACZ,eAAe,EACf,cAAc,EACd,eAAe,EACf,eAAe,EACf,SAAS,EACT,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,SAAS,CACD;AAIV,MAAMC,WAAgC,GAAG,IAAIC,GAAG,CAACF,KAAK,CAAC;AAEvD,OAAO,MAAMG,aAAa,SAASC,KAAK,CAAC;EAGvC;;EAGAC,WAAWA,CACTC,IAAuB,EACvBC,OAAe,EACfC,OAAkD,EAClD;IACA,KAAK,CAACD,OAAO,CAAC;IACd,IAAI,CAACE,IAAI,GAAG,eAAe;IAC3B,IAAI,CAACH,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACI,UAAU,GAAGF,OAAO,EAAEE,UAAU;IAErC,IAAIF,OAAO,IAAI,OAAO,IAAIA,OAAO,EAAE;MACjC;MACC,IAAI,CAAyBG,KAAK,GAAGH,OAAO,CAACG,KAAK;IACrD;;IAEA;IACA;IACAC,MAAM,CAACC,cAAc,CAAC,IAAI,EAAEV,aAAa,CAACW,SAAS,CAAC;IAEpD,MAAMC,OAAO,GACXX,KAAK,CAGLY,iBAAiB;IACnB,IAAI,OAAOD,OAAO,KAAK,UAAU,EAAE;MACjCA,OAAO,CAAC,IAAI,EAAEZ,aAAa,CAAC;IAC9B;EACF;AACF;AAEA,SAASc,mBAAmBA,CAACC,KAAc,EAA8B;EACvE,OAAO,OAAOA,KAAK,KAAK,QAAQ,IAAIjB,WAAW,CAACkB,GAAG,CAACD,KAAK,CAAC;AAC5D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,eAAeA,CAACF,KAAc,EAAiB;EAC7D,IAAIA,KAAK,YAAYf,aAAa,EAAE;IAClC,OAAOe,KAAK;EACd;EAEA,MAAMG,GAAG,GAAIH,KAAK,EAA4CZ,IAAI;EAClE,MAAMC,OAAO,GACVW,KAAK,EAA+CX,OAAO,IAC5D,gCAAgC;EAElC,OAAO,IAAIJ,aAAa,CACtBc,mBAAmB,CAACI,GAAG,CAAC,GAAGA,GAAG,GAAG,SAAS,EAC1C,OAAOd,OAAO,KAAK,QAAQ,GAAGA,OAAO,GAAGe,MAAM,CAACf,OAAO,CAAC,EACvD;IACEG,UAAU,EAAE,OAAOW,GAAG,KAAK,QAAQ,GAAGA,GAAG,GAAGE,SAAS;IACrDZ,KAAK,EAAEO;EACT,CACF,CAAC;AACH","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export * from "./keystore.js";
+export { KeystoreError } from "./errors.js";
+
+// The viem adapter is intentionally not re-exported. It ships as the
+// `react-native-wallet-keystore/viem` subpath with viem as an optional peer, so
+// importing the core API never requires viem to be installed.
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["KeystoreError"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,cAAc,eAAY;AAC1B,SAASA,aAAa,QAAgC,aAAU;;AAEhE;AACA;AACA","ignoreList":[]}

package/lib/module/keystore.js

@@ -0,0 +1,220 @@
+"use strict";
+
+import NativeWalletKeystore from "./NativeWalletKeystore.js";
+import { KeystoreError, toKeystoreError } from "./errors.js";
+
+/**
+ * Android reports which biometric *hardware* exists, not which modality is
+ * enrolled, so it returns `'biometric'` when more than one is present.
+ */
+
+/**
+ * Whether the wrapping key is destroyed when biometric enrollment changes.
+ *
+ * Orthogonal to {@link AuthPolicy} on purpose: `'biometricOnly'` must never
+ * imply invalidation, or a user adding a fingerprint silently destroys their
+ * wallet. Opting in is explicit.
+ */
+
+export const DEFAULT_AUTH_POLICY = 'biometricOrPasscode';
+export const DEFAULT_INVALIDATION_POLICY = 'never';
+
+/** Uncompressed SEC1 public key: `0x04` followed by 64 bytes. */
+
+/** 65-byte Ethereum signature: `r || s || v`, with `v` 27 or 28. */
+
+const BIOMETRY_TYPES = new Set(['faceId', 'touchId', 'opticId', 'fingerprint', 'face', 'iris', 'biometric', 'none']);
+const HEX_PATTERN = /^(?:[0-9a-fA-F]{2})+$/;
+const HEX_32_BYTES = /^(?:0x)?[0-9a-fA-F]{64}$/;
+function strip0x(value) {
+  return value.startsWith('0x') || value.startsWith('0X') ? value.slice(2) : value;
+}
+function prefix0x(value) {
+  return value.startsWith('0x') ? value : `0x${value}`;
+}
+function assertKeyId(keyId) {
+  if (typeof keyId !== 'string' || keyId.trim() === '') {
+    throw new KeystoreError('UNKNOWN', 'A non-empty `keyId` is required.');
+  }
+}
+function assertReason(reason, action) {
+  // iOS raises on an empty localizedReason rather than failing gracefully, so
+  // this is checked before the bridge to keep both platforms consistent.
+  if (typeof reason !== 'string' || reason.trim() === '') {
+    throw new KeystoreError('UNKNOWN', `A non-empty \`reason\` is required to ${action}.`);
+  }
+}
+
+/**
+ * Which biometric modality the hardware supports, whether or not anything is
+ * enrolled. Resolves `'none'` when there is no hardware; never rejects.
+ *
+ * Enrollment state comes from {@link authenticate} via `NOT_ENROLLED`.
+ */
+export async function getBiometryType() {
+  const type = await NativeWalletKeystore.getBiometryType();
+  // A native layer newer than this JS could return a modality we don't know.
+  return BIOMETRY_TYPES.has(type) ? type : 'biometric';
+}
+
+/**
+ * Prompts for device-owner authentication.
+ *
+ * A UX gate, not a security boundary — the boolean can be faked by a
+ * compromised bundle. Use {@link signDigest} where it actually matters.
+ *
+ * Never resolves `false`; every failure rejects.
+ *
+ * @throws {KeystoreError}
+ */
+export async function authenticate(reason, policy = DEFAULT_AUTH_POLICY) {
+  try {
+    assertReason(reason, 'authenticate');
+    return await NativeWalletKeystore.authenticate(reason, policy);
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/**
+ * Stores a secret encrypted under a hardware-bound wrapping key.
+ *
+ * @throws {KeystoreError} `KEY_ALREADY_EXISTS` if `keyId` is taken; overwriting
+ *   is always deliberate.
+ */
+export async function storeSecret(keyId, secretHex, options = {}) {
+  try {
+    assertKeyId(keyId);
+    if (typeof secretHex !== 'string' || !HEX_PATTERN.test(secretHex)) {
+      throw new KeystoreError('UNKNOWN', '`secretHex` must be a non-empty, even-length hex string.');
+    }
+    await NativeWalletKeystore.storeSecret(keyId, secretHex, options.policy ?? DEFAULT_AUTH_POLICY, options.invalidation ?? DEFAULT_INVALIDATION_POLICY);
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/**
+ * Authenticates and returns the stored secret as hex.
+ *
+ * The prompt is raised by the keystore as a precondition of using the wrapping
+ * key, so it cannot be bypassed from JS.
+ *
+ * @throws {KeystoreError} `KEY_NOT_FOUND`, `KEY_INVALIDATED`, or any auth code.
+ */
+export async function getSecret(keyId, reason) {
+  try {
+    assertKeyId(keyId);
+    assertReason(reason, 'read a secret');
+    return await NativeWalletKeystore.getSecret(keyId, reason);
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/** Whether a secret is stored under `keyId`. Does not authenticate. */
+export async function hasSecret(keyId) {
+  try {
+    assertKeyId(keyId);
+    return await NativeWalletKeystore.hasSecret(keyId);
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/** Removes the secret and its wrapping key. Idempotent. */
+export async function deleteSecret(keyId) {
+  try {
+    assertKeyId(keyId);
+    await NativeWalletKeystore.deleteSecret(keyId);
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/**
+ * Generates a secp256k1 keypair in hardware-wrapped storage.
+ *
+ * Entropy comes from the platform CSPRNG, never from JavaScript, and the
+ * private key never crosses the bridge.
+ *
+ * @returns The uncompressed public key.
+ */
+export async function generateKey(keyId, options = {}) {
+  try {
+    assertKeyId(keyId);
+    return prefix0x(await NativeWalletKeystore.generateKey(keyId, options.policy ?? DEFAULT_AUTH_POLICY, options.invalidation ?? DEFAULT_INVALIDATION_POLICY));
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/**
+ * Imports an existing secp256k1 private key.
+ *
+ * @throws {KeystoreError} `INVALID_KEY` unless the key is in [1, n-1]. Keys
+ *   outside that range are rejected rather than clamped.
+ */
+export async function importPrivateKey(keyId, privateKeyHex, options = {}) {
+  try {
+    assertKeyId(keyId);
+    if (typeof privateKeyHex !== 'string' || !HEX_32_BYTES.test(privateKeyHex)) {
+      throw new KeystoreError('INVALID_KEY', 'A private key must be exactly 32 bytes of hex.');
+    }
+
+    // The range check stays native, where the curve order is already at hand.
+    return prefix0x(await NativeWalletKeystore.importPrivateKey(keyId, strip0x(privateKeyHex), options.policy ?? DEFAULT_AUTH_POLICY, options.invalidation ?? DEFAULT_INVALIDATION_POLICY));
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/** The uncompressed public key. Does not authenticate. */
+export async function getPublicKey(keyId) {
+  try {
+    assertKeyId(keyId);
+    return prefix0x(await NativeWalletKeystore.getPublicKey(keyId));
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/**
+ * Authenticates, then signs a 32-byte digest.
+ *
+ * Only a digest crosses the boundary — never a message or a transaction.
+ * Keccak and EIP-191/712/155 encoding stay in JS, which keeps this module
+ * curve-specific but chain-agnostic.
+ *
+ * @returns 65 bytes, `r || s || v`, low-s normalized per EIP-2 with `v` of
+ *   27/28 — byte-identical to viem.
+ */
+export async function signDigest(keyId, digestHex, reason) {
+  try {
+    assertKeyId(keyId);
+    if (typeof digestHex !== 'string' || !HEX_32_BYTES.test(digestHex)) {
+      throw new KeystoreError('INVALID_KEY', 'A digest must be exactly 32 bytes of hex. Hash the message in JS first.');
+    }
+    assertReason(reason, 'sign');
+    return prefix0x(await NativeWalletKeystore.signDigest(keyId, strip0x(digestHex), reason));
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+
+/**
+ * Authenticates, then returns the raw private key.
+ *
+ * For user-initiated backup only. The result lands in the JS heap where it
+ * cannot be zeroed, so prefer {@link signDigest} for everyday use.
+ */
+export async function exportPrivateKey(keyId, reason) {
+  try {
+    assertKeyId(keyId);
+    assertReason(reason, 'export a private key');
+    return prefix0x(await NativeWalletKeystore.exportPrivateKey(keyId, reason));
+  } catch (error) {
+    throw toKeystoreError(error);
+  }
+}
+//# sourceMappingURL=keystore.js.map

package/lib/module/keystore.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeWalletKeystore","KeystoreError","toKeystoreError","DEFAULT_AUTH_POLICY","DEFAULT_INVALIDATION_POLICY","BIOMETRY_TYPES","Set","HEX_PATTERN","HEX_32_BYTES","strip0x","value","startsWith","slice","prefix0x","assertKeyId","keyId","trim","assertReason","reason","action","getBiometryType","type","has","authenticate","policy","error","storeSecret","secretHex","options","test","invalidation","getSecret","hasSecret","deleteSecret","generateKey","importPrivateKey","privateKeyHex","getPublicKey","signDigest","digestHex","exportPrivateKey"],"sourceRoot":"../../src","sources":["keystore.ts"],"mappings":";;AAAA,OAAOA,oBAAoB,MAAM,2BAAwB;AACzD,SAASC,aAAa,EAAEC,eAAe,QAAQ,aAAU;;AAEzD;AACA;AACA;AACA;;AAaA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,OAAO,MAAMC,mBAA+B,GAAG,qBAAqB;AACpE,OAAO,MAAMC,2BAA+C,GAAG,OAAO;;AAEtE;;AAGA;;AAQA,MAAMC,cAAmC,GAAG,IAAIC,GAAG,CAAe,CAChE,QAAQ,EACR,SAAS,EACT,SAAS,EACT,aAAa,EACb,MAAM,EACN,MAAM,EACN,WAAW,EACX,MAAM,CACP,CAAC;AAEF,MAAMC,WAAW,GAAG,uBAAuB;AAC3C,MAAMC,YAAY,GAAG,0BAA0B;AAE/C,SAASC,OAAOA,CAACC,KAAa,EAAU;EACtC,OAAOA,KAAK,CAACC,UAAU,CAAC,IAAI,CAAC,IAAID,KAAK,CAACC,UAAU,CAAC,IAAI,CAAC,GACnDD,KAAK,CAACE,KAAK,CAAC,CAAC,CAAC,GACdF,KAAK;AACX;AAEA,SAASG,QAAQA,CAACH,KAAa,EAAiB;EAC9C,OAAQA,KAAK,CAACC,UAAU,CAAC,IAAI,CAAC,GAAGD,KAAK,GAAG,KAAKA,KAAK,EAAE;AACvD;AAEA,SAASI,WAAWA,CAACC,KAAa,EAAQ;EACxC,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,CAACC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;IACpD,MAAM,IAAIf,aAAa,CAAC,SAAS,EAAE,kCAAkC,CAAC;EACxE;AACF;AAEA,SAASgB,YAAYA,CAACC,MAAc,EAAEC,MAAc,EAAQ;EAC1D;EACA;EACA,IAAI,OAAOD,MAAM,KAAK,QAAQ,IAAIA,MAAM,CAACF,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;IACtD,MAAM,IAAIf,aAAa,CACrB,SAAS,EACT,yCAAyCkB,MAAM,GACjD,CAAC;EACH;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,eAAeA,CAAA,EAA0B;EAC7D,MAAMC,IAAI,GAAG,MAAMrB,oBAAoB,CAACoB,eAAe,CAAC,CAAC;EACzD;EACA,OAAQf,cAAc,CAACiB,GAAG,CAACD,IAAI,CAAC,GAAGA,IAAI,GAAG,WAAW;AACvD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeE,YAAYA,CAChCL,MAAc,EACdM,MAAkB,GAAGrB,mBAAmB,EACtB;EAClB,IAAI;IACFc,YAAY,CAACC,MAAM,EAAE,cAAc,CAAC;IACpC,OAAO,MAAMlB,oBAAoB,CAACuB,YAAY,CAACL,MAAM,EAAEM,MAAM,CAAC;EAChE,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,WAAWA,CAC/BX,KAAa,EACbY,SAAiB,EACjBC,OAAmB,GAAG,CAAC,CAAC,EACT;EACf,IAAI;IACFd,WAAW,CAACC,KAAK,CAAC;IAElB,IAAI,OAAOY,SAAS,KAAK,QAAQ,IAAI,CAACpB,WAAW,CAACsB,IAAI,CAACF,SAAS,CAAC,EAAE;MACjE,MAAM,IAAI1B,aAAa,CACrB,SAAS,EACT,0DACF,CAAC;IACH;IAEA,MAAMD,oBAAoB,CAAC0B,WAAW,CACpCX,KAAK,EACLY,SAAS,EACTC,OAAO,CAACJ,MAAM,IAAIrB,mBAAmB,EACrCyB,OAAO,CAACE,YAAY,IAAI1B,2BAC1B,CAAC;EACH,CAAC,CAAC,OAAOqB,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeM,SAASA,CAC7BhB,KAAa,EACbG,MAAc,EACG;EACjB,IAAI;IACFJ,WAAW,CAACC,KAAK,CAAC;IAClBE,YAAY,CAACC,MAAM,EAAE,eAAe,CAAC;IACrC,OAAO,MAAMlB,oBAAoB,CAAC+B,SAAS,CAAChB,KAAK,EAAEG,MAAM,CAAC;EAC5D,CAAC,CAAC,OAAOO,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA,OAAO,eAAeO,SAASA,CAACjB,KAAa,EAAoB;EAC/D,IAAI;IACFD,WAAW,CAACC,KAAK,CAAC;IAClB,OAAO,MAAMf,oBAAoB,CAACgC,SAAS,CAACjB,KAAK,CAAC;EACpD,CAAC,CAAC,OAAOU,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA,OAAO,eAAeQ,YAAYA,CAAClB,KAAa,EAAiB;EAC/D,IAAI;IACFD,WAAW,CAACC,KAAK,CAAC;IAClB,MAAMf,oBAAoB,CAACiC,YAAY,CAAClB,KAAK,CAAC;EAChD,CAAC,CAAC,OAAOU,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeS,WAAWA,CAC/BnB,KAAa,EACba,OAAmB,GAAG,CAAC,CAAC,EACD;EACvB,IAAI;IACFd,WAAW,CAACC,KAAK,CAAC;IAClB,OAAOF,QAAQ,CACb,MAAMb,oBAAoB,CAACkC,WAAW,CACpCnB,KAAK,EACLa,OAAO,CAACJ,MAAM,IAAIrB,mBAAmB,EACrCyB,OAAO,CAACE,YAAY,IAAI1B,2BAC1B,CACF,CAAC;EACH,CAAC,CAAC,OAAOqB,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeU,gBAAgBA,CACpCpB,KAAa,EACbqB,aAAqB,EACrBR,OAAmB,GAAG,CAAC,CAAC,EACD;EACvB,IAAI;IACFd,WAAW,CAACC,KAAK,CAAC;IAElB,IACE,OAAOqB,aAAa,KAAK,QAAQ,IACjC,CAAC5B,YAAY,CAACqB,IAAI,CAACO,aAAa,CAAC,EACjC;MACA,MAAM,IAAInC,aAAa,CACrB,aAAa,EACb,gDACF,CAAC;IACH;;IAEA;IACA,OAAOY,QAAQ,CACb,MAAMb,oBAAoB,CAACmC,gBAAgB,CACzCpB,KAAK,EACLN,OAAO,CAAC2B,aAAa,CAAC,EACtBR,OAAO,CAACJ,MAAM,IAAIrB,mBAAmB,EACrCyB,OAAO,CAACE,YAAY,IAAI1B,2BAC1B,CACF,CAAC;EACH,CAAC,CAAC,OAAOqB,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA,OAAO,eAAeY,YAAYA,CAACtB,KAAa,EAAyB;EACvE,IAAI;IACFD,WAAW,CAACC,KAAK,CAAC;IAClB,OAAOF,QAAQ,CAAC,MAAMb,oBAAoB,CAACqC,YAAY,CAACtB,KAAK,CAAC,CAAC;EACjE,CAAC,CAAC,OAAOU,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAea,UAAUA,CAC9BvB,KAAa,EACbwB,SAAiB,EACjBrB,MAAc,EACS;EACvB,IAAI;IACFJ,WAAW,CAACC,KAAK,CAAC;IAElB,IAAI,OAAOwB,SAAS,KAAK,QAAQ,IAAI,CAAC/B,YAAY,CAACqB,IAAI,CAACU,SAAS,CAAC,EAAE;MAClE,MAAM,IAAItC,aAAa,CACrB,aAAa,EACb,yEACF,CAAC;IACH;IAEAgB,YAAY,CAACC,MAAM,EAAE,MAAM,CAAC;IAE5B,OAAOL,QAAQ,CACb,MAAMb,oBAAoB,CAACsC,UAAU,CAACvB,KAAK,EAAEN,OAAO,CAAC8B,SAAS,CAAC,EAAErB,MAAM,CACzE,CAAC;EACH,CAAC,CAAC,OAAOO,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAee,gBAAgBA,CACpCzB,KAAa,EACbG,MAAc,EACG;EACjB,IAAI;IACFJ,WAAW,CAACC,KAAK,CAAC;IAClBE,YAAY,CAACC,MAAM,EAAE,sBAAsB,CAAC;IAC5C,OAAOL,QAAQ,CAAC,MAAMb,oBAAoB,CAACwC,gBAAgB,CAACzB,KAAK,EAAEG,MAAM,CAAC,CAAC;EAC7E,CAAC,CAAC,OAAOO,KAAK,EAAE;IACd,MAAMvB,eAAe,CAACuB,KAAK,CAAC;EAC9B;AACF","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/viem.js

@@ -0,0 +1,65 @@
+"use strict";
+
+import { hashMessage, hashTypedData, keccak256, serializeTransaction } from 'viem';
+import { publicKeyToAddress, toAccount } from 'viem/accounts';
+import { getPublicKey, signDigest } from "./keystore.js";
+const DEFAULT_REASON = 'Sign with your wallet key';
+
+/**
+ * Adapts a hardware-wrapped key into a viem {@link LocalAccount}.
+ *
+ * Every path hashes in JS and sends only a 32-byte digest to native, leaving
+ * EIP-191, EIP-712 and transaction serialization to viem.
+ *
+ * ```ts
+ * const account = await toKeystoreAccount('wallet-1');
+ * const client = createWalletClient({ account, chain: mainnet, transport: http() });
+ * await client.sendTransaction({ to: '0x…', value: 1n });
+ * ```
+ *
+ * Each signature raises its own authentication prompt, so batching several will
+ * prompt several times.
+ */
+export async function toKeystoreAccount(keyId, options = {}) {
+  const reason = options.reason ?? DEFAULT_REASON;
+  const publicKey = options.publicKey ?? (await getPublicKey(keyId));
+
+  // Derived here rather than natively: the address is a pure function of the
+  // public key, and keccak has no business in the native layer.
+  const address = publicKeyToAddress(publicKey);
+  const sign = digest => signDigest(keyId, digest, reason);
+  const account = toAccount({
+    address,
+    async sign({
+      hash
+    }) {
+      return sign(hash);
+    },
+    async signMessage({
+      message
+    }) {
+      return sign(hashMessage(message));
+    },
+    async signTypedData(typedData) {
+      return sign(hashTypedData(typedData));
+    },
+    async signTransaction(transaction, args) {
+      const serializer = args?.serializer ?? serializeTransaction;
+
+      // Sign the hash of the unsigned serialization, then re-serialize with the
+      // signature attached; viem's serializer owns the EIP-155 and typed-tx
+      // rules for every transaction type.
+      const unsigned = await serializer(transaction);
+      const signature = await sign(keccak256(unsigned));
+      return await serializer(transaction, {
+        r: `0x${signature.slice(2, 66)}`,
+        s: `0x${signature.slice(66, 130)}`,
+        v: BigInt(parseInt(signature.slice(130, 132), 16))
+      });
+    }
+  });
+
+  // toAccount's return type is a union; this pins it to the local branch.
+  return account;
+}
+//# sourceMappingURL=viem.js.map

package/lib/module/viem.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hashMessage","hashTypedData","keccak256","serializeTransaction","publicKeyToAddress","toAccount","getPublicKey","signDigest","DEFAULT_REASON","toKeystoreAccount","keyId","options","reason","publicKey","address","sign","digest","account","hash","signMessage","message","signTypedData","typedData","signTransaction","transaction","args","serializer","unsigned","signature","r","slice","s","v","BigInt","parseInt"],"sourceRoot":"../../src","sources":["viem.ts"],"mappings":";;AAAA,SACEA,WAAW,EACXC,aAAa,EACbC,SAAS,EACTC,oBAAoB,QAQf,MAAM;AACb,SAASC,kBAAkB,EAAEC,SAAS,QAAQ,eAAe;AAE7D,SAASC,YAAY,EAAEC,UAAU,QAAQ,eAAY;AASrD,MAAMC,cAAc,GAAG,2BAA2B;;AAElD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,iBAAiBA,CACrCC,KAAa,EACbC,OAA+B,GAAG,CAAC,CAAC,EACb;EACvB,MAAMC,MAAM,GAAGD,OAAO,CAACC,MAAM,IAAIJ,cAAc;EAC/C,MAAMK,SAAS,GAAGF,OAAO,CAACE,SAAS,KAAK,MAAMP,YAAY,CAACI,KAAK,CAAC,CAAC;;EAElE;EACA;EACA,MAAMI,OAAO,GAAGV,kBAAkB,CAACS,SAAS,CAAC;EAE7C,MAAME,IAAI,GAAIC,MAAW,IACvBT,UAAU,CAACG,KAAK,EAAEM,MAAM,EAAEJ,MAAM,CAAiB;EAEnD,MAAMK,OAAO,GAAGZ,SAAS,CAAC;IACxBS,OAAO;IAEP,MAAMC,IAAIA,CAAC;MAAEG;IAAoB,CAAC,EAAE;MAClC,OAAOH,IAAI,CAACG,IAAI,CAAC;IACnB,CAAC;IAED,MAAMC,WAAWA,CAAC;MAAEC;IAAsC,CAAC,EAAE;MAC3D,OAAOL,IAAI,CAACf,WAAW,CAACoB,OAAO,CAAC,CAAC;IACnC,CAAC;IAED,MAAMC,aAAaA,CAGjBC,SAAsD,EAAE;MACxD,OAAOP,IAAI,CAACd,aAAa,CAACqB,SAAgC,CAAC,CAAC;IAC9D,CAAC;IAED,MAAMC,eAAeA,CACnBC,WAAoC,EACpCC,IAGC,EACD;MACA,MAAMC,UAAU,GAAGD,IAAI,EAAEC,UAAU,IAAIvB,oBAAoB;;MAE3D;MACA;MACA;MACA,MAAMwB,QAAQ,GAAI,MAAMD,UAAU,CAACF,WAAW,CAAS;MACvD,MAAMI,SAAS,GAAG,MAAMb,IAAI,CAACb,SAAS,CAACyB,QAAQ,CAAC,CAAC;MAEjD,OAAQ,MAAMD,UAAU,CAACF,WAAW,EAAE;QACpCK,CAAC,EAAE,KAAKD,SAAS,CAACE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAS;QACvCC,CAAC,EAAE,KAAKH,SAAS,CAACE,KAAK,CAAC,EAAE,EAAE,GAAG,CAAC,EAAS;QACzCE,CAAC,EAAEC,MAAM,CAACC,QAAQ,CAACN,SAAS,CAACE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC;MACnD,CAAC,CAAC;IACJ;EACF,CAAC,CAAC;;EAEF;EACA,OAAOb,OAAO;AAChB","ignoreList":[]}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NativeWalletKeystore.d.ts

@@ -0,0 +1,26 @@
+import { type TurboModule } from 'react-native';
+/**
+ * Codegen contract.
+ *
+ * Everything crossing the bridge is a plain `string` on purpose: codegen
+ * supports a narrow set of types, and string-literal unions are handled
+ * inconsistently across React Native versions. The typed surface lives in
+ * `keystore.ts`, which narrows these values.
+ */
+export interface Spec extends TurboModule {
+    getBiometryType(): Promise<string>;
+    authenticate(reason: string, policy: string): Promise<boolean>;
+    storeSecret(keyId: string, secretHex: string, policy: string, invalidation: string): Promise<void>;
+    getSecret(keyId: string, reason: string): Promise<string>;
+    hasSecret(keyId: string): Promise<boolean>;
+    deleteSecret(keyId: string): Promise<void>;
+    generateKey(keyId: string, policy: string, invalidation: string): Promise<string>;
+    importPrivateKey(keyId: string, privateKeyHex: string, policy: string, invalidation: string): Promise<string>;
+    getPublicKey(keyId: string): Promise<string>;
+    /** Returns 65 bytes of hex: `r || s || v`, low-s normalized, `v` of 27/28. */
+    signDigest(keyId: string, digestHex: string, reason: string): Promise<string>;
+    exportPrivateKey(keyId: string, reason: string): Promise<string>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeWalletKeystore.d.ts.map

package/lib/typescript/src/NativeWalletKeystore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeWalletKeystore.d.ts","sourceRoot":"","sources":["../../../src/NativeWalletKeystore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE;;;;;;;GAOG;AACH,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACnC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE/D,WAAW,CACT,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1D,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3C,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3C,WAAW,CACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,gBAAgB,CACd,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE7C,8EAA8E;IAC9E,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9E,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAClE;;AAED,wBAAwE"}

package/lib/typescript/src/errors.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Stable, cross-platform error codes.
+ *
+ * The distinctions are load-bearing: `USER_CANCELED` means re-prompt,
+ * `NOT_ENROLLED` means send the user to Settings, and `KEY_INVALIDATED` means
+ * the secret is gone and recovery must start. Collapsing them makes callers
+ * guess.
+ */
+declare const CODES: readonly ["NOT_AVAILABLE", "NOT_ENROLLED", "USER_CANCELED", "USER_FALLBACK", "LOCKOUT", "LOCKOUT_PERMANENT", "SYSTEM_CANCEL", "KEY_NOT_FOUND", "KEY_ALREADY_EXISTS", "KEY_INVALIDATED", "STORAGE_ERROR", "INVALID_KEY", "UNKNOWN"];
+export type KeystoreErrorCode = (typeof CODES)[number];
+export declare class KeystoreError extends Error {
+    readonly code: KeystoreErrorCode;
+    /** The raw native code, kept even when `code` has fallen back to `UNKNOWN`. */
+    readonly nativeCode?: string;
+    constructor(code: KeystoreErrorCode, message: string, options?: {
+        nativeCode?: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Normalizes any rejection into a `KeystoreError`.
+ *
+ * React Native surfaces `reject(code, message)` as an `Error` carrying `code`,
+ * but a JS-side failure can produce any shape at all, so everything degrades to
+ * `UNKNOWN` rather than throwing while building the error.
+ */
+export declare function toKeystoreError(value: unknown): KeystoreError;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/lib/typescript/src/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,QAAA,MAAM,KAAK,oOAcD,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;AAIvD,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAEjC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAG3B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAyBrD;AAMD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAkB7D"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './keystore.js';
+export { KeystoreError, type KeystoreErrorCode } from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,cAAc,eAAY,CAAC;AAC3B,OAAO,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAU,CAAC"}

package/lib/typescript/src/keystore.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Android reports which biometric *hardware* exists, not which modality is
+ * enrolled, so it returns `'biometric'` when more than one is present.
+ */
+export type BiometryType = 'faceId' | 'touchId' | 'opticId' | 'fingerprint' | 'face' | 'iris' | 'biometric' | 'none';
+export type AuthPolicy = 'biometricOnly' | 'biometricOrPasscode';
+/**
+ * Whether the wrapping key is destroyed when biometric enrollment changes.
+ *
+ * Orthogonal to {@link AuthPolicy} on purpose: `'biometricOnly'` must never
+ * imply invalidation, or a user adding a fingerprint silently destroys their
+ * wallet. Opting in is explicit.
+ */
+export type InvalidationPolicy = 'onEnrollmentChange' | 'never';
+export declare const DEFAULT_AUTH_POLICY: AuthPolicy;
+export declare const DEFAULT_INVALIDATION_POLICY: InvalidationPolicy;
+/** Uncompressed SEC1 public key: `0x04` followed by 64 bytes. */
+export type PublicKeyHex = `0x${string}`;
+/** 65-byte Ethereum signature: `r || s || v`, with `v` 27 or 28. */
+export type SignatureHex = `0x${string}`;
+type KeyOptions = {
+    policy?: AuthPolicy;
+    invalidation?: InvalidationPolicy;
+};
+/**
+ * Which biometric modality the hardware supports, whether or not anything is
+ * enrolled. Resolves `'none'` when there is no hardware; never rejects.
+ *
+ * Enrollment state comes from {@link authenticate} via `NOT_ENROLLED`.
+ */
+export declare function getBiometryType(): Promise<BiometryType>;
+/**
+ * Prompts for device-owner authentication.
+ *
+ * A UX gate, not a security boundary — the boolean can be faked by a
+ * compromised bundle. Use {@link signDigest} where it actually matters.
+ *
+ * Never resolves `false`; every failure rejects.
+ *
+ * @throws {KeystoreError}
+ */
+export declare function authenticate(reason: string, policy?: AuthPolicy): Promise<boolean>;
+/**
+ * Stores a secret encrypted under a hardware-bound wrapping key.
+ *
+ * @throws {KeystoreError} `KEY_ALREADY_EXISTS` if `keyId` is taken; overwriting
+ *   is always deliberate.
+ */
+export declare function storeSecret(keyId: string, secretHex: string, options?: KeyOptions): Promise<void>;
+/**
+ * Authenticates and returns the stored secret as hex.
+ *
+ * The prompt is raised by the keystore as a precondition of using the wrapping
+ * key, so it cannot be bypassed from JS.
+ *
+ * @throws {KeystoreError} `KEY_NOT_FOUND`, `KEY_INVALIDATED`, or any auth code.
+ */
+export declare function getSecret(keyId: string, reason: string): Promise<string>;
+/** Whether a secret is stored under `keyId`. Does not authenticate. */
+export declare function hasSecret(keyId: string): Promise<boolean>;
+/** Removes the secret and its wrapping key. Idempotent. */
+export declare function deleteSecret(keyId: string): Promise<void>;
+/**
+ * Generates a secp256k1 keypair in hardware-wrapped storage.
+ *
+ * Entropy comes from the platform CSPRNG, never from JavaScript, and the
+ * private key never crosses the bridge.
+ *
+ * @returns The uncompressed public key.
+ */
+export declare function generateKey(keyId: string, options?: KeyOptions): Promise<PublicKeyHex>;
+/**
+ * Imports an existing secp256k1 private key.
+ *
+ * @throws {KeystoreError} `INVALID_KEY` unless the key is in [1, n-1]. Keys
+ *   outside that range are rejected rather than clamped.
+ */
+export declare function importPrivateKey(keyId: string, privateKeyHex: string, options?: KeyOptions): Promise<PublicKeyHex>;
+/** The uncompressed public key. Does not authenticate. */
+export declare function getPublicKey(keyId: string): Promise<PublicKeyHex>;
+/**
+ * Authenticates, then signs a 32-byte digest.
+ *
+ * Only a digest crosses the boundary — never a message or a transaction.
+ * Keccak and EIP-191/712/155 encoding stay in JS, which keeps this module
+ * curve-specific but chain-agnostic.
+ *
+ * @returns 65 bytes, `r || s || v`, low-s normalized per EIP-2 with `v` of
+ *   27/28 — byte-identical to viem.
+ */
+export declare function signDigest(keyId: string, digestHex: string, reason: string): Promise<SignatureHex>;
+/**
+ * Authenticates, then returns the raw private key.
+ *
+ * For user-initiated backup only. The result lands in the JS heap where it
+ * cannot be zeroed, so prefer {@link signDigest} for everyday use.
+ */
+export declare function exportPrivateKey(keyId: string, reason: string): Promise<string>;
+export {};
+//# sourceMappingURL=keystore.d.ts.map

package/lib/typescript/src/keystore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore.d.ts","sourceRoot":"","sources":["../../../src/keystore.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,MAAM,YAAY,GACpB,QAAQ,GACR,SAAS,GACT,SAAS,GACT,aAAa,GACb,MAAM,GACN,MAAM,GACN,WAAW,GACX,MAAM,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,eAAe,GAAG,qBAAqB,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GAAG,OAAO,CAAC;AAEhE,eAAO,MAAM,mBAAmB,EAAE,UAAkC,CAAC;AACrE,eAAO,MAAM,2BAA2B,EAAE,kBAA4B,CAAC;AAEvE,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG,KAAK,MAAM,EAAE,CAAC;AAEzC,oEAAoE;AACpE,MAAM,MAAM,YAAY,GAAG,KAAK,MAAM,EAAE,CAAC;AAEzC,KAAK,UAAU,GAAG;IAChB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,YAAY,CAAC,EAAE,kBAAkB,CAAC;CACnC,CAAC;AA2CF;;;;;GAKG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,YAAY,CAAC,CAI7D;AAED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,UAAgC,GACvC,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,uEAAuE;AACvE,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO/D;AAED,2DAA2D;AAC3D,wBAAsB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/D;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CAavB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,UAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CA0BvB;AAED,0DAA0D;AAC1D,wBAAsB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAOvE;AAED;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,YAAY,CAAC,CAmBvB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAQjB"}

package/lib/typescript/src/viem.d.ts

@@ -0,0 +1,24 @@
+import { type Hex, type LocalAccount } from 'viem';
+export type KeystoreAccountOptions = {
+    /** Shown in the authentication prompt. */
+    reason?: string;
+    /** Skips a native round-trip. Must belong to `keyId`. */
+    publicKey?: Hex;
+};
+/**
+ * Adapts a hardware-wrapped key into a viem {@link LocalAccount}.
+ *
+ * Every path hashes in JS and sends only a 32-byte digest to native, leaving
+ * EIP-191, EIP-712 and transaction serialization to viem.
+ *
+ * ```ts
+ * const account = await toKeystoreAccount('wallet-1');
+ * const client = createWalletClient({ account, chain: mainnet, transport: http() });
+ * await client.sendTransaction({ to: '0x…', value: 1n });
+ * ```
+ *
+ * Each signature raises its own authentication prompt, so batching several will
+ * prompt several times.
+ */
+export declare function toKeystoreAccount(keyId: string, options?: KeystoreAccountOptions): Promise<LocalAccount>;
+//# sourceMappingURL=viem.d.ts.map

package/lib/typescript/src/viem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["../../../src/viem.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,GAAG,EACR,KAAK,YAAY,EAMlB,MAAM,MAAM,CAAC;AAKd,MAAM,MAAM,sBAAsB,GAAG;IACnC,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,SAAS,CAAC,EAAE,GAAG,CAAC;CACjB,CAAC;AAIF;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,YAAY,CAAC,CAsDvB"}