@authon/react-native-wallet 0.1.0 → 0.4.0

package/ios/vendor/GENERATED.md

@@ -1,4 +1,4 @@
 # Generated sources
 
-Everything in this folder is copied from `swift/Sources/{AuthonWallet,CSecp256k1,CKeccak}` by
+Everything in this folder is copied from `swift/Sources/{AuthonWallet,CSecp256k1,CKeccak,CMonocypher}` by
 `scripts/sync-native-wallet.mjs` (run by the package build). Do not edit these files; change the native SDK sources and run the script. `--check` fails on any difference.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@authon/react-native-wallet",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "Authon embedded wallet for React Native (Expo native module wrapping the Swift and Kotlin wallet SDKs)",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -21,7 +21,8 @@
     "android/consumer-rules.pro",
     "android/src",
     "expo-module.config.json",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "license": "MIT",
   "repository": {

package/src/client.ts

@@ -9,7 +9,12 @@ import type {
   Hex,
   TypedDataPayload,
   WalletAccount,
+  CapabilityCheck,
+  CapabilityStatus,
   WalletAppConfig,
+  WalletCapabilities,
+  WalletChain,
+  WalletChainSignRequest,
   WalletChangeListener,
   WalletMessage,
   WalletSignOptions,
@@ -43,9 +48,16 @@ function toWallet(value: unknown): EmbeddedWallet {
   };
 }
 
+const CHAINS: WalletChain[] = ['evm', 'tron', 'xrp', 'bitcoin', 'bitcoin-testnet', 'solana'];
+
 function toAccounts(value: unknown): WalletAccount[] {
   if (!Array.isArray(value)) throw new AuthonWalletError('UNKNOWN', 'Wallet returned no accounts');
-  return value.filter(isObject).map((a) => ({ index: Number(a.index), path: String(a.path), address: String(a.address) }));
+  return value.filter(isObject).map((a) => {
+    const account: WalletAccount = { index: Number(a.index), path: String(a.path), address: String(a.address) };
+    if (CHAINS.includes(a.chain as WalletChain)) account.chain = a.chain as WalletChain;
+    if (typeof a.publicKey === 'string' && /^(0x)?[0-9a-fA-F]+$/.test(a.publicKey)) account.publicKey = a.publicKey;
+    return account;
+  });
 }
 
 function toHex(value: unknown): Hex {
@@ -67,6 +79,28 @@ function toAppConfig(value: unknown): WalletAppConfig {
   };
 }
 
+const STATUSES: CapabilityStatus[] = ['available', 'unavailable', 'unknown'];
+
+function toCheck(value: unknown): CapabilityCheck {
+  const v = isObject(value) ? value : {};
+  const status = STATUSES.includes(v.status as CapabilityStatus) ? (v.status as CapabilityStatus) : 'unknown';
+  return { status, reason: status === 'available' ? null : str(v.reason) ?? 'CHECK_FAILED' };
+}
+
+function toCapabilities(value: unknown): WalletCapabilities {
+  if (!isObject(value)) throw new AuthonWalletError('UNKNOWN', 'Wallet returned no capabilities');
+  const checks = {
+    app: toCheck(value.app),
+    wallet: toCheck(value.wallet),
+    secureStorage: toCheck(value.secureStorage),
+    deviceLock: toCheck(value.deviceLock),
+    passkeyBackup: toCheck(value.passkeyBackup),
+  };
+  const all = Object.values(checks).map((c) => c.status);
+  const ready: CapabilityStatus = all.includes('unavailable') ? 'unavailable' : all.includes('unknown') ? 'unknown' : 'available';
+  return { ready, ...checks, diagnosticId: str(value.diagnosticId) };
+}
+
 /** bigint → 0x hex (transactions, like @authon/js). */
 const txReplacer = (_key: string, v: unknown) => (typeof v === 'bigint' ? `0x${v.toString(16)}` : v);
 /** bigint → decimal string (EIP-712 integer values). */
@@ -99,6 +133,17 @@ export class AuthonWalletClient {
     return toAppConfig(this.unwrap(await native.appConfig(this.id), generation));
   }
 
+  /**
+   * Whether this device and app can use the wallet, before sign-in (no session, creates nothing,
+   * opens no UI). `ready === 'unavailable'`: tell the user before signing in; `unknown`: continue
+   * but expect that feature to fail. Answers for release builds (test options are ignored).
+   */
+  async capabilities(): Promise<WalletCapabilities> {
+    const generation = this.generation;
+    const native = await this.native();
+    return toCapabilities(this.unwrap(await native.capabilities(this.id), generation));
+  }
+
   /** The signed-in user's wallet, or null when there is none yet. */
   async get(): Promise<EmbeddedWallet | null> {
     try {
@@ -138,15 +183,27 @@ export class AuthonWalletClient {
     return (await this.get())?.protected === true;
   }
 
-  /** Addresses of accounts `start`..`start + count - 1` (public, no approval). */
-  async getAccounts(options: { start?: number; count?: number } = {}): Promise<WalletAccount[]> {
+  /**
+   * Addresses of accounts `start`..`start + count - 1` (public, no approval) on `chain` (default
+   * `evm`). Signing is EVM only for now; other chains are for receiving and display.
+   */
+  async getAccounts(options: { start?: number; count?: number; chain?: WalletChain } = {}): Promise<WalletAccount[]> {
     const start = options.start ?? 0;
     const count = options.count ?? 1;
+    const chain = options.chain;
     if (!Number.isInteger(start) || start < 0 || start > MAX_ACCOUNT_INDEX || !Number.isInteger(count) || count < 1) {
       throw new AuthonWalletError('INVALID_PARAMS', 'start must be an integer 0..2147483647 and count a positive integer');
     }
-    const list = toAccounts(await this.call((n, id, token) => n.accounts(id, token, start, count)));
-    for (const account of list) this.accountAddresses.set(account.index, account.address);
+    if (chain !== undefined && !CHAINS.includes(chain)) {
+      throw new AuthonWalletError('INVALID_PARAMS', `chain must be one of ${CHAINS.join(', ')}`);
+    }
+    const list = toAccounts(await this.call((n, id, token) => n.accounts(id, token, start, count, chain ?? 'evm')));
+    if (chain && list.some((account) => account.chain !== chain)) {
+      // A native wallet without multichain support would answer with EVM addresses.
+      throw new AuthonWalletError('UNSUPPORTED_TYPE', 'This wallet build does not support other chains yet');
+    }
+    // Only EVM addresses can name a signing account.
+    if (!chain || chain === 'evm') for (const account of list) this.accountAddresses.set(account.index, account.address);
     return list;
   }
 
@@ -186,6 +243,30 @@ export class AuthonWalletClient {
     return toHex(await this.call((n, id, token) => n.signTransaction(id, token, json, account, address)));
   }
 
+  /**
+   * Signs an app-built transaction on another chain (NATIVE.md section 12): Solana `{ signature }`,
+   * TRON `{ signature, txID }`, Bitcoin `{ psbt, txHex? }`, XRP `{ signature }`. The native approval
+   * UI shows what the transaction does (unknown programs / contracts are shown as high risk).
+   */
+  async signChainTransaction(request: WalletChainSignRequest): Promise<Record<string, string>> {
+    if (!isObject(request) || (request.chain as WalletChain) === 'evm') {
+      throw new AuthonWalletError('INVALID_PARAMS', 'use signTransaction for EVM');
+    }
+    if (!CHAINS.includes(request.chain)) throw new AuthonWalletError('INVALID_PARAMS', `chain must be one of ${CHAINS.filter((c) => c !== 'evm').join(', ')}`);
+    const account = request.account ?? 0;
+    if (!Number.isInteger(account) || account < 0 || account > MAX_ACCOUNT_INDEX || typeof request.address !== 'string' || !request.address) {
+      throw new AuthonWalletError('INVALID_PARAMS', 'account index and its address are required');
+    }
+    if (!isObject(request.payload)) throw new AuthonWalletError('INVALID_PARAMS', 'payload must be an object');
+    const payload = JSON.stringify(request.payload, txReplacer);
+    const result = await this.call((n, id, token) => n.signChainTransaction(id, token, request.chain, account, request.address, payload));
+    if (!isObject(result)) throw new AuthonWalletError('UNKNOWN', 'Wallet returned no signature');
+    // Signatures and signed transactions only; anything that is not a string is dropped.
+    const out: Record<string, string> = {};
+    for (const [k, v] of Object.entries(result)) if (typeof v === 'string') out[k] = v;
+    return out;
+  }
+
   /** Creates the passkey backup (iOS 18+ / Android with PRF support). Needs an approved app registration. */
   async protect(): Promise<void> {
     await this.call((n, id, token) => n.protect(id, token));
@@ -329,7 +410,10 @@ export class AuthonWalletClient {
     if (!isObject(result)) throw new AuthonWalletError('UNKNOWN', 'Wallet returned no result');
     if (result.ok === true) return result.value as T;
     const code = typeof result.code === 'string' && result.code ? result.code : 'UNKNOWN';
-    throw new AuthonWalletError(code, typeof result.message === 'string' && result.message ? result.message : code);
+    throw new AuthonWalletError(code, typeof result.message === 'string' && result.message ? result.message : code, {
+      diagnosticId: typeof result.diagnosticId === 'string' && result.diagnosticId ? result.diagnosticId : null,
+      retryable: result.retryable === true,
+    });
   }
 
   /** For accounts other than 0 the native wallet needs the expected address and refuses on mismatch. */

package/src/errors.ts

@@ -44,9 +44,15 @@ export type WalletErrorCode =
 
 export class AuthonWalletError extends Error {
   readonly code: WalletErrorCode;
-  constructor(code: WalletErrorCode, message?: string) {
+  /** The server's request ID when the failure came from an API response; log this, never secrets. */
+  readonly diagnosticId: string | null;
+  /** Whether trying the same call again can succeed (from the native wallet's code table). */
+  readonly retryable: boolean;
+  constructor(code: WalletErrorCode, message?: string, options: { diagnosticId?: string | null; retryable?: boolean } = {}) {
     super(message ?? code);
     this.name = 'AuthonWalletError';
     this.code = code;
+    this.diagnosticId = options.diagnosticId ?? null;
+    this.retryable = options.retryable ?? false;
   }
 }

package/src/index.ts

@@ -5,6 +5,11 @@ export { useAuthonWallet } from './useAuthonWallet';
 export type { UseAuthonWalletOptions, UseAuthonWalletResult } from './useAuthonWallet';
 export type {
   AuthonWalletOptions,
+  CapabilityCheck,
+  CapabilityStatus,
+  WalletCapabilities,
+  WalletChain,
+  WalletChainSignRequest,
   EIP1193Provider,
   EIP1193RequestArguments,
   EmbeddedWallet,

package/src/native.ts

@@ -3,7 +3,7 @@ import { requireOptionalNativeModule } from 'expo-modules-core';
 /** Every native function resolves an envelope instead of rejecting. */
 export type NativeResult<T> =
   | { ok: true; value: T }
-  | { ok: false; code: string; message?: string };
+  | { ok: false; code: string; message?: string; diagnosticId?: string | null; retryable?: boolean };
 
 export interface NativeConfig {
   publishableKey: string;
@@ -18,9 +18,10 @@ export interface AuthonWalletNativeModule {
   configure(id: string, config: NativeConfig): Promise<NativeResult<null>>;
   release(id: string): Promise<NativeResult<null>>;
   appConfig(id: string): Promise<NativeResult<unknown>>;
+  capabilities(id: string): Promise<NativeResult<unknown>>;
   status(id: string, token: string): Promise<NativeResult<unknown>>;
   create(id: string, token: string): Promise<NativeResult<unknown>>;
-  accounts(id: string, token: string, start: number, count: number): Promise<NativeResult<unknown>>;
+  accounts(id: string, token: string, start: number, count: number, chain: string): Promise<NativeResult<unknown>>;
   signMessage(
     id: string,
     token: string,
@@ -31,6 +32,7 @@ export interface AuthonWalletNativeModule {
   ): Promise<NativeResult<unknown>>;
   signTypedData(id: string, token: string, typedDataJson: string, account: number, address: string | null): Promise<NativeResult<unknown>>;
   signTransaction(id: string, token: string, transactionJson: string, account: number, address: string | null): Promise<NativeResult<unknown>>;
+  signChainTransaction(id: string, token: string, chain: string, account: number, address: string, payloadJson: string): Promise<NativeResult<unknown>>;
   protect(id: string, token: string): Promise<NativeResult<unknown>>;
   upgradeBackup(id: string, token: string): Promise<NativeResult<unknown>>;
   restore(id: string, token: string, reset: boolean): Promise<NativeResult<unknown>>;

package/src/types.ts

@@ -27,11 +27,36 @@ export interface EmbeddedWallet {
   devices: EmbeddedWalletDevice[];
 }
 
-/** One HD account, derived at `m/44'/60'/0'/0/{index}`. Account 0 is `EmbeddedWallet.address`. */
+/** Chains whose account addresses the wallet derives from the same seed (NATIVE.md section 11). */
+export type WalletChain = 'evm' | 'tron' | 'xrp' | 'bitcoin' | 'bitcoin-testnet' | 'solana';
+
+/**
+ * One HD account. EVM: `m/44'/60'/0'/0/{index}` (account 0 is `EmbeddedWallet.address`); other chains
+ * use their standard paths (TRON `m/44'/195'/n'/0/0`, XRP `m/44'/144'/n'/0/0`, Bitcoin
+ * `m/84'/0'/n'/0/0`, Bitcoin testnet `m/84'/1'/n'/0/0`, Solana `m/44'/501'/n'/0'`).
+ */
 export interface WalletAccount {
   index: number;
   path: string;
   address: string;
+  /** Set when `getAccounts` was asked for a chain. */
+  chain?: WalletChain;
+  /** Public key (hex) when the chain needs it to build a transaction (XRP SigningPubKey). */
+  publicKey?: string;
+}
+
+/** `signChainTransaction` input (NATIVE.md section 12). The app builds the unsigned transaction. */
+export interface WalletChainSignRequest {
+  chain: Exclude<WalletChain, 'evm'>;
+  /** Account index (default 0). */
+  account?: number;
+  /** The account's address on `chain`, from getAccounts. Signing fails (ADDRESS_MISMATCH) if it differs. */
+  address: string;
+  /**
+   * Chain-specific unsigned transaction: Solana `{ message }` (base64 Message, legacy or v0),
+   * TRON `{ rawDataHex }`, Bitcoin `{ psbt }` (base64), XRP `{ txBlobHex }` (encodeForSigning output).
+   */
+  payload: Record<string, unknown>;
 }
 
 /** Signs with another account of the same wallet. Omitted or 0 = the wallet address. */
@@ -83,6 +108,32 @@ export interface WalletAppConfig {
   minFrameProtocol: number | null;
 }
 
+export type CapabilityStatus = 'available' | 'unavailable' | 'unknown';
+
+export interface CapabilityCheck {
+  status: CapabilityStatus;
+  /** Reason code (see the README table); null when available. */
+  reason: string | null;
+}
+
+/** `capabilities()`: can this device and app use the wallet? Asked before sign-in, no session. */
+export interface WalletCapabilities {
+  /** unavailable if any check is unavailable, else unknown if any is unknown, else available. */
+  ready: CapabilityStatus;
+  /** App registration and approval (APP_NOT_REGISTERED, APP_SIGNATURE_MISMATCH, APP_NOT_APPROVED, NETWORK_ERROR, API_ERROR). */
+  app: CapabilityCheck;
+  /** Embedded wallet enabled for the project (WALLET_DISABLED, NETWORK_ERROR). */
+  wallet: CapabilityCheck;
+  /** Hardware-protected key storage (HARDWARE_KEYSTORE_UNAVAILABLE, SIMULATOR, CHECK_FAILED). */
+  secureStorage: CapabilityCheck;
+  /** A device passcode / biometrics is set (DEVICE_LOCK_NOT_SET, CHECK_FAILED). */
+  deviceLock: CapabilityCheck;
+  /** Passkey PRF backup, static OS/API support only (OS_UNSUPPORTED, PASSKEY_API_UNAVAILABLE, PRF_PROVIDER_UNVERIFIED). */
+  passkeyBackup: CapabilityCheck;
+  /** X-Request-Id of the app-config response. */
+  diagnosticId: string | null;
+}
+
 export interface EIP1193RequestArguments {
   method: string;
   params?: unknown[] | Record<string, unknown>;