@mentaproject/signer-react-native 0.0.1

package/src/signer.ts

@@ -0,0 +1,499 @@
+import { Passkey } from "react-native-passkey";
+import {
+  type Address,
+  type Hex,
+  type TypedData,
+  type TypedDataDefinition,
+  hashTypedData,
+  keccak256,
+} from "viem";
+
+import type {
+  SmartAccountSigner,
+  PasskeyCredential,
+  P256PublicKey,
+  ReactNativePasskeySignerConfig,
+  SignableMessage,
+  SignatureEncodingFormat,
+} from "./types/index.js";
+import {
+  extractPublicKeyFromAttestation,
+  encodeUncompressedPublicKey,
+  isValidP256PublicKey,
+  COSEParseError,
+} from "./utils/cose.js";
+import { bytesToBase64Url, base64UrlToHex } from "./utils/base64url.js";
+import {
+  parseWebAuthnAssertion,
+  encodeWebAuthnSignature,
+  createAssertionOptions,
+  SignatureError,
+} from "./utils/passkey.js";
+
+/**
+ * Error thrown when passkey operations fail.
+ */
+export class PasskeySignerError extends Error {
+  constructor(
+    message: string,
+    public readonly cause?: unknown,
+  ) {
+    super(message);
+    this.name = "PasskeySignerError";
+  }
+}
+
+/**
+ * ReactNativePasskeySigner implements SmartAccountSigner using WebAuthn/Passkeys.
+ *
+ * This signer uses the device's biometric authentication (Face ID, Touch ID, fingerprint)
+ * to sign messages and transactions for ERC-4337 smart accounts.
+ *
+ * The public key is a P-256 (secp256r1) key stored in the device's secure enclave.
+ *
+ * @example
+ * ```typescript
+ * // Register a new passkey
+ * const signer = await ReactNativePasskeySigner.register("user@example.com", {
+ *   rpId: "example.com",
+ *   rpName: "Example App",
+ * });
+ *
+ * // Sign a message (triggers biometric prompt)
+ * const signature = await signer.signMessage({
+ *   message: { raw: userOpHash },
+ * });
+ * ```
+ */
+export class ReactNativePasskeySigner implements SmartAccountSigner<"passkey"> {
+  public readonly source = "passkey" as const;
+
+  /**
+   * The credential ID in Base64URL format.
+   */
+  public readonly credentialId: string;
+
+  /**
+   * The credential ID as hex.
+   */
+  public readonly credentialIdHex: Hex;
+
+  /**
+   * The P-256 public key coordinates (x, y).
+   */
+  public readonly publicKeyCoordinates: P256PublicKey;
+
+  /**
+   * The encoded public key (uncompressed SEC1 format: 0x04 || x || y).
+   */
+  public readonly publicKey: Hex;
+
+  /**
+   * Configuration for passkey operations.
+   */
+  private readonly config: ReactNativePasskeySignerConfig;
+
+  /**
+   * Creates a new ReactNativePasskeySigner instance.
+   * Use the static `register` or `fromCredential` methods instead of calling this directly.
+   *
+   * @param credential - The passkey credential data
+   * @param config - Configuration for passkey operations
+   */
+  private constructor(
+    credential: PasskeyCredential,
+    config: ReactNativePasskeySignerConfig,
+  ) {
+    this.credentialId = credential.credentialId;
+    this.credentialIdHex = credential.credentialIdHex;
+    this.publicKeyCoordinates = credential.publicKey;
+    this.publicKey = credential.publicKeyHex;
+    this.config = {
+      ...config,
+      timeout: config.timeout ?? 60000,
+      userVerification: config.userVerification ?? "required",
+      signatureFormat: config.signatureFormat ?? "kernel",
+    };
+  }
+
+  /**
+   * Registers a new passkey and returns a signer instance.
+   *
+   * This triggers the device's WebAuthn registration flow:
+   * 1. Shows a system prompt to create a new passkey
+   * 2. User authenticates with biometrics
+   * 3. Device generates a new P-256 key pair in the secure enclave
+   * 4. Returns the public key and credential ID
+   *
+   * @param username - The username for the passkey (displayed in system UI)
+   * @param config - Configuration for the passkey
+   * @returns A new ReactNativePasskeySigner instance
+   * @throws PasskeySignerError if registration fails
+   */
+  public static async register(
+    username: string,
+    config: ReactNativePasskeySignerConfig,
+  ): Promise<ReactNativePasskeySigner> {
+    // Generate a random user ID
+    const userId = new Uint8Array(32);
+    crypto.getRandomValues(userId);
+    const userIdB64 = bytesToBase64Url(userId);
+
+    // Generate a random challenge
+    const challenge = new Uint8Array(32);
+    crypto.getRandomValues(challenge);
+    const challengeB64 = bytesToBase64Url(challenge);
+
+    try {
+      // Call the native passkey creation
+      const result = await Passkey.create({
+        challenge: challengeB64,
+        rp: {
+          id: config.rpId,
+          name: config.rpName,
+        },
+        user: {
+          id: userIdB64,
+          name: username,
+          displayName: username,
+        },
+        pubKeyCredParams: [
+          {
+            type: "public-key",
+            alg: -7, // ES256 (P-256 with SHA-256)
+          },
+        ],
+        authenticatorSelection: {
+          authenticatorAttachment: "platform",
+          residentKey: "required",
+          requireResidentKey: true,
+          userVerification: config.userVerification ?? "required",
+        },
+        timeout: config.timeout ?? 60000,
+        attestation: "none",
+      });
+
+      // Extract the credential ID
+      const credentialId = result.id;
+      const credentialIdHex = base64UrlToHex(credentialId);
+
+      // Parse the attestation to extract the public key
+      // The attestationObject contains the COSE-encoded public key
+      if (!result.response.attestationObject) {
+        throw new PasskeySignerError(
+          "Registration response missing attestationObject",
+        );
+      }
+
+      const { publicKey } = extractPublicKeyFromAttestation(
+        result.response.attestationObject,
+      );
+
+      // Validate the public key
+      if (!isValidP256PublicKey(publicKey)) {
+        throw new PasskeySignerError(
+          "Invalid public key extracted from attestation",
+        );
+      }
+
+      // Encode the public key in uncompressed format
+      const publicKeyHex = encodeUncompressedPublicKey(publicKey);
+
+      const credential: PasskeyCredential = {
+        credentialId,
+        credentialIdHex,
+        publicKey,
+        publicKeyHex,
+      };
+
+      return new ReactNativePasskeySigner(credential, config);
+    } catch (error) {
+      if (error instanceof COSEParseError) {
+        throw new PasskeySignerError(
+          `Failed to parse attestation: ${error.message}`,
+          error,
+        );
+      }
+      if (error instanceof PasskeySignerError) {
+        throw error;
+      }
+      throw new PasskeySignerError(
+        `Passkey registration failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error,
+      );
+    }
+  }
+
+  /**
+   * Creates a signer from an existing credential.
+   *
+   * Use this when you have previously registered a passkey and stored the credential data.
+   *
+   * @param credential - The stored credential data
+   * @param config - Configuration for passkey operations
+   * @returns A new ReactNativePasskeySigner instance
+   */
+  public static fromCredential(
+    credential: PasskeyCredential,
+    config: ReactNativePasskeySignerConfig,
+  ): ReactNativePasskeySigner {
+    if (!isValidP256PublicKey(credential.publicKey)) {
+      throw new PasskeySignerError("Invalid public key in credential");
+    }
+
+    return new ReactNativePasskeySigner(credential, config);
+  }
+
+  /**
+   * Signs a message using the passkey.
+   *
+   * This triggers the device's biometric authentication prompt.
+   * The message can be a string or raw bytes (typically a UserOpHash).
+   *
+   * @param params - The message to sign
+   * @returns The encoded signature
+   * @throws PasskeySignerError if signing fails
+   */
+  public async signMessage({
+    message,
+  }: {
+    message: SignableMessage;
+  }): Promise<Hex> {
+    // Convert message to bytes
+    let messageBytes: Uint8Array;
+
+    if (typeof message === "string") {
+      // For string messages, hash with EIP-191 prefix
+      const encoder = new TextEncoder();
+      const msgBytes = encoder.encode(message);
+      const prefix = `\x19Ethereum Signed Message:\n${msgBytes.length}`;
+      const prefixBytes = encoder.encode(prefix);
+
+      const combined = new Uint8Array(prefixBytes.length + msgBytes.length);
+      combined.set(prefixBytes, 0);
+      combined.set(msgBytes, prefixBytes.length);
+
+      // Hash the prefixed message
+      const hash = keccak256(combined);
+      messageBytes = this.hexToBytes(hash);
+    } else if ("raw" in message) {
+      // For raw bytes, use them directly (typically already a hash)
+      if (typeof message.raw === "string") {
+        messageBytes = this.hexToBytes(message.raw as Hex);
+      } else {
+        messageBytes = message.raw;
+      }
+    } else {
+      throw new PasskeySignerError("Invalid message format");
+    }
+
+    // Create challenge from the message bytes
+    const challenge = bytesToBase64Url(messageBytes);
+
+    return this.signWithPasskey(challenge);
+  }
+
+  /**
+   * Signs typed data according to EIP-712.
+   *
+   * @param typedData - The typed data to sign
+   * @returns The encoded signature
+   * @throws PasskeySignerError if signing fails
+   */
+  public async signTypedData<
+    const TTypedData extends TypedData | Record<string, unknown>,
+    TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData,
+  >(typedData: TypedDataDefinition<TTypedData, TPrimaryType>): Promise<Hex> {
+    // Hash the typed data according to EIP-712
+    const hash = hashTypedData(typedData);
+
+    // Convert hash to bytes for challenge
+    const messageBytes = this.hexToBytes(hash);
+    const challenge = bytesToBase64Url(messageBytes);
+
+    return this.signWithPasskey(challenge);
+  }
+
+  /**
+   * Returns the address derived from the public key.
+   *
+   * Note: P-256 keys don't directly map to Ethereum addresses.
+   * This returns a pseudo-address derived from the public key hash.
+   * The actual smart account address is determined by the account implementation.
+   *
+   * @returns A derived address (not a real EOA address)
+   */
+  public async getAddress(): Promise<Address> {
+    // Derive an address from the public key by hashing it
+    // This is not a real EOA address, just an identifier
+    const hash = keccak256(this.publicKey);
+    // Take the last 20 bytes
+    return `0x${hash.slice(-40)}` as Address;
+  }
+
+  /**
+   * Returns the X coordinate of the public key.
+   */
+  public getPublicKeyX(): Hex {
+    return this.publicKeyCoordinates.x;
+  }
+
+  /**
+   * Returns the Y coordinate of the public key.
+   */
+  public getPublicKeyY(): Hex {
+    return this.publicKeyCoordinates.y;
+  }
+
+  /**
+   * Returns the full credential data for storage/restoration.
+   */
+  public getCredential(): PasskeyCredential {
+    return {
+      credentialId: this.credentialId,
+      credentialIdHex: this.credentialIdHex,
+      publicKey: this.publicKeyCoordinates,
+      publicKeyHex: this.publicKey,
+    };
+  }
+
+  /**
+   * Sets the signature encoding format.
+   *
+   * @param format - The format to use for encoding signatures
+   * @returns A new signer instance with the updated format
+   */
+  public withSignatureFormat(
+    format: SignatureEncodingFormat,
+  ): ReactNativePasskeySigner {
+    return new ReactNativePasskeySigner(this.getCredential(), {
+      ...this.config,
+      signatureFormat: format,
+    });
+  }
+
+  /**
+   * Internal method to sign a challenge with the passkey.
+   *
+   * @param challenge - The Base64URL-encoded challenge
+   * @returns The encoded signature
+   */
+  private async signWithPasskey(challenge: string): Promise<Hex> {
+    try {
+      // Create assertion options
+      const options = createAssertionOptions(
+        challenge,
+        this.config.rpId,
+        this.credentialId,
+        this.config.userVerification,
+        this.config.timeout,
+      );
+
+      // Call native passkey assertion
+      const result = await Passkey.get(options);
+
+      // Parse the assertion response
+      const webAuthnSignature = parseWebAuthnAssertion({
+        authenticatorData: result.response.authenticatorData,
+        clientDataJSON: result.response.clientDataJSON,
+        signature: result.response.signature,
+      });
+
+      // Encode the signature according to the configured format
+      return encodeWebAuthnSignature(
+        webAuthnSignature,
+        this.config.signatureFormat,
+      );
+    } catch (error) {
+      if (error instanceof SignatureError) {
+        throw new PasskeySignerError(
+          `Signature parsing failed: ${error.message}`,
+          error,
+        );
+      }
+      throw new PasskeySignerError(
+        `Passkey signing failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error,
+      );
+    }
+  }
+
+  /**
+   * Converts a hex string to Uint8Array.
+   */
+  private hexToBytes(hex: Hex): Uint8Array {
+    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+    const bytes = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < cleanHex.length; i += 2) {
+      bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
+    }
+    return bytes;
+  }
+}
+
+/**
+ * Type guard to check if a value is a valid PasskeyCredential.
+ */
+export function isPasskeyCredential(
+  value: unknown,
+): value is PasskeyCredential {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const obj = value as Record<string, unknown>;
+
+  return (
+    typeof obj.credentialId === "string" &&
+    typeof obj.credentialIdHex === "string" &&
+    obj.credentialIdHex.startsWith("0x") &&
+    typeof obj.publicKey === "object" &&
+    obj.publicKey !== null &&
+    typeof (obj.publicKey as Record<string, unknown>).x === "string" &&
+    typeof (obj.publicKey as Record<string, unknown>).y === "string" &&
+    typeof obj.publicKeyHex === "string" &&
+    obj.publicKeyHex.startsWith("0x")
+  );
+}
+
+/**
+ * Serializes a PasskeyCredential to a JSON-safe object.
+ */
+export function serializeCredential(
+  credential: PasskeyCredential,
+): Record<string, string> {
+  return {
+    credentialId: credential.credentialId,
+    credentialIdHex: credential.credentialIdHex,
+    publicKeyX: credential.publicKey.x,
+    publicKeyY: credential.publicKey.y,
+    publicKeyHex: credential.publicKeyHex,
+  };
+}
+
+/**
+ * Deserializes a PasskeyCredential from a JSON object.
+ */
+export function deserializeCredential(
+  data: Record<string, string>,
+): PasskeyCredential {
+  if (
+    !data.credentialId ||
+    !data.credentialIdHex ||
+    !data.publicKeyX ||
+    !data.publicKeyY ||
+    !data.publicKeyHex
+  ) {
+    throw new PasskeySignerError("Invalid serialized credential data");
+  }
+
+  return {
+    credentialId: data.credentialId,
+    credentialIdHex: data.credentialIdHex as Hex,
+    publicKey: {
+      x: data.publicKeyX as Hex,
+      y: data.publicKeyY as Hex,
+    },
+    publicKeyHex: data.publicKeyHex as Hex,
+  };
+}

package/src/types/index.ts

@@ -0,0 +1,140 @@
+import type { Address, Hex, TypedData, TypedDataDefinition } from "viem";
+
+/**
+ * Represents the source of a SmartAccountSigner - either a custom source or a known type.
+ */
+export type SmartAccountSignerSource = "passkey" | "custom";
+
+/**
+ * Interface for signing messages and typed data for Smart Accounts.
+ * Compatible with permissionless.js and viem account abstraction.
+ */
+export interface SmartAccountSigner<
+  TSource extends SmartAccountSignerSource = SmartAccountSignerSource,
+> {
+  /** The type/source of the signer */
+  readonly source: TSource;
+
+  /** The public key associated with this signer (for passkeys, this is the encoded P256 key) */
+  readonly publicKey: Hex;
+
+  /**
+   * Signs a message and returns the signature.
+   * For passkeys, this triggers the biometric prompt.
+   */
+  signMessage: (params: { message: SignableMessage }) => Promise<Hex>;
+
+  /**
+   * Signs typed data according to EIP-712 and returns the signature.
+   * For passkeys, this triggers the biometric prompt.
+   */
+  signTypedData: <
+    const TTypedData extends TypedData | Record<string, unknown>,
+    TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData,
+  >(
+    typedData: TypedDataDefinition<TTypedData, TPrimaryType>
+  ) => Promise<Hex>;
+
+  /**
+   * Returns the address derived from or associated with this signer.
+   * For passkeys with P256 keys, this may be a derived address or the account address.
+   */
+  getAddress: () => Promise<Address>;
+}
+
+/**
+ * Message types that can be signed.
+ * Matches viem's SignableMessage type.
+ */
+export type SignableMessage =
+  | string
+  | {
+      raw: Hex | Uint8Array;
+    };
+
+/**
+ * Configuration for WebAuthn/Passkey operations.
+ */
+export interface PasskeyConfig {
+  /** The Relying Party ID (usually the domain) */
+  rpId: string;
+  /** The Relying Party name for display */
+  rpName: string;
+  /** Challenge timeout in milliseconds (default: 60000) */
+  timeout?: number;
+  /** User verification requirement */
+  userVerification?: "required" | "preferred" | "discouraged";
+}
+
+/**
+ * Represents the parsed public key coordinates from a P256/secp256r1 key.
+ */
+export interface P256PublicKey {
+  /** X coordinate of the public key (32 bytes) */
+  x: Hex;
+  /** Y coordinate of the public key (32 bytes) */
+  y: Hex;
+}
+
+/**
+ * Credential data stored after passkey registration.
+ */
+export interface PasskeyCredential {
+  /** The credential ID in base64url format */
+  credentialId: string;
+  /** The raw credential ID as hex */
+  credentialIdHex: Hex;
+  /** The public key coordinates */
+  publicKey: P256PublicKey;
+  /** The encoded public key for the signer interface */
+  publicKeyHex: Hex;
+}
+
+/**
+ * WebAuthn authenticator data structure.
+ */
+export interface AuthenticatorData {
+  /** RP ID hash (32 bytes) */
+  rpIdHash: Hex;
+  /** Flags byte */
+  flags: number;
+  /** Sign counter */
+  signCount: number;
+  /** Raw authenticator data */
+  raw: Hex;
+}
+
+/**
+ * Parsed WebAuthn assertion response for signing.
+ */
+export interface WebAuthnSignature {
+  /** Raw authenticator data */
+  authenticatorData: Hex;
+  /** Client data JSON string */
+  clientDataJSON: string;
+  /** The r component of the signature (32 bytes) */
+  r: Hex;
+  /** The s component of the signature (32 bytes) */
+  s: Hex;
+  /** Challenge location in clientDataJSON */
+  challengeLocation: number;
+  /** Response type location in clientDataJSON */
+  responseTypeLocation: number;
+}
+
+/**
+ * Options for signature encoding format.
+ * Different smart contract implementations expect different formats.
+ */
+export type SignatureEncodingFormat =
+  | "kernel" // Kernel/ZeroDev format
+  | "rhinestone" // Rhinestone format
+  | "raw"; // Raw WebAuthn signature components
+
+/**
+ * Configuration for the ReactNativePasskeySigner.
+ */
+export interface ReactNativePasskeySignerConfig extends PasskeyConfig {
+  /** The format to use when encoding signatures */
+  signatureFormat?: SignatureEncodingFormat;
+}