{"version":3,"sources":["../src/crypto/encoding.ts","../src/chains/stellar/envelope.ts","../src/chains/stellar/DeviceUnwrapKey.ts","../src/chains/stellar/WebCryptoDeviceUnwrapKey.ts"],"names":["p256","sha256"],"mappings":"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","file":"chunk-BRY454OR.mjs","sourcesContent":["/**\n * Low-level encoding helpers shared across the kit.\n */\nimport { Buffer } from \"buffer\";\n\n\nconst U128_MASK = (1n << 128n) - 1n;\n\nexport function utf8ToBytes(value: string): Uint8Array {\n return new Uint8Array(Buffer.from(value, \"utf8\"));\n}\n\nexport function bytesToUtf8(value: Uint8Array): string {\n return Buffer.from(value).toString(\"utf8\");\n}\n\nexport function bytesToBase64Url(bytes: Uint8Array): string {\n return Buffer.from(bytes)\n .toString(\"base64\")\n .replace(/\\+/g, \"-\")\n .replace(/\\//g, \"_\")\n .replace(/=+$/, \"\");\n}\n\nexport function base64UrlToBytes(value: string): Uint8Array {\n const normal = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n const padded = normal.padEnd(Math.ceil(normal.length / 4) * 4, \"=\");\n return new Uint8Array(Buffer.from(padded, \"base64\"));\n}\n\nexport function secureRandomBytes(length: number): Uint8Array {\n if (!globalThis.crypto?.getRandomValues) throw new Error(\"kit: secure random source unavailable\");\n const out = new Uint8Array(length);\n globalThis.crypto.getRandomValues(out);\n return out;\n}\n\n/** Split a u256 into the `[low, high]` felt pair Cairo expects. */\nexport function u256ToFelts(value: bigint): [bigint, bigint] {\n return [value & U128_MASK, value >> 128n];\n}\n\n/** Big-endian bytes -> bigint. */\nexport function bytesToBigInt(bytes: Uint8Array): bigint {\n let out = 0n;\n for (const b of bytes) out = (out << 8n) | BigInt(b);\n return out;\n}\n\nexport function bytesToHex(bytes: Uint8Array): string {\n let s = \"0x\";\n for (const b of bytes) s += b.toString(16).padStart(2, \"0\");\n return s;\n}\n\nexport function hexToBytes(hex: string): Uint8Array {\n const clean = hex.startsWith(\"0x\") ? hex.slice(2) : hex;\n const padded = clean.length % 2 ? \"0\" + clean : clean;\n const out = new Uint8Array(padded.length / 2);\n for (let i = 0; i < out.length; i++) out[i] = parseInt(padded.slice(i * 2, i * 2 + 2), 16);\n return out;\n}\n\n/** A felt/bigint -> 32-byte big-endian Uint8Array (the tx-hash width). */\nexport function bigIntTo32Bytes(value: bigint): Uint8Array {\n const out = new Uint8Array(32);\n let v = value;\n for (let i = 31; i >= 0; i--) {\n out[i] = Number(v & 0xffn);\n v >>= 8n;\n }\n return out;\n}\n","import { gcm } from \"@noble/ciphers/aes\";\nimport { p256 } from \"@noble/curves/p256\";\nimport { hkdf } from \"@noble/hashes/hkdf\";\nimport { pbkdf2 } from \"@noble/hashes/pbkdf2\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { randomBytes } from \"@noble/hashes/utils\";\nimport { utf8ToBytes } from \"../../crypto/encoding\";\n\n/**\n * Envelope encryption for the classic-G control key.\n *\n * The control key's 32-byte seed is the one secret that authorizes the account.\n * It is never stored in the clear. Instead:\n *\n * 1. A random 256-bit **DEK** (data-encryption key) encrypts the control seed\n * once → `ciphertext` (stored on-chain in a `cv:ct` data entry).\n * 2. The DEK itself is **wrapped** independently by each unlock factor's KEK\n * (key-encryption key), producing one small blob per factor:\n * - device P-256 (ECIES) → silent daily unlock, per-device, non-syncable\n * - passkey PRF → recovery / new-device anchor (synced, portable)\n * - recovery code → offline backup (optional in v1)\n *\n * Adding a factor (e.g. approving a new device) only re-wraps the DEK for that\n * factor; the control ciphertext never changes. Losing a factor is just dropping\n * its wrap. This is the classic-multisig analogue of `add_signer`, done in the\n * account's own on-chain data entries with no backend and no registry.\n *\n * All primitives are AES-256-GCM (authenticated) + HKDF-SHA256, pure `@noble/*`.\n */\n\n/** AES-GCM nonce length (96-bit, the standard). */\nconst NONCE_LEN = 12;\n\n/** HKDF `info` strings, one per factor, so the same underlying secret can never\n * produce the same KEK across factors. Never change (breaks existing wraps). */\nconst RECOVERY_INFO = \"cavos-stellar-dek-recovery\";\nconst PASSKEY_INFO = \"cavos-stellar-dek-passkey\";\nconst ECIES_INFO = \"cavos-stellar-dek-ecies\";\n\n/** PBKDF2 iterations for the recovery-code KEK — matches the recovery signer's\n * brute-force brake so a stolen envelope can't be attacked cheaply offline. */\nconst RECOVERY_PBKDF2_ITERATIONS = 210_000;\nconst RECOVERY_KDF_SALT = \"cavos-stellar-recovery-v1\";\n\n/** A DEK-wrap blob: `nonce || AES-GCM(kek, dek)`. Self-contained (nonce inline). */\nexport type WrappedDEK = Uint8Array;\n\n/** Fresh 256-bit data-encryption key. One per account, generated at creation. */\nexport function generateDEK(): Uint8Array {\n return randomBytes(32);\n}\n\n/** Encrypt the control seed under the DEK → `nonce || ct`. */\nexport function sealControlSeed(controlSeed: Uint8Array, dek: Uint8Array): Uint8Array {\n const nonce = randomBytes(NONCE_LEN);\n const ct = gcm(dek, nonce).encrypt(controlSeed);\n return concat(nonce, ct);\n}\n\n/** Decrypt the control seed (`nonce || ct`) under the DEK. Throws on tamper. */\nexport function openControlSeed(sealed: Uint8Array, dek: Uint8Array): Uint8Array {\n const { nonce, ct } = splitNonce(sealed);\n return gcm(dek, nonce).decrypt(ct);\n}\n\n/** Wrap the DEK under a raw 32-byte KEK → `nonce || AES-GCM(kek, dek)`. */\nexport function wrapDEK(dek: Uint8Array, kek: Uint8Array): WrappedDEK {\n const nonce = randomBytes(NONCE_LEN);\n return concat(nonce, gcm(kek, nonce).encrypt(dek));\n}\n\n/** Unwrap the DEK from a `nonce || ct` blob under a raw 32-byte KEK. */\nexport function unwrapDEK(wrapped: WrappedDEK, kek: Uint8Array): Uint8Array {\n const { nonce, ct } = splitNonce(wrapped);\n return gcm(kek, nonce).decrypt(ct);\n}\n\n// ---------------------------------------------------------------------------\n// Factor KEK derivations\n// ---------------------------------------------------------------------------\n\n/** KEK from a human recovery code (PBKDF2-stretched, then HKDF-scoped). The same\n * normalised code yields the same KEK on any device. */\nexport function deriveRecoveryKEK(code: string): Uint8Array {\n const normalised = code.trim().replace(/\\s+/g, \" \").toLowerCase();\n if (!normalised) throw new Error(\"kit/stellar: recovery code is empty\");\n const stretched = pbkdf2(sha256, utf8ToBytes(normalised), utf8ToBytes(RECOVERY_KDF_SALT), {\n c: RECOVERY_PBKDF2_ITERATIONS,\n dkLen: 32,\n });\n return hkdf(sha256, stretched, undefined, RECOVERY_INFO, 32);\n}\n\n/** KEK from a WebAuthn PRF output (32 bytes the authenticator returns for our\n * fixed PRF salt). HKDF-scoped so the raw PRF secret is never used directly. */\nexport function derivePasskeyKEK(prfOutput: Uint8Array): Uint8Array {\n if (prfOutput.length < 32) throw new Error(\"kit/stellar: passkey PRF output too short\");\n return hkdf(sha256, prfOutput, undefined, PASSKEY_INFO, 32);\n}\n\n// ---------------------------------------------------------------------------\n// Device factor: ECIES over P-256\n// ---------------------------------------------------------------------------\n\n/**\n * ECIES-wrap the DEK to a device's P-256 public key (SEC1 uncompressed, 65\n * bytes). Returns `ephPubCompressed(33) || nonce(12) || ct` — self-contained.\n * An ephemeral keypair makes each wrap use a fresh shared secret; the device\n * unwraps with its private scalar. The ephemeral public key is bound into the\n * KEK via the HKDF salt so it can't be swapped.\n */\nexport function eciesWrapDEK(dek: Uint8Array, recipientPubSec1: Uint8Array): Uint8Array {\n const ephPriv = p256.utils.randomPrivateKey();\n const ephPubCompressed = p256.getPublicKey(ephPriv, true); // 33 bytes\n const kek = eciesKEK(p256.getSharedSecret(ephPriv, recipientPubSec1, false), ephPubCompressed);\n const wrapped = wrapDEK(dek, kek);\n return concat(ephPubCompressed, wrapped);\n}\n\n/** ECIES-unwrap the DEK with the device's private scalar (32 bytes). */\nexport function eciesUnwrapDEK(blob: Uint8Array, recipientPrivScalar: Uint8Array): Uint8Array {\n const ephPubCompressed = blob.subarray(0, 33);\n const wrapped = blob.subarray(33);\n const kek = eciesKEK(p256.getSharedSecret(recipientPrivScalar, ephPubCompressed, false), ephPubCompressed);\n return unwrapDEK(wrapped, kek);\n}\n\n/**\n * Derive the ECIES KEK from a raw ECDH result. We hash ONLY the shared secret's\n * X coordinate (bytes 1..33 of the uncompressed `04||X||Y` point), because that\n * is exactly what WebCrypto's `deriveBits({name:\"ECDH\"}, …)` returns — so a\n * browser `WebCryptoDeviceUnwrapKey` and a raw-scalar `LocalDeviceUnwrapKey`\n * derive the identical KEK for the same wrap. The ephemeral public key is bound\n * in as the HKDF salt so it can't be swapped.\n */\nexport function eciesKEK(sharedUncompressed: Uint8Array, ephPubCompressed: Uint8Array): Uint8Array {\n return eciesKEKFromX(sharedUncompressed.subarray(1, 33), ephPubCompressed);\n}\n\n/** ECIES KEK straight from the 32-byte ECDH X coordinate — the form WebCrypto's\n * `deriveBits` returns, so the browser unwrap path derives the identical KEK. */\nexport function eciesKEKFromX(sharedX: Uint8Array, ephPubCompressed: Uint8Array): Uint8Array {\n return hkdf(sha256, sharedX, ephPubCompressed, ECIES_INFO, 32);\n}\n\n// ---------------------------------------------------------------------------\n// 64-byte chunking (Stellar MANAGE_DATA value limit)\n// ---------------------------------------------------------------------------\n\n/** Stellar data-entry values are capped at 64 bytes; blobs larger than that\n * (e.g. an ECIES device wrap) are split across ordered `:` entries. */\nexport const DATA_ENTRY_MAX = 64;\n\n/** Split a blob into ≤64-byte chunks, in order. A blob that already fits\n * returns a single chunk. */\nexport function chunkTo64(blob: Uint8Array): Uint8Array[] {\n if (blob.length <= DATA_ENTRY_MAX) return [blob];\n const chunks: Uint8Array[] = [];\n for (let i = 0; i < blob.length; i += DATA_ENTRY_MAX) {\n chunks.push(blob.subarray(i, i + DATA_ENTRY_MAX));\n }\n return chunks;\n}\n\n/** Reassemble an ordered list of chunks back into the original blob. */\nexport function unchunk(chunks: Uint8Array[]): Uint8Array {\n const total = chunks.reduce((n, c) => n + c.length, 0);\n const out = new Uint8Array(total);\n let off = 0;\n for (const c of chunks) {\n out.set(c, off);\n off += c.length;\n }\n return out;\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array): Uint8Array {\n const out = new Uint8Array(a.length + b.length);\n out.set(a, 0);\n out.set(b, a.length);\n return out;\n}\n\nfunction splitNonce(blob: Uint8Array): { nonce: Uint8Array; ct: Uint8Array } {\n return { nonce: blob.subarray(0, NONCE_LEN), ct: blob.subarray(NONCE_LEN) };\n}\n","import { p256 } from \"@noble/curves/p256\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { randomBytes } from \"@noble/hashes/utils\";\nimport { eciesUnwrapDEK } from \"./envelope\";\n\n/**\n * The device's P-256 **ECDH** key used only to unwrap the account DEK.\n *\n * This key is per-device and non-syncable — losing the device loses only this convenience factor, not\n * the account (the passkey / recovery factors survive). Its public key goes into\n * the account's `cv:wd:` on-chain envelope slot; the DEK is ECIES-wrapped to\n * it so daily unlock is silent.\n *\n * `LocalDeviceUnwrapKey` holds a raw scalar (Node / tests / React Native secure\n * storage). The browser implementation wraps a non-extractable WebCrypto ECDH\n * key and overrides `unwrap` with `deriveBits`; it never exposes the scalar.\n */\nexport interface DeviceUnwrapKey {\n /** SEC1 *uncompressed* (65-byte) public key — the ECIES recipient key that is\n * published on-chain in the device's envelope slot. */\n publicKeySec1(): Uint8Array;\n /** A short, stable id for this device's envelope slot (`cv:wd:`). */\n slotId(): string;\n /** Unwrap the account DEK from this device's ECIES blob. */\n unwrap(blob: Uint8Array): Promise;\n}\n\n/** Raw-scalar device unwrap key (Node / React Native). */\nexport class LocalDeviceUnwrapKey implements DeviceUnwrapKey {\n private constructor(private readonly scalar: Uint8Array) {}\n\n /** Generate a fresh device unwrap key. */\n static generate(): LocalDeviceUnwrapKey {\n return new LocalDeviceUnwrapKey(p256.utils.randomPrivateKey());\n }\n\n /** Rebuild from a persisted 32-byte scalar. */\n static fromScalar(scalar: Uint8Array): LocalDeviceUnwrapKey {\n if (scalar.length !== 32) throw new Error(\"kit/stellar: device unwrap scalar must be 32 bytes\");\n return new LocalDeviceUnwrapKey(scalar);\n }\n\n /** The raw scalar, for the caller to persist in secure storage. */\n export(): Uint8Array {\n return this.scalar;\n }\n\n publicKeySec1(): Uint8Array {\n return p256.getPublicKey(this.scalar, false);\n }\n\n slotId(): string {\n return deviceSlotId(this.publicKeySec1());\n }\n\n async unwrap(blob: Uint8Array): Promise {\n return eciesUnwrapDEK(blob, this.scalar);\n }\n}\n\n/** Stable short slot id for a device's envelope entry: first 8 hex of\n * `sha256(pubkey)`. Deterministic from the public key, so it's the same on\n * every read and can't collide in practice for a handful of devices. */\nexport function deviceSlotId(publicKeySec1: Uint8Array): string {\n const h = sha256(publicKeySec1);\n let s = \"\";\n for (const b of h.subarray(0, 4)) s += b.toString(16).padStart(2, \"0\");\n return s;\n}\n\n/** For tests: a random slot id (when no key is involved). */\nexport function randomSlotId(): string {\n let s = \"\";\n for (const b of randomBytes(4)) s += b.toString(16).padStart(2, \"0\");\n return s;\n}\n","import { p256 } from \"@noble/curves/p256\";\nimport { eciesKEKFromX, unwrapDEK } from \"./envelope\";\nimport { deviceSlotId, type DeviceUnwrapKey } from \"./DeviceUnwrapKey\";\n\n// A dedicated database (not WebCryptoSigner's \"cavos-kit\") so the two never\n// collide on IndexedDB version numbers.\nconst IDB_NAME = \"cavos-kit-stellar\";\nconst IDB_STORE = \"unwrap-keys\";\n\nexport interface WebCryptoUnwrapKeyOptions {\n /** Storage key for this device's unwrap key (e.g. `${userId}:${appSalt}`). One\n * ECDH key per (this value, browser profile). */\n keyId: string;\n}\n\ninterface StoredUnwrapKey {\n privateKey: CryptoKey; // non-extractable ECDH key; structured-cloneable\n publicRaw: Uint8Array; // SEC1 uncompressed (65 bytes)\n}\n\n/**\n * Browser `DeviceUnwrapKey`: a non-extractable P-256 **ECDH** key generated with\n * WebCrypto and persisted in IndexedDB. Distinct from `WebCryptoSigner` (an ECDSA\n * signing key) — a signing key can't do ECDH, so the classic-G envelope needs its\n * own key here. The private key never leaves WebCrypto: the account DEK is\n * unwrapped via `deriveBits` (raw ECDH), then AES-GCM in `@noble` on the derived\n * KEK. Per-device, non-syncable → losing the device loses only this convenience\n * factor, never the account (the passkey / recovery factors survive).\n */\nexport class WebCryptoDeviceUnwrapKey implements DeviceUnwrapKey {\n private constructor(\n private readonly privateKey: CryptoKey,\n private readonly publicRaw: Uint8Array,\n readonly keyId: string,\n ) {}\n\n /** Create a fresh device unwrap key and persist it. */\n static async create(opts: WebCryptoUnwrapKeyOptions): Promise {\n assertSecureContext();\n const pair = await crypto.subtle.generateKey(\n { name: \"ECDH\", namedCurve: \"P-256\" },\n false, // private key is NON-extractable\n [\"deriveBits\"],\n );\n const publicRaw = new Uint8Array(await crypto.subtle.exportKey(\"raw\", pair.publicKey)); // 65 bytes\n await idbPut(opts.keyId, { privateKey: pair.privateKey, publicRaw });\n return new WebCryptoDeviceUnwrapKey(pair.privateKey, publicRaw, opts.keyId);\n }\n\n /** Load an existing device unwrap key, or null if none exists yet. */\n static async load(opts: WebCryptoUnwrapKeyOptions): Promise {\n const rec = await idbGet(opts.keyId);\n if (!rec) return null;\n return new WebCryptoDeviceUnwrapKey(rec.privateKey, rec.publicRaw, opts.keyId);\n }\n\n static async remove(keyId: string): Promise {\n if (typeof indexedDB === \"undefined\") return;\n const db = await openDb();\n await tx(db, \"readwrite\", (store) => store.delete(keyId));\n db.close();\n }\n\n /** Load the device unwrap key, creating one on first use. */\n static async loadOrCreate(opts: WebCryptoUnwrapKeyOptions): Promise {\n return (await WebCryptoDeviceUnwrapKey.load(opts)) ?? (await WebCryptoDeviceUnwrapKey.create(opts));\n }\n\n publicKeySec1(): Uint8Array {\n return this.publicRaw;\n }\n\n slotId(): string {\n return deviceSlotId(this.publicRaw);\n }\n\n async unwrap(blob: Uint8Array): Promise {\n const ephPubCompressed = blob.subarray(0, 33);\n const wrapped = blob.subarray(33);\n\n // WebCrypto only imports uncompressed points → decompress the ephemeral pubkey.\n const ephUncompressed = p256.ProjectivePoint.fromHex(ephPubCompressed).toRawBytes(false);\n const ephKey = await crypto.subtle.importKey(\n \"raw\",\n ephUncompressed as unknown as BufferSource,\n { name: \"ECDH\", namedCurve: \"P-256\" },\n false,\n [],\n );\n const sharedX = new Uint8Array(\n await crypto.subtle.deriveBits({ name: \"ECDH\", public: ephKey }, this.privateKey, 256),\n );\n const kek = eciesKEKFromX(sharedX, ephPubCompressed);\n return unwrapDEK(wrapped, kek);\n }\n}\n\nfunction assertSecureContext(): void {\n const ok =\n typeof crypto !== \"undefined\" &&\n typeof crypto.subtle !== \"undefined\" &&\n (typeof window === \"undefined\" || window.isSecureContext);\n if (!ok) {\n throw new Error(\n \"Cavos: WebCrypto is unavailable. Device keys require a secure context — use HTTPS, or http://localhost.\",\n );\n }\n}\n\n// --- minimal IndexedDB wrapper (mirrors WebCryptoSigner, separate store) ---\n\nfunction openDb(): Promise {\n return new Promise((resolve, reject) => {\n const req = indexedDB.open(IDB_NAME, 1);\n req.onupgradeneeded = () => req.result.createObjectStore(IDB_STORE);\n req.onsuccess = () => resolve(req.result);\n req.onerror = () => reject(req.error);\n });\n}\n\nasync function idbPut(keyId: string, value: StoredUnwrapKey): Promise {\n const db = await openDb();\n await tx(db, \"readwrite\", (store) => store.put(value, keyId));\n db.close();\n}\n\nasync function idbGet(keyId: string): Promise {\n const db = await openDb();\n const result = await tx(db, \"readonly\", (store) => store.get(keyId));\n db.close();\n return (result as StoredUnwrapKey) ?? null;\n}\n\nfunction tx(\n db: IDBDatabase,\n mode: IDBTransactionMode,\n run: (store: IDBObjectStore) => IDBRequest,\n): Promise {\n return new Promise((resolve, reject) => {\n const store = db.transaction(IDB_STORE, mode).objectStore(IDB_STORE);\n const req = run(store);\n req.onsuccess = () => resolve(req.result);\n req.onerror = () => reject(req.error);\n });\n}\n"]}