@sogni-ai/expo-client 1.0.0-alpha.10

package/src/wallet.ts

@@ -0,0 +1,158 @@
+/**
+ * Wallet creation and EIP-712 signing for Sogni authentication.
+ *
+ * Importable as a separate entry point so consumers using only API-key auth
+ * do not bundle viem:
+ *
+ *   import { deriveWallet, signAuthentication } from '@sogni-ai/expo-client/wallet';
+ *
+ * Requires `crypto.getRandomValues` (for fresh wallet generation), which the
+ * `polyfillWebCrypto()` call from `expo-standard-web-crypto` provides. PBKDF2
+ * for username+password derivation is done in pure JS via @noble/hashes, so
+ * no `crypto.subtle` is needed (Expo doesn't polyfill it).
+ */
+
+import { pbkdf2 } from '@noble/hashes/pbkdf2';
+import { sha256 } from '@noble/hashes/sha2';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import type { Hex } from 'viem';
+
+export { LIB_VERSION } from './version';
+
+/** A Sogni wallet — private key plus its derived Ethereum-style address. */
+export interface Wallet {
+  privateKey: Hex;
+  address: Hex;
+}
+
+/** Network the wallet's signatures target. Affects the EIP-712 domain. */
+export type WalletNetwork = 'mainnet' | 'testnet';
+
+interface DomainConfig {
+  name: string;
+  version: '1';
+  chainId: number;
+  verifyingContract: Hex;
+}
+
+const PLACEHOLDER_VERIFYING_CONTRACT: Hex = '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC';
+
+function getDomain(network: WalletNetwork): DomainConfig {
+  return network === 'testnet'
+    ? {
+        name: 'Sogni-testnet',
+        version: '1',
+        chainId: 84532,
+        verifyingContract: PLACEHOLDER_VERIFYING_CONTRACT
+      }
+    : {
+        name: 'Sogni AI',
+        version: '1',
+        chainId: 8453,
+        verifyingContract: PLACEHOLDER_VERIFYING_CONTRACT
+      };
+}
+
+const AUTH_TYPES = {
+  Authentication: [
+    { name: 'walletAddress', type: 'address' },
+    { name: 'nonce', type: 'string' }
+  ]
+} as const;
+
+const SIGNUP_TYPES = {
+  Signup: [
+    { name: 'appid', type: 'string' },
+    { name: 'username', type: 'string' },
+    { name: 'email', type: 'string' },
+    { name: 'subscribe', type: 'uint256' },
+    { name: 'walletAddress', type: 'address' },
+    { name: 'nonce', type: 'string' }
+  ]
+} as const;
+
+/**
+ * Derive a deterministic wallet from a username + password using PBKDF2
+ * (10,000 iterations of SHA-256, salt = username, output = 32 bytes).
+ *
+ * Uses @noble/hashes pure-JS implementation rather than `crypto.subtle`
+ * because Hermes / expo-standard-web-crypto don't polyfill subtle. Still
+ * async-returning so callers don't depend on the implementation detail.
+ *
+ * The same credentials always produce the same wallet on every device,
+ * which is how Sogni's username+password login works without ever
+ * transmitting or storing the password server-side.
+ */
+export async function deriveWallet(input: { username: string; password: string }): Promise<Wallet> {
+  const { username, password } = input;
+  if (!username || !password) {
+    throw new Error('deriveWallet requires both username and password');
+  }
+  const passwordBytes = new TextEncoder().encode(password);
+  const saltBytes = new TextEncoder().encode(username);
+  const bits = pbkdf2(sha256, passwordBytes, saltBytes, { c: 10000, dkLen: 32 });
+  const privateKey = bytesToHex(bits);
+  const account = privateKeyToAccount(privateKey);
+  return { privateKey, address: account.address };
+}
+
+/** Generate a fresh random wallet (uses crypto.getRandomValues internally). */
+export function createRandomWallet(): Wallet {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  return { privateKey, address: account.address };
+}
+
+/**
+ * Sign the Authentication EIP-712 message used by `/v1/account/login` and
+ * other authenticated REST endpoints.
+ */
+export async function signAuthentication(
+  wallet: Wallet,
+  params: { nonce: string },
+  network: WalletNetwork = 'mainnet'
+): Promise<Hex> {
+  const account = privateKeyToAccount(wallet.privateKey);
+  return account.signTypedData({
+    domain: getDomain(network),
+    types: AUTH_TYPES,
+    primaryType: 'Authentication',
+    message: { walletAddress: wallet.address, nonce: params.nonce }
+  });
+}
+
+/**
+ * Sign the Signup EIP-712 message used by `/v1/account/create`. The
+ * `subscribe` boolean is encoded as a uint256 (0/1) on the wire.
+ */
+export async function signSignup(
+  wallet: Wallet,
+  params: {
+    appid: string;
+    username: string;
+    email: string;
+    subscribe: boolean;
+    nonce: string;
+  },
+  network: WalletNetwork = 'mainnet'
+): Promise<Hex> {
+  const account = privateKeyToAccount(wallet.privateKey);
+  return account.signTypedData({
+    domain: getDomain(network),
+    types: SIGNUP_TYPES,
+    primaryType: 'Signup',
+    message: {
+      appid: params.appid,
+      username: params.username,
+      email: params.email,
+      subscribe: BigInt(params.subscribe ? 1 : 0),
+      walletAddress: wallet.address,
+      nonce: params.nonce
+    }
+  });
+}
+
+function bytesToHex(bytes: Uint8Array): Hex {
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+  return `0x${hex}` as Hex;
+}