@cavos/kit 0.0.2 → 0.0.4

package/dist/chunk-F2J25XSL.mjs

@@ -0,0 +1,2946 @@
+import { p256 } from '@noble/curves/p256';
+import { sha256 } from '@noble/hashes/sha256';
+import { hash, num, Signer, RpcProvider, PaymasterRpc, Account as Account$1 } from 'starknet';
+import { PublicKey, TransactionInstruction, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, Transaction, Connection, sendAndConfirmTransaction } from '@solana/web3.js';
+import { hkdf } from '@noble/hashes/hkdf';
+import { pbkdf2 } from '@noble/hashes/pbkdf2';
+import { randomBytes } from '@noble/hashes/utils';
+import { rpc, hash as hash$1, xdr, Address, StrKey, nativeToScVal, Operation, scValToNative, Account, TransactionBuilder, BASE_FEE } from '@stellar/stellar-sdk';
+
+// src/crypto/encoding.ts
+var U128_MASK = (1n << 128n) - 1n;
+function u256ToFelts(value) {
+  return [value & U128_MASK, value >> 128n];
+}
+function bytesToBigInt(bytes) {
+  let out = 0n;
+  for (const b of bytes) out = out << 8n | BigInt(b);
+  return out;
+}
+function bytesToHex(bytes) {
+  let s = "0x";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const padded = clean.length % 2 ? "0" + clean : clean;
+  const out = new Uint8Array(padded.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(padded.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+function bytesToByteArrayCalldata(bytes) {
+  const CHUNK = 31;
+  const fullCount = Math.floor(bytes.length / CHUNK);
+  const out = [String(fullCount)];
+  for (let i = 0; i < fullCount; i++) {
+    out.push("0x" + bytesToBigInt(bytes.subarray(i * CHUNK, i * CHUNK + CHUNK)).toString(16));
+  }
+  const rem = bytes.subarray(fullCount * CHUNK);
+  out.push("0x" + (rem.length ? bytesToBigInt(rem).toString(16) : "0"));
+  out.push(String(rem.length));
+  return out;
+}
+function bigIntTo32Bytes(value) {
+  const out = new Uint8Array(32);
+  let v = value;
+  for (let i = 31; i >= 0; i--) {
+    out[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return out;
+}
+function signatureToFelts(sig) {
+  const [rLow, rHigh] = u256ToFelts(sig.r);
+  const [sLow, sHigh] = u256ToFelts(sig.s);
+  return [rLow, rHigh, sLow, sHigh, sig.yParity ? 1n : 0n];
+}
+function recoverYParity(r, s, digest, pubkey) {
+  for (const bit of [0, 1]) {
+    try {
+      const candidate = new p256.Signature(r, s).addRecoveryBit(bit);
+      const point = candidate.recoverPublicKey(digest).toAffine();
+      if (point.x === pubkey.x && point.y === pubkey.y) {
+        return bit === 1;
+      }
+    } catch {
+    }
+  }
+  throw new Error("kit/signature: could not recover parity for the given pubkey");
+}
+var IDB_NAME = "cavos-kit";
+var IDB_STORE = "device-keys";
+var WebCryptoSigner = class _WebCryptoSigner {
+  constructor(privateKey, publicKey, keyId) {
+    this.privateKey = privateKey;
+    this.publicKey = publicKey;
+    this.keyId = keyId;
+  }
+  /** Create a fresh device key (first run on this device) and persist it. */
+  static async create(opts) {
+    assertSecureContext();
+    const pair = await crypto.subtle.generateKey(
+      { name: "ECDSA", namedCurve: "P-256" },
+      false,
+      // private key is NON-extractable
+      ["sign", "verify"]
+    );
+    const publicKey = await exportPublicKey(pair.publicKey);
+    await idbPut(opts.keyId, { privateKey: pair.privateKey, x: publicKey.x, y: publicKey.y });
+    return new _WebCryptoSigner(pair.privateKey, publicKey, opts.keyId);
+  }
+  /** Load an existing device key from storage, or null if none exists yet. */
+  static async load(opts) {
+    const rec = await idbGet(opts.keyId);
+    if (!rec) return null;
+    return new _WebCryptoSigner(rec.privateKey, { x: rec.x, y: rec.y }, opts.keyId);
+  }
+  /** Load the device key, creating one on first use. */
+  static async loadOrCreate(opts) {
+    return await _WebCryptoSigner.load(opts) ?? await _WebCryptoSigner.create(opts);
+  }
+  async getPublicKey() {
+    return this.publicKey;
+  }
+  async sign(txHash) {
+    const raw = new Uint8Array(
+      await crypto.subtle.sign(
+        { name: "ECDSA", hash: "SHA-256" },
+        this.privateKey,
+        txHash
+      )
+    );
+    const r = bytesToBigInt(raw.subarray(0, 32));
+    const s = bytesToBigInt(raw.subarray(32, 64));
+    const digest = sha256(txHash);
+    const yParity = recoverYParity(r, s, digest, this.publicKey);
+    return { r, s, yParity };
+  }
+};
+async function exportPublicKey(publicKey) {
+  const raw = new Uint8Array(await crypto.subtle.exportKey("raw", publicKey));
+  return { x: bytesToBigInt(raw.subarray(1, 33)), y: bytesToBigInt(raw.subarray(33, 65)) };
+}
+function assertSecureContext() {
+  const ok = typeof crypto !== "undefined" && typeof crypto.subtle !== "undefined" && (typeof window === "undefined" || window.isSecureContext);
+  if (!ok) {
+    throw new Error(
+      "Cavos: WebCrypto is unavailable. Device keys require a secure context \u2014 use HTTPS, or http://localhost. (For LAN/mobile dev testing, run `next dev --experimental-https`.)"
+    );
+  }
+}
+function openDb() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(IDB_NAME, 1);
+    req.onupgradeneeded = () => req.result.createObjectStore(IDB_STORE);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbPut(keyId, value) {
+  const db = await openDb();
+  await tx(db, "readwrite", (store) => store.put(value, keyId));
+  db.close();
+}
+async function idbGet(keyId) {
+  const db = await openDb();
+  const result = await tx(db, "readonly", (store) => store.get(keyId));
+  db.close();
+  return result ?? null;
+}
+function tx(db, mode, run) {
+  return new Promise((resolve, reject) => {
+    const store = db.transaction(IDB_STORE, mode).objectStore(IDB_STORE);
+    const req = run(store);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+// src/chains/starknet/constants.ts
+var STARKNET_NETWORKS = {
+  sepolia: {
+    chainId: "0x534e5f5345504f4c4941",
+    // SN_SEPOLIA
+    rpcUrl: "https://api.cartridge.gg/x/starknet/sepolia"
+  },
+  mainnet: {
+    chainId: "0x534e5f4d41494e",
+    // SN_MAIN
+    rpcUrl: "https://api.cartridge.gg/x/starknet/mainnet"
+  }
+};
+var UDC_ADDRESS = "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf";
+var CAVOS_PAYMASTER_URL = {
+  sepolia: "https://sepolia-paymaster.cavos.xyz",
+  mainnet: "https://paymaster.cavos.xyz"
+};
+var DEVICE_ACCOUNT_CLASS_HASH = {
+  sepolia: "0x25cbc5423e8ee895febb0ef2c3945b408da44d0039d915fbdd681fe6b6ba66b",
+  mainnet: "0x1840aded59e8a0d2b440a134cb9079a7fc11b06c77f58ed189ab436a034ca6a"
+};
+var StarknetAdapter = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.chain = "starknet";
+  }
+  computeAddress({ addressSeed, initialSigner, salt }) {
+    return hash.calculateContractAddressFromHash(
+      num.toHex(salt ?? addressSeed),
+      this.opts.classHash,
+      this.constructorCalldata(addressSeed, initialSigner),
+      0
+      // deployerAddress 0 => deterministic counterfactual address
+    );
+  }
+  /** Single UDC deploy; the constructor registers the first device signer, so
+   * the account is ready the moment it is deployed (fits the paymaster's
+   * deploy + execute_from_outside bundle). */
+  buildDeploy(params) {
+    const salt = params.salt ?? params.addressSeed;
+    const calldata = this.constructorCalldata(params.addressSeed, params.initialSigner);
+    return [
+      {
+        contractAddress: UDC_ADDRESS,
+        entrypoint: "deployContract",
+        calldata: [
+          this.opts.classHash,
+          num.toHex(salt),
+          "0x0",
+          // unique = false -> deployer-independent address
+          num.toHex(calldata.length),
+          ...calldata
+        ]
+      }
+    ];
+  }
+  /** Constructor calldata: [address_seed, pub_x_low, pub_x_high, pub_y_low, pub_y_high]. */
+  constructorCalldata(addressSeed, initialSigner) {
+    return [num.toHex(addressSeed), ...pubkeyCalldata(initialSigner)];
+  }
+  buildAddSigner(accountAddress, signer) {
+    return { contractAddress: accountAddress, entrypoint: "add_signer", calldata: pubkeyCalldata(signer) };
+  }
+  buildRemoveSigner(accountAddress, signer) {
+    return { contractAddress: accountAddress, entrypoint: "remove_signer", calldata: pubkeyCalldata(signer) };
+  }
+  async isAuthorizedSigner(accountAddress, signer) {
+    if (!this.opts.provider) throw new Error("kit/starknet: provider required for reads");
+    const res = await this.opts.provider.callContract({
+      contractAddress: accountAddress,
+      entrypoint: "is_authorized_signer",
+      calldata: pubkeyCalldata(signer)
+    });
+    return BigInt(res[0] ?? 0) !== 0n;
+  }
+  async buildSignature(txHash) {
+    if (!this.opts.signer) throw new Error("kit/starknet: signer required to sign");
+    const sig = await this.opts.signer.sign(bigIntTo32Bytes(txHash));
+    return signatureToFelts(sig).map((f) => num.toHex(f));
+  }
+  // --- passkey approvers ---
+  buildAddApprover(accountAddress, passkey) {
+    return { contractAddress: accountAddress, entrypoint: "add_approver", calldata: pubkeyCalldata(passkey) };
+  }
+  buildRemoveApprover(accountAddress, passkey) {
+    return { contractAddress: accountAddress, entrypoint: "remove_approver", calldata: pubkeyCalldata(passkey) };
+  }
+  async isApprover(accountAddress, passkey) {
+    if (!this.opts.provider) throw new Error("kit/starknet: provider required for reads");
+    const res = await this.opts.provider.callContract({
+      contractAddress: accountAddress,
+      entrypoint: "is_approver",
+      calldata: pubkeyCalldata(passkey)
+    });
+    return BigInt(res[0] ?? 0) !== 0n;
+  }
+  /** True if the account has at least one passkey registered as an approver.
+   * Lets the UI decide whether to offer passkey approval before prompting. */
+  async hasPasskeyApprover(accountAddress) {
+    if (!this.opts.provider) throw new Error("kit/starknet: provider required for reads");
+    const res = await this.opts.provider.callContract({
+      contractAddress: accountAddress,
+      entrypoint: "get_approver_count",
+      calldata: []
+    });
+    return BigInt(res[0] ?? 0) > 0n;
+  }
+  async getPasskeyNonce(accountAddress) {
+    if (!this.opts.provider) throw new Error("kit/starknet: provider required for reads");
+    const res = await this.opts.provider.callContract({
+      contractAddress: accountAddress,
+      entrypoint: "get_passkey_nonce",
+      calldata: []
+    });
+    return BigInt(res[0] ?? 0);
+  }
+  /** This chain's leaf for approving `add_signer(newSigner)` at `nonce`:
+   * `sha256(new_x || new_y || nonce)` (coords 32B BE, nonce 16B BE). The batch
+   * challenge the passkey signs is `sha256(concat(leaves))` across chains. */
+  passkeyLeaf(newSigner, nonce) {
+    const msg = new Uint8Array(32 + 32 + 16);
+    msg.set(bigIntTo32Bytes(newSigner.x), 0);
+    msg.set(bigIntTo32Bytes(newSigner.y), 32);
+    msg.set(bigIntTo32Bytes(nonce).subarray(16), 64);
+    return sha256(msg);
+  }
+  /** Passkey-authorized `add_signer` call. `leaves`/`leafIndex` place this chain's
+   * leaf in the multi-chain batch (single chain → `[leaf]`, index 0). `yParity`
+   * matches the raw `(r, s)` — the contract normalizes high-S internally. */
+  buildAddSignerViaPasskey(accountAddress, newSigner, nonce, leaves, leafIndex, assertion, yParity) {
+    const [rl, rh] = u256ToFelts(assertion.r);
+    const [sl, sh] = u256ToFelts(assertion.s);
+    const leavesCalldata = [String(leaves.length)];
+    for (const leaf of leaves) {
+      const [lo, hi] = u256ToFelts(bytesToBigInt(leaf));
+      leavesCalldata.push(num.toHex(lo), num.toHex(hi));
+    }
+    return {
+      contractAddress: accountAddress,
+      entrypoint: "add_signer_via_passkey",
+      calldata: [
+        ...pubkeyCalldata(newSigner),
+        // new_x, new_y (u256 pairs)
+        num.toHex(nonce),
+        ...leavesCalldata,
+        // Array<u256> leaves
+        String(leafIndex),
+        ...bytesToByteArrayCalldata(assertion.authenticatorData),
+        ...bytesToByteArrayCalldata(assertion.clientDataJSON),
+        String(assertion.challengeOffset),
+        num.toHex(rl),
+        num.toHex(rh),
+        num.toHex(sl),
+        num.toHex(sh),
+        yParity ? "0x1" : "0x0"
+      ]
+    };
+  }
+};
+function pubkeyCalldata(pk) {
+  const [xl, xh] = u256ToFelts(pk.x);
+  const [yl, yh] = u256ToFelts(pk.y);
+  return [num.toHex(xl), num.toHex(xh), num.toHex(yl), num.toHex(yh)];
+}
+var StarknetDeviceSigner = class extends Signer {
+  constructor(device) {
+    super("0x1");
+    this.device = device;
+  }
+  /** Device accounts are not controlled by a single Stark pubkey. */
+  async getPubKey() {
+    return "0x0";
+  }
+  /** Sign the computed tx hash silently with the device signer. */
+  async signRaw(msgHash) {
+    const sig = await this.device.sign(bigIntTo32Bytes(BigInt(msgHash)));
+    return signatureToFelts(sig).map((f) => num.toHex(f));
+  }
+};
+
+// src/registry/WalletRegistry.ts
+var InMemoryWalletRegistry = class {
+  constructor() {
+    this.wallets = /* @__PURE__ */ new Map();
+  }
+  async lookup(userId) {
+    return this.wallets.get(userId) ?? null;
+  }
+  async register(params) {
+    this.wallets.set(params.userId, { address: params.address, devices: [params.initialSigner] });
+  }
+  async addDevice(params) {
+    const w = this.wallets.get(params.userId);
+    if (w) w.devices = [...w.devices ?? [], params.signer];
+  }
+};
+
+// src/registry/HttpWalletRegistry.ts
+function toHex(n) {
+  return "0x" + n.toString(16);
+}
+function fromHex(s) {
+  return BigInt(s);
+}
+var HttpWalletRegistry = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async lookup(userId) {
+    const url = new URL("/api/wallets", this.opts.baseUrl);
+    url.searchParams.set("app_id", this.opts.appId);
+    url.searchParams.set("user_social_id", userId);
+    url.searchParams.set("network", this.opts.network);
+    const res = await fetch(url, { headers: { "Content-Type": "application/json" } });
+    if (!res.ok) throw new Error(`registry lookup failed: ${res.status}`);
+    const data = await res.json();
+    if (!data.found || !data.address) return null;
+    const devices = Array.isArray(data.devices) ? data.devices.map((d) => ({
+      x: fromHex(d.pub_x),
+      y: fromHex(d.pub_y)
+    })) : void 0;
+    return { address: data.address, devices };
+  }
+  async register(params) {
+    const res = await fetch(new URL("/api/wallets", this.opts.baseUrl), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        app_id: this.opts.appId,
+        user_social_id: params.userId,
+        network: this.opts.network,
+        address: params.address,
+        // Device-signer wallets send their initial signer (no encrypted blob).
+        devices: [{ x: toHex(params.initialSigner.x), y: toHex(params.initialSigner.y) }]
+      })
+    });
+    if (!res.ok) {
+      const t = await res.text().catch(() => "");
+      throw new Error(`registry register failed: ${res.status} ${t}`);
+    }
+  }
+  async addDevice(params) {
+  }
+};
+function deriveAddressSeed({ userId, appSalt }) {
+  const h = hash.computePoseidonHashOnElements([feltFromString(userId), feltFromString(appSalt)]);
+  return BigInt(h);
+}
+function deriveAddressSeedSolana({ userId, appSalt }) {
+  return sha256(new TextEncoder().encode(`cavos:solana:v1:${userId}:${appSalt}`));
+}
+function deriveAddressSeedStellar({ userId, appSalt }) {
+  return sha256(new TextEncoder().encode(`cavos:stellar:v1:${userId}:${appSalt}`));
+}
+function feltFromString(s) {
+  const bytes = new TextEncoder().encode(s);
+  const chunks = [];
+  for (let i = 0; i < bytes.length; i += 31) {
+    let w = 0n;
+    for (const b of bytes.subarray(i, i + 31)) w = w << 8n | BigInt(b);
+    chunks.push(w);
+  }
+  if (chunks.length === 0) return 0n;
+  if (chunks.length === 1) return chunks[0];
+  return BigInt(hash.computePoseidonHashOnElements(chunks));
+}
+
+// src/chains/solana/constants.ts
+var DEVICE_ACCOUNT_PROGRAM_ID = "FHnoYNfYAmFrwt18gcBGG7G1S5q3RAbCBvrV2D29izNJ";
+var SECP256R1_PROGRAM_ID = "Secp256r1SigVerify1111111111111111111111111";
+var ACCOUNT_SEED = "cavos-account";
+var DOMAIN_ADD = "cavos:add_signer:v1";
+var DOMAIN_REMOVE = "cavos:remove_signer:v1";
+var DOMAIN_TRANSFER = "cavos:transfer:v1";
+var DOMAIN_EXECUTE = "cavos:execute:v1";
+var DOMAIN_ADD_APPROVER = "cavos:add_approver:v1";
+var DOMAIN_REMOVE_APPROVER = "cavos:remove_approver:v1";
+var SECP256R1_N = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n;
+var SOLANA_NETWORKS = {
+  "solana-devnet": "https://api.devnet.solana.com",
+  "solana-mainnet": "https://api.mainnet-beta.solana.com",
+  "solana-localnet": "http://127.0.0.1:8899"
+};
+var COMPRESSED_PUBKEY_SIZE = 33;
+var SIGNATURE_SIZE = 64;
+var CURRENT_IX = 65535;
+var SolanaAdapter = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.chain = "solana";
+    this.programId = new PublicKey(opts.programId ?? DEVICE_ACCOUNT_PROGRAM_ID);
+  }
+  /** Deterministic account address: PDA of [seed, address_seed, initial_signer_x]. */
+  computeAddress(addressSeed, initialSigner) {
+    return this.pda(addressSeed, compressedPubkey(initialSigner)).toBase58();
+  }
+  pda(addressSeed, initialCompressed) {
+    const [pda] = PublicKey.findProgramAddressSync(
+      [
+        Buffer.from(ACCOUNT_SEED),
+        Buffer.from(addressSeed),
+        Buffer.from(initialCompressed.slice(1, 33))
+        // x-coordinate
+      ],
+      this.programId
+    );
+    return pda;
+  }
+  /** `initialize` instruction creating the account with its first device signer. */
+  buildInitialize(addressSeed, payer, initialSigner) {
+    const initialCompressed = compressedPubkey(initialSigner);
+    const account = this.pda(addressSeed, initialCompressed);
+    const data = Buffer.concat([
+      anchorDiscriminator("initialize"),
+      Buffer.from(addressSeed),
+      // [u8;32]
+      Buffer.from(initialCompressed)
+      // [u8;33]
+    ]);
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: account, isSigner: false, isWritable: true },
+        { pubkey: new PublicKey(payer), isSigner: true, isWritable: true },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      ],
+      data
+    });
+  }
+  /** `[precompile, add_signer]` bundle, authorized by an existing device signer. */
+  async buildAddSigner(account, newSigner) {
+    const accountPk = new PublicKey(account);
+    const newCompressed = compressedPubkey(newSigner);
+    const nonce = await this.fetchNonce(accountPk);
+    const message = concatBytes(
+      Buffer.from(DOMAIN_ADD),
+      accountPk.toBuffer(),
+      newCompressed,
+      u64le(nonce)
+    );
+    const { precompileIx } = await this.signToPrecompile(message);
+    const ix = new TransactionInstruction({
+      programId: this.programId,
+      keys: this.guardedKeys(accountPk),
+      data: Buffer.concat([anchorDiscriminator("add_signer"), Buffer.from(newCompressed)])
+    });
+    return [precompileIx, ix];
+  }
+  /** `[precompile, remove_signer]` bundle, authorized by an existing device signer. */
+  async buildRemoveSigner(account, signer) {
+    const accountPk = new PublicKey(account);
+    const compressed = compressedPubkey(signer);
+    const nonce = await this.fetchNonce(accountPk);
+    const message = concatBytes(
+      Buffer.from(DOMAIN_REMOVE),
+      accountPk.toBuffer(),
+      compressed,
+      u64le(nonce)
+    );
+    const { precompileIx } = await this.signToPrecompile(message);
+    const ix = new TransactionInstruction({
+      programId: this.programId,
+      keys: this.guardedKeys(accountPk),
+      data: Buffer.concat([anchorDiscriminator("remove_signer"), Buffer.from(compressed)])
+    });
+    return [precompileIx, ix];
+  }
+  /** `[precompile, add_approver]` bundle enrolling a passkey approver (device-signed). */
+  async buildAddApprover(account, passkey) {
+    const accountPk = new PublicKey(account);
+    const compressed = compressedPubkey(passkey);
+    const nonce = await this.fetchNonce(accountPk);
+    const message = concatBytes(
+      Buffer.from(DOMAIN_ADD_APPROVER),
+      accountPk.toBuffer(),
+      compressed,
+      u64le(nonce)
+    );
+    const { precompileIx } = await this.signToPrecompile(message);
+    const ix = new TransactionInstruction({
+      programId: this.programId,
+      keys: this.guardedKeys(accountPk),
+      data: Buffer.concat([anchorDiscriminator("add_approver"), Buffer.from(compressed)])
+    });
+    return [precompileIx, ix];
+  }
+  /** `[precompile, remove_approver]` bundle (device-signed). */
+  async buildRemoveApprover(account, passkey) {
+    const accountPk = new PublicKey(account);
+    const compressed = compressedPubkey(passkey);
+    const nonce = await this.fetchNonce(accountPk);
+    const message = concatBytes(
+      Buffer.from(DOMAIN_REMOVE_APPROVER),
+      accountPk.toBuffer(),
+      compressed,
+      u64le(nonce)
+    );
+    const { precompileIx } = await this.signToPrecompile(message);
+    const ix = new TransactionInstruction({
+      programId: this.programId,
+      keys: this.guardedKeys(accountPk),
+      data: Buffer.concat([anchorDiscriminator("remove_approver"), Buffer.from(compressed)])
+    });
+    return [precompileIx, ix];
+  }
+  /** This chain's leaf for approving `add_signer(newSigner)` at `nonce`:
+   * `sha256(compressed(new_signer) || passkey_nonce_le8)`. The batch challenge the
+   * passkey signs is `sha256(concat(leaves))` across chains. */
+  passkeyLeaf(newSigner, nonce) {
+    return sha256(concatBytes(compressedPubkey(newSigner), u64le(nonce)));
+  }
+  /**
+   * `[precompile(passkey), add_signer_via_passkey]` bundle. The precompile ix
+   * verifies the PASSKEY's WebAuthn assertion over `authData || sha256(clientDataJSON)`;
+   * the program ix binds the challenge to `newSigner` + the passkey nonce and adds
+   * the signer. No device signature — a gasless relayer can submit it.
+   */
+  buildAddSignerViaPasskey(account, newSigner, passkey, leaves, leafIndex, assertion) {
+    const accountPk = new PublicKey(account);
+    const newCompressed = compressedPubkey(newSigner);
+    const passkeyCompressed = compressedPubkey(passkey);
+    const clientHash = sha256(assertion.clientDataJSON);
+    const message = concatBytes(assertion.authenticatorData, clientHash);
+    const signature = encodeLowSSignature(assertion.r, assertion.s);
+    const precompileIx = buildSecp256r1Instruction(passkeyCompressed, signature, message);
+    const leavesBlob = Buffer.concat([u32le(leaves.length), ...leaves.map((l) => Buffer.from(l))]);
+    const data = Buffer.concat([
+      anchorDiscriminator("add_signer_via_passkey"),
+      Buffer.from(newCompressed),
+      leavesBlob,
+      u32le(leafIndex),
+      serializeVecU8(assertion.authenticatorData),
+      serializeVecU8(assertion.clientDataJSON),
+      u32le(assertion.challengeOffset)
+    ]);
+    const ix = new TransactionInstruction({
+      programId: this.programId,
+      keys: this.guardedKeys(accountPk),
+      data
+    });
+    return [precompileIx, ix];
+  }
+  /** Read whether `passkey` is a registered approver. */
+  /** True if the account has at least one passkey registered as an approver. */
+  async hasPasskeyApprover(account) {
+    const approvers = await this.fetchApprovers(new PublicKey(account));
+    return approvers.length > 0;
+  }
+  async isApprover(account, passkey) {
+    const approvers = await this.fetchApprovers(new PublicKey(account));
+    const target = Buffer.from(compressedPubkey(passkey)).toString("hex");
+    return approvers.some((a) => Buffer.from(a).toString("hex") === target);
+  }
+  /** Read the current passkey-approval nonce. */
+  async passkeyNonce(account) {
+    const info = await this.requireConnection().getAccountInfo(new PublicKey(account));
+    if (!info) return 0n;
+    const d = info.data;
+    const signersLenOff = 8 + 32 + 1 + 8 + COMPRESSED_PUBKEY_SIZE;
+    const signerCount = d.readUInt32LE(signersLenOff);
+    const approversLenOff = signersLenOff + 4 + signerCount * COMPRESSED_PUBKEY_SIZE;
+    const approverCount = d.readUInt32LE(approversLenOff);
+    const passkeyNonceOff = approversLenOff + 4 + approverCount * COMPRESSED_PUBKEY_SIZE;
+    return readU64le(d, passkeyNonceOff);
+  }
+  /** `[precompile, execute_transfer]` bundle moving lamports out of the account. */
+  async buildExecuteTransfer(account, destination, amount) {
+    const accountPk = new PublicKey(account);
+    const destPk = new PublicKey(destination);
+    const nonce = await this.fetchNonce(accountPk);
+    const message = concatBytes(
+      Buffer.from(DOMAIN_TRANSFER),
+      accountPk.toBuffer(),
+      destPk.toBuffer(),
+      u64le(amount),
+      u64le(nonce)
+    );
+    const { precompileIx } = await this.signToPrecompile(message);
+    const ix = new TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: accountPk, isSigner: false, isWritable: true },
+        { pubkey: destPk, isSigner: false, isWritable: true },
+        { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false }
+      ],
+      data: Buffer.concat([anchorDiscriminator("execute_transfer"), u64le(amount)])
+    });
+    return [precompileIx, ix];
+  }
+  /**
+   * `[precompile, execute]` bundle running arbitrary CPI instructions with the
+   * account PDA as signer. The device key signs over
+   * `DOMAIN_EXECUTE || account || sha256(canonical(instructions)) || nonce`, so
+   * the signature commits to the EXACT instruction set the program will invoke —
+   * no account/data substitution is possible after signing.
+   *
+   * The instructions' accounts are passed to the program via `remaining_accounts`
+   * (flattened, in order); the program enforces an exact, ordered mapping.
+   */
+  async buildExecute(account, instructions) {
+    if (instructions.length === 0) throw new Error("kit/solana: execute requires at least one instruction");
+    const accountPk = new PublicKey(account);
+    const nonce = await this.fetchNonce(accountPk);
+    const blob = serializeInstructions(instructions);
+    const ixsHash = sha256(blob);
+    const message = concatBytes(
+      Buffer.from(DOMAIN_EXECUTE),
+      accountPk.toBuffer(),
+      Buffer.from(ixsHash),
+      u64le(nonce)
+    );
+    const { precompileIx } = await this.signToPrecompile(message);
+    const blobLen = Buffer.alloc(4);
+    new DataView(blobLen.buffer).setUint32(0, blob.length, true);
+    const data = Buffer.concat([anchorDiscriminator("execute"), blobLen, blob]);
+    const remainingAccounts = [];
+    for (const ix2 of instructions) {
+      for (const acc of ix2.accounts) {
+        remainingAccounts.push({
+          pubkey: new PublicKey(acc.pubkey),
+          isSigner: false,
+          // signer flags are part of the signed InstructionData
+          isWritable: acc.isWritable
+        });
+      }
+      remainingAccounts.push({
+        pubkey: new PublicKey(ix2.programId),
+        isSigner: false,
+        isWritable: false
+      });
+    }
+    const ix = new TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: accountPk, isSigner: false, isWritable: true },
+        { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+        ...remainingAccounts
+      ],
+      data
+    });
+    return [precompileIx, ix];
+  }
+  /** Read whether `signer` is currently an authorized signer of `account`. */
+  async isAuthorizedSigner(account, signer) {
+    const signers = await this.fetchSigners(new PublicKey(account));
+    const target = Buffer.from(compressedPubkey(signer)).toString("hex");
+    return signers.some((s) => Buffer.from(s).toString("hex") === target);
+  }
+  guardedKeys(account) {
+    return [
+      { pubkey: account, isSigner: false, isWritable: true },
+      { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false }
+    ];
+  }
+  /** Sign `message` with the device key and build the matching precompile ix. */
+  async signToPrecompile(message) {
+    if (!this.opts.signer) throw new Error("kit/solana: signer required to authorize");
+    const pubkey = await this.opts.signer.getPublicKey();
+    const sig = await this.opts.signer.sign(message);
+    const signature = encodeLowSSignature(sig.r, sig.s);
+    const precompileIx = buildSecp256r1Instruction(
+      compressedPubkey(pubkey),
+      signature,
+      message
+    );
+    return { precompileIx };
+  }
+  async fetchNonce(account) {
+    const info = await this.requireConnection().getAccountInfo(account);
+    if (!info) return 0n;
+    return readU64le(info.data, 41);
+  }
+  async fetchSigners(account) {
+    const info = await this.requireConnection().getAccountInfo(account);
+    if (!info) return [];
+    const d = info.data;
+    const lenOffset = 8 + 32 + 1 + 8 + COMPRESSED_PUBKEY_SIZE;
+    const count = d.readUInt32LE(lenOffset);
+    const out = [];
+    let off = lenOffset + 4;
+    for (let i = 0; i < count; i++) {
+      out.push(Uint8Array.from(d.subarray(off, off + COMPRESSED_PUBKEY_SIZE)));
+      off += COMPRESSED_PUBKEY_SIZE;
+    }
+    return out;
+  }
+  async fetchApprovers(account) {
+    const info = await this.requireConnection().getAccountInfo(account);
+    if (!info) return [];
+    const d = info.data;
+    const signersLenOff = 8 + 32 + 1 + 8 + COMPRESSED_PUBKEY_SIZE;
+    const signerCount = d.readUInt32LE(signersLenOff);
+    const approversLenOff = signersLenOff + 4 + signerCount * COMPRESSED_PUBKEY_SIZE;
+    const count = d.readUInt32LE(approversLenOff);
+    const out = [];
+    let off = approversLenOff + 4;
+    for (let i = 0; i < count; i++) {
+      out.push(Uint8Array.from(d.subarray(off, off + COMPRESSED_PUBKEY_SIZE)));
+      off += COMPRESSED_PUBKEY_SIZE;
+    }
+    return out;
+  }
+  requireConnection() {
+    if (!this.opts.connection) throw new Error("kit/solana: connection required for reads");
+    return this.opts.connection;
+  }
+};
+function compressedPubkey(pk) {
+  const out = new Uint8Array(COMPRESSED_PUBKEY_SIZE);
+  out[0] = pk.y % 2n === 0n ? 2 : 3;
+  out.set(bigIntTo32Bytes(pk.x), 1);
+  return out;
+}
+function encodeLowSSignature(r, s) {
+  const lowS2 = s > SECP256R1_N / 2n ? SECP256R1_N - s : s;
+  const out = new Uint8Array(SIGNATURE_SIZE);
+  out.set(bigIntTo32Bytes(r), 0);
+  out.set(bigIntTo32Bytes(lowS2), 32);
+  return out;
+}
+function buildSecp256r1Instruction(compressed, signature, message) {
+  const headerLen = 2;
+  const offsetsLen = 14;
+  const pubkeyOffset = headerLen + offsetsLen;
+  const sigOffset = pubkeyOffset + COMPRESSED_PUBKEY_SIZE;
+  const msgOffset = sigOffset + SIGNATURE_SIZE;
+  const data = Buffer.alloc(msgOffset + message.length);
+  data.writeUInt8(1, 0);
+  data.writeUInt8(0, 1);
+  let o = headerLen;
+  data.writeUInt16LE(sigOffset, o);
+  o += 2;
+  data.writeUInt16LE(CURRENT_IX, o);
+  o += 2;
+  data.writeUInt16LE(pubkeyOffset, o);
+  o += 2;
+  data.writeUInt16LE(CURRENT_IX, o);
+  o += 2;
+  data.writeUInt16LE(msgOffset, o);
+  o += 2;
+  data.writeUInt16LE(message.length, o);
+  o += 2;
+  data.writeUInt16LE(CURRENT_IX, o);
+  o += 2;
+  Buffer.from(compressed).copy(data, pubkeyOffset);
+  Buffer.from(signature).copy(data, sigOffset);
+  Buffer.from(message).copy(data, msgOffset);
+  return new TransactionInstruction({
+    keys: [],
+    programId: new PublicKey(SECP256R1_PROGRAM_ID),
+    data
+  });
+}
+function anchorDiscriminator(name) {
+  return Buffer.from(sha256(`global:${name}`).slice(0, 8));
+}
+function u32le(n) {
+  const b = Buffer.alloc(4);
+  b.writeUInt32LE(n);
+  return b;
+}
+function u64le(n) {
+  const b = Buffer.alloc(8);
+  new DataView(b.buffer, b.byteOffset, 8).setBigUint64(0, BigInt(n), true);
+  return b;
+}
+function readU64le(buf2, offset) {
+  return new DataView(buf2.buffer, buf2.byteOffset, buf2.length).getBigUint64(
+    offset,
+    true
+  );
+}
+function concatBytes(...parts) {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+function serializeInstruction(ix) {
+  const programId = new PublicKey(ix.programId).toBuffer();
+  const accounts = serializeAccounts(ix.accounts);
+  const data = serializeVecU8(ix.data);
+  return Buffer.concat([programId, accounts, data]);
+}
+function serializeAccounts(metas) {
+  const len = Buffer.alloc(4);
+  new DataView(len.buffer).setUint32(0, metas.length, true);
+  const parts = metas.map(serializeAccountMeta);
+  return Buffer.concat([len, ...parts]);
+}
+function serializeAccountMeta(meta) {
+  const pubkey = new PublicKey(meta.pubkey).toBuffer();
+  return Buffer.concat([pubkey, Buffer.from([meta.isSigner ? 1 : 0, meta.isWritable ? 1 : 0])]);
+}
+function serializeVecU8(data) {
+  const len = Buffer.alloc(4);
+  new DataView(len.buffer).setUint32(0, data.length, true);
+  return Buffer.concat([len, Buffer.from(data)]);
+}
+function serializeInstructions(instructions) {
+  return Buffer.concat(instructions.map(serializeInstruction));
+}
+var SolanaRelayer = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /** The relayer's fee-payer pubkey (fetched + cached from the backend). */
+  async getFeePayer() {
+    if (this.feePayer) return this.feePayer;
+    const res = await fetch(`${this.opts.baseUrl}/api/solana/relay?network=${this.opts.network}`);
+    if (!res.ok) throw new Error(`kit/solana: relayer fee-payer lookup failed (${res.status})`);
+    const { fee_payer } = await res.json();
+    this.feePayer = new PublicKey(fee_payer);
+    return this.feePayer;
+  }
+  /**
+   * Build a tx with the relayer as fee payer, serialize it unsigned, and POST it
+   * to the relayer to co-sign + submit. Returns the confirmed signature.
+   */
+  async send(instructions) {
+    const feePayer = await this.getFeePayer();
+    const { blockhash } = await this.opts.connection.getLatestBlockhash("confirmed");
+    const tx2 = new Transaction();
+    tx2.feePayer = feePayer;
+    tx2.recentBlockhash = blockhash;
+    tx2.add(...instructions);
+    const serialized = tx2.serialize({ requireAllSignatures: false, verifySignatures: false }).toString("base64");
+    const res = await fetch(`${this.opts.baseUrl}/api/solana/relay`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        app_id: this.opts.appId,
+        network: this.opts.network,
+        transaction: serialized
+      })
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`kit/solana: relay failed (${res.status}) ${detail}`);
+    }
+    const { signature } = await res.json();
+    return signature;
+  }
+};
+var BACKUP_KDF_SALT = "cavos-recovery-v1";
+var BACKUP_PBKDF2_ITERATIONS = 21e4;
+var BACKUP_HKDF_INFO = "cavos-backup-signer";
+var CODE_WORDS = 16;
+function generateRecoveryCode() {
+  const bytes = randomBytes(CODE_WORDS);
+  const words = [];
+  for (const b of bytes) words.push(WORDLIST[b]);
+  return words.join(" ");
+}
+function deriveBackupKey(code) {
+  const normalised = code.trim().replace(/\s+/g, " ").toLowerCase();
+  if (!normalised) throw new Error("kit: recovery code is empty");
+  const stretched = pbkdf2(
+    sha256,
+    new TextEncoder().encode(normalised),
+    new TextEncoder().encode(BACKUP_KDF_SALT),
+    { c: BACKUP_PBKDF2_ITERATIONS, dkLen: 32 }
+  );
+  const seed = hkdf(sha256, stretched, void 0, BACKUP_HKDF_INFO, 32);
+  const d = bytesToBigInt(seed) % p256.CURVE.n;
+  if (d === 0n) throw new Error("kit: derived backup key is zero (retry with a new code)");
+  const priv = bigIntTo32Bytes(d);
+  const pub = p256.getPublicKey(priv, false);
+  return {
+    privateKey: priv,
+    publicKey: { x: bytesToBigInt(pub.subarray(1, 33)), y: bytesToBigInt(pub.subarray(33, 65)) }
+  };
+}
+var BackupSigner = class _BackupSigner {
+  constructor(privateKey, publicKey) {
+    this.privateKey = privateKey;
+    this.publicKeyValue = publicKey;
+  }
+  /** Build a signer from a recovery code (derive + wrap in one step). */
+  static fromCode(code) {
+    const { privateKey, publicKey } = deriveBackupKey(code);
+    return new _BackupSigner(privateKey, publicKey);
+  }
+  async getPublicKey() {
+    return this.publicKeyValue;
+  }
+  async sign(txHash) {
+    const digest = sha256(txHash);
+    const sig = p256.sign(digest, this.privateKey);
+    const yParity = recoverYParity(sig.r, sig.s, digest, this.publicKeyValue);
+    return { r: sig.r, s: sig.s, yParity };
+  }
+};
+var WORDLIST = [
+  "able",
+  "acid",
+  "amber",
+  "apple",
+  "arch",
+  "arrow",
+  "ashen",
+  "atlas",
+  "axis",
+  "badge",
+  "baker",
+  "balm",
+  "banner",
+  "basin",
+  "beacon",
+  "bench",
+  "beryl",
+  "birch",
+  "blade",
+  "bloom",
+  "bluer",
+  "border",
+  "brave",
+  "brick",
+  "brook",
+  "cabin",
+  "candle",
+  "carbon",
+  "cargo",
+  "cedar",
+  "chalk",
+  "charm",
+  "chrome",
+  "cipher",
+  "clam",
+  "clasp",
+  "cliff",
+  "clock",
+  "cobia",
+  "comet",
+  "coral",
+  "cotton",
+  "coves",
+  "crane",
+  "crest",
+  "crow",
+  "crystal",
+  "curio",
+  "dawn",
+  "delta",
+  "denim",
+  "depth",
+  "dewy",
+  "digger",
+  "docks",
+  "dover",
+  "drift",
+  "dunes",
+  "eagle",
+  "ember",
+  "echo",
+  "eden",
+  "elite",
+  "ethic",
+  "fable",
+  "falcon",
+  "fawn",
+  "feather",
+  "fern",
+  "fjord",
+  "flame",
+  "flint",
+  "forest",
+  "forge",
+  "frost",
+  "garnet",
+  "gemini",
+  "glade",
+  "glider",
+  "glow",
+  "granite",
+  "grove",
+  "guppy",
+  "harbor",
+  "haven",
+  "hazel",
+  "helio",
+  "heron",
+  "hickory",
+  "honey",
+  "horizon",
+  "ivory",
+  "jade",
+  "jasper",
+  "kestrel",
+  "knot",
+  "lagoon",
+  "lattice",
+  "laurel",
+  "lavender",
+  "lemon",
+  "linden",
+  "loon",
+  "luger",
+  "lumen",
+  "lunar",
+  "mango",
+  "maple",
+  "marble",
+  "marsh",
+  "meadow",
+  "mercy",
+  "mistle",
+  "monsoon",
+  "morning",
+  "moss",
+  "nacre",
+  "nectar",
+  "needle",
+  "nimbus",
+  "nova",
+  "ocean",
+  "onyx",
+  "orbit",
+  "otter",
+  "palm",
+  "panda",
+  "pansy",
+  "papaya",
+  "passage",
+  "pebble",
+  "pelican",
+  "pepper",
+  "petal",
+  "piano",
+  "pierce",
+  "pilot",
+  "pioneer",
+  "platinum",
+  "plume",
+  "poplar",
+  "porpoise",
+  "prairie",
+  "prism",
+  "pulsar",
+  "quartz",
+  "quasar",
+  "quill",
+  "quiver",
+  "raven",
+  "reef",
+  "relic",
+  "ridge",
+  "ripple",
+  "robin",
+  "rocket",
+  "rouge",
+  "ruby",
+  "saffron",
+  "sage",
+  "sail",
+  "salmon",
+  "sapphire",
+  "scarab",
+  "shadow",
+  "shale",
+  "sienna",
+  "silica",
+  "silver",
+  "skyline",
+  "slate",
+  "sonar",
+  "spruce",
+  "starling",
+  "stone",
+  "sugar",
+  "summit",
+  "sunset",
+  "swan",
+  "tangent",
+  "tarragon",
+  "temple",
+  "thistle",
+  "thrush",
+  "tiger",
+  "topaz",
+  "tundra",
+  "turtle",
+  "umber",
+  "union",
+  "valley",
+  "vapor",
+  "vector",
+  "velvet",
+  "violet",
+  "vortex",
+  "walnut",
+  "whale",
+  "winter",
+  "wisp",
+  "wisteria",
+  "xenon",
+  "yarrow",
+  "zephyr",
+  "zinc",
+  "zodiac",
+  "anchor",
+  "basil",
+  "cider",
+  "daisy",
+  "elfin",
+  "ferry",
+  "gimlet",
+  "halcyon",
+  "indigo",
+  "juniper",
+  "kindle",
+  "lilac",
+  "mantis",
+  "nylon",
+  "oracle",
+  "parch",
+  "quokka",
+  "ramble",
+  "thatch",
+  "ultra",
+  "vivid",
+  "xylo",
+  "yodel",
+  "zesty",
+  "arbor",
+  "bliss",
+  "calyx",
+  "dwindle",
+  "folio",
+  "globe",
+  "hymn",
+  "ionic",
+  "jolly",
+  "knack",
+  "lyric",
+  "myrtle",
+  "noble",
+  "plumb",
+  "quaint",
+  "rustic",
+  "satin",
+  "timber",
+  "urge",
+  "vault",
+  "whimsy",
+  "yearn",
+  "zenith",
+  "ash",
+  "beach",
+  "dusk"
+];
+function base64urlEncode(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  const b64 = typeof btoa !== "undefined" ? btoa(bin) : Buffer.from(bytes).toString("base64");
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function derToRs(der) {
+  let i = 0;
+  if (der[i++] !== 48) throw new Error("kit/webauthn: bad DER (no SEQUENCE)");
+  if (der[i] & 128) i += 1 + (der[i] & 127);
+  else i += 1;
+  if (der[i++] !== 2) throw new Error("kit/webauthn: bad DER (no r INTEGER)");
+  const rlen = der[i++];
+  const r = bytesToBigInt(der.subarray(i, i + rlen));
+  i += rlen;
+  if (der[i++] !== 2) throw new Error("kit/webauthn: bad DER (no s INTEGER)");
+  const slen = der[i++];
+  const s = bytesToBigInt(der.subarray(i, i + slen));
+  return { r, s };
+}
+function spkiToPublicKey(spki) {
+  const idx = spki.lastIndexOf(4, spki.length - 65);
+  const start = spki.length - 65;
+  const prefix = spki[start];
+  if (prefix !== 4) {
+    if (idx < 0) throw new Error("kit/webauthn: no uncompressed EC point in SPKI");
+    return { x: bytesToBigInt(spki.subarray(idx + 1, idx + 33)), y: bytesToBigInt(spki.subarray(idx + 33, idx + 65)) };
+  }
+  return {
+    x: bytesToBigInt(spki.subarray(start + 1, start + 33)),
+    y: bytesToBigInt(spki.subarray(start + 33, start + 65))
+  };
+}
+function batchChallenge(leaves) {
+  const total = leaves.reduce((n, l) => n + l.length, 0);
+  const cat = new Uint8Array(total);
+  let o = 0;
+  for (const l of leaves) {
+    cat.set(l, o);
+    o += l.length;
+  }
+  return sha256(cat);
+}
+function webauthnDigest(authenticatorData, clientDataJSON) {
+  const clientHash = sha256(clientDataJSON);
+  const msg = new Uint8Array(authenticatorData.length + clientHash.length);
+  msg.set(authenticatorData, 0);
+  msg.set(clientHash, authenticatorData.length);
+  return sha256(msg);
+}
+function recoverCandidatePublicKeys(r, s, digest) {
+  const out = [];
+  for (const bit of [0, 1]) {
+    try {
+      const point = new p256.Signature(r, s).addRecoveryBit(bit).recoverPublicKey(digest).toAffine();
+      out.push({ publicKey: { x: point.x, y: point.y }, yParity: bit === 1 });
+    } catch {
+    }
+  }
+  return out;
+}
+function lowS(s) {
+  const n = p256.CURVE.n;
+  return s > n / 2n ? n - s : s;
+}
+function challengeOffsetOf(clientDataJSON, challengeB64) {
+  const text = new TextDecoder().decode(clientDataJSON);
+  const idx = text.indexOf(challengeB64);
+  if (idx < 0) throw new Error("kit/webauthn: challenge not found in clientDataJSON");
+  return idx;
+}
+var CavosSolana = class _CavosSolana {
+  constructor(identity, address, status, connection, adapter, devicePubkey, relayer, feePayer) {
+    this.identity = identity;
+    this.address = address;
+    this.status = status;
+    this.connection = connection;
+    this.adapter = adapter;
+    this.devicePubkey = devicePubkey;
+    this.relayer = relayer;
+    this.feePayer = feePayer;
+    /** Discriminant for the `CavosWallet` union — narrows `execute()` per chain. */
+    this.chain = "solana";
+    /** True when this connect just created a brand-new account (first sign-up). */
+    this.isNewAccount = false;
+  }
+  get publicKey() {
+    return this.devicePubkey;
+  }
+  static async connect(opts) {
+    const identity = opts.identity ?? await opts.auth?.authenticate();
+    if (!identity) throw new Error("kit/solana: connect requires `identity` or `auth`");
+    if (opts.network === "solana-mainnet" && !opts.rpcUrl) {
+      console.warn(
+        "[cavos] Using the public mainnet-beta RPC. Pass `rpcUrl` with your own provider (Helius/Triton/QuickNode) for production \u2014 the public endpoint is rate-limited."
+      );
+    }
+    const connection = new Connection(opts.rpcUrl ?? SOLANA_NETWORKS[opts.network], "confirmed");
+    const signer = opts.createSigner ? await opts.createSigner(`${identity.userId}:${opts.appSalt}`) : await WebCryptoSigner.loadOrCreate({ keyId: `${identity.userId}:${opts.appSalt}` });
+    const devicePubkey = await signer.getPublicKey();
+    const adapter = new SolanaAdapter({ programId: opts.programId, connection, signer });
+    const addressSeed = deriveAddressSeedSolana({ userId: identity.userId, appSalt: opts.appSalt });
+    const backendUrl = opts.backendUrl ?? "https://cavos.xyz";
+    const registry = opts.registry ?? (opts.appId ? new HttpWalletRegistry({ baseUrl: backendUrl, appId: opts.appId, network: opts.network }) : defaultRegistry);
+    const relayer = opts.relayer ?? (opts.appId ? new SolanaRelayer({ baseUrl: backendUrl, appId: opts.appId, network: opts.network, connection }) : void 0);
+    const existing = await registry.lookup(identity.userId);
+    if (existing) {
+      const isSigner2 = await adapter.isAuthorizedSigner(existing.address, devicePubkey);
+      return new _CavosSolana(
+        identity,
+        existing.address,
+        isSigner2 ? "ready" : "needs-device-approval",
+        connection,
+        adapter,
+        devicePubkey,
+        relayer,
+        opts.feePayer
+      );
+    }
+    const address = adapter.computeAddress(addressSeed, devicePubkey);
+    const deployed = await connection.getAccountInfo(new PublicKey(address)) !== null;
+    if (!deployed) {
+      if (relayer) {
+        const payer = await relayer.getFeePayer();
+        const ix = adapter.buildInitialize(addressSeed, payer.toBase58(), devicePubkey);
+        await relayer.send([ix]);
+      } else if (opts.feePayer) {
+        const ix = adapter.buildInitialize(addressSeed, opts.feePayer.publicKey.toBase58(), devicePubkey);
+        await sendAndConfirmTransaction(connection, new Transaction().add(ix), [opts.feePayer]);
+      } else {
+        throw new Error("kit/solana: a relayer (appId) or feePayer is required to initialize a new account");
+      }
+    }
+    await registry.register({ userId: identity.userId, address, initialSigner: devicePubkey });
+    const isSigner = await adapter.isAuthorizedSigner(address, devicePubkey);
+    const wallet = new _CavosSolana(
+      identity,
+      address,
+      isSigner ? "ready" : "needs-device-approval",
+      connection,
+      adapter,
+      devicePubkey,
+      relayer,
+      opts.feePayer
+    );
+    wallet.isNewAccount = !deployed && isSigner;
+    return wallet;
+  }
+  /** Authorize an additional device signer (device-signed via precompile). */
+  async addSigner(pubkey) {
+    const ixs = await this.adapter.buildAddSigner(this.address, pubkey);
+    return this.send(ixs);
+  }
+  /**
+   * Enroll a passkey as an approver (2FA-style step-up). Device-signed + gasless;
+   * requires a ready device. Idempotent. Returns the passkey pubkey + tx hash.
+   */
+  async enrollPasskey(passkey, params) {
+    const enrolled = await passkey.enroll(params);
+    const { transactionHash } = await this.addApprover(enrolled.publicKey);
+    return { publicKey: enrolled.publicKey, transactionHash };
+  }
+  /** Register an already-enrolled passkey pubkey as an approver (gasless).
+   * Idempotent. Lets one passkey be registered across chains without re-prompting. */
+  async addApprover(pubkey) {
+    if (this.status !== "ready") {
+      throw new Error("kit/solana: addApprover requires a ready, authorized device");
+    }
+    if (await this.adapter.isApprover(this.address, pubkey)) return {};
+    const ixs = await this.adapter.buildAddApprover(this.address, pubkey);
+    const transactionHash = await this.send(ixs);
+    return { transactionHash };
+  }
+  /** True if this account already has a passkey enrolled as an approver, so a
+   * new device can be approved with the passkey instead of the email flow. */
+  async hasPasskey() {
+    return this.adapter.hasPasskeyApprover(this.address);
+  }
+  /** Re-read (from chain) whether THIS device is now an authorized signer.
+   * Used to poll for readiness after a passkey approval before it's indexed. */
+  async isReady() {
+    return this.adapter.isAuthorizedSigner(this.address, this.devicePubkey);
+  }
+  /**
+   * From a fresh browser (status `needs-device-approval`), approve adding THIS
+   * device with the user's synced passkey. Gasless via the relayer — the bundle
+   * carries the passkey's WebAuthn assertion, so no device signature is needed.
+   */
+  async approveThisDeviceWithPasskey(passkey) {
+    if (this.status === "ready") {
+      throw new Error("kit/solana: this device is already an authorized signer");
+    }
+    const { leaf, nonce } = await this.passkeyLeafForThisDevice();
+    const leaves = [leaf];
+    const assertion = await passkey.assert(batchChallenge(leaves));
+    const { transactionHash } = await this.submitPasskeyApproval(assertion, leaves, 0, nonce);
+    return transactionHash;
+  }
+  /** This device's leaf + passkey nonce for a (possibly multi-chain) batch. */
+  async passkeyLeafForThisDevice() {
+    const nonce = await this.adapter.passkeyNonce(this.address);
+    return { leaf: this.adapter.passkeyLeaf(this.devicePubkey, nonce), nonce };
+  }
+  /** Submit `add_signer_via_passkey` given a shared assertion + batch position.
+   * Used by `approveThisDeviceWithPasskey` and `approveDeviceEverywhere`. */
+  async submitPasskeyApproval(assertion, leaves, leafIndex, _nonce) {
+    const digest = webauthnDigest(assertion.authenticatorData, assertion.clientDataJSON);
+    const candidates = recoverCandidatePublicKeys(assertion.r, assertion.s, digest);
+    let approver = null;
+    for (const cand of candidates) {
+      if (await this.adapter.isApprover(this.address, cand.publicKey)) {
+        approver = cand.publicKey;
+        break;
+      }
+    }
+    if (!approver) throw new Error("kit/solana: this passkey is not a registered approver");
+    const ixs = this.adapter.buildAddSignerViaPasskey(
+      this.address,
+      this.devicePubkey,
+      approver,
+      leaves,
+      leafIndex,
+      assertion
+    );
+    return { transactionHash: await this.send(ixs) };
+  }
+  /** Move `amount` lamports out of the account to `destination` (device-signed). */
+  async execute(amount, destination) {
+    if (this.status !== "ready") {
+      throw new Error("kit/solana: this device is not yet an authorized signer of the wallet");
+    }
+    const ixs = await this.adapter.buildExecuteTransfer(this.address, destination, amount);
+    return this.send(ixs);
+  }
+  /**
+   * Run arbitrary CPI `instructions` with the account PDA as signer (device-
+   * signed). The signature commits to sha256 of the canonical Borsh
+   * serialization of the instructions, so it binds exactly the operations the
+   * program will invoke. Unlocks SPL transfers, swaps, staking, etc.
+   *
+   * What the relayer will sponsor is constrained by the app's Solana program
+   * allowlist (configured in the dashboard) — programs outside the allowlist are
+   * rejected before co-signing.
+   */
+  async executeInstructions(instructions) {
+    if (this.status !== "ready") {
+      throw new Error("kit/solana: this device is not yet an authorized signer of the wallet");
+    }
+    const ixs = await this.adapter.buildExecute(this.address, instructions);
+    return this.send(ixs);
+  }
+  /**
+   * Register the backup signer derived from `code` as an authorized signer of this
+   * account (device-signed via precompile). Idempotent: returns without a tx if
+   * the backup signer is already registered. The code never leaves the device —
+   * only the derived public key travels on-chain.
+   *
+   * Self-custodial: anyone who can re-derive the backup key from the code (i.e.
+   * the rightful owner) can later recover the account with `CavosSolana.recover`.
+   * Run this once, on a registered device, and have the user store the code.
+   */
+  async setupRecovery(code) {
+    if (this.status !== "ready") {
+      throw new Error("kit/solana: setupRecovery requires a ready, registered device");
+    }
+    const { publicKey: backupPubkey } = deriveBackupKey(code);
+    const already = await this.adapter.isAuthorizedSigner(this.address, backupPubkey);
+    if (already) return void 0;
+    return this.addSigner(backupPubkey);
+  }
+  /**
+   * Recover an account after losing every device signer. Derives the backup key
+   * from `code`, uses it (not the new device key) to sign an `add_signer` for the
+   * new device, and returns a ready CavosSolana bound to the new device. The
+   * account address is unchanged.
+   *
+   * Self-custodial: only someone holding the code (i.e. the rightful owner) can
+   * re-derive the backup key. The backend never sees the code.
+   *
+   * This mirrors `Cavos.recover` (Starknet): the backup key is just another
+   * authorized signer, so recovery is an `add_signer(newDevice)` bundle signed by
+   * the backup key. The on-chain program needs no recovery-specific entrypoint.
+   */
+  static async recover(opts) {
+    if (opts.network === "solana-mainnet" && !opts.rpcUrl) {
+      console.warn(
+        "[cavos] Using the public mainnet-beta RPC. Pass `rpcUrl` with your own provider (Helius/Triton/QuickNode) for production \u2014 the public endpoint is rate-limited."
+      );
+    }
+    const connection = new Connection(opts.rpcUrl ?? SOLANA_NETWORKS[opts.network], "confirmed");
+    const signer = opts.createSigner ? await opts.createSigner(`${opts.identity.userId}:${opts.appSalt}`) : await WebCryptoSigner.loadOrCreate({ keyId: `${opts.identity.userId}:${opts.appSalt}` });
+    const devicePubkey = await signer.getPublicKey();
+    const backup = BackupSigner.fromCode(opts.code);
+    const backupAdapter = new SolanaAdapter({
+      programId: opts.programId,
+      connection,
+      signer: backup
+    });
+    const backendUrl = opts.backendUrl ?? "https://cavos.xyz";
+    const registry = opts.registry ?? (opts.appId ? new HttpWalletRegistry({ baseUrl: backendUrl, appId: opts.appId, network: opts.network }) : defaultRegistry);
+    const existing = await registry.lookup(opts.identity.userId);
+    if (!existing) {
+      throw new Error("kit/solana: no account found for this identity \u2014 nothing to recover");
+    }
+    const relayer = opts.relayer ?? (opts.appId ? new SolanaRelayer({ baseUrl: backendUrl, appId: opts.appId, network: opts.network, connection }) : void 0);
+    const alreadyAuthed = await backupAdapter.isAuthorizedSigner(existing.address, devicePubkey);
+    if (!alreadyAuthed) {
+      const ixs = await backupAdapter.buildAddSigner(existing.address, devicePubkey);
+      if (relayer) {
+        await relayer.send(ixs);
+      } else if (opts.feePayer) {
+        await sendAndConfirmTransaction(connection, new Transaction().add(...ixs), [opts.feePayer]);
+      } else {
+        throw new Error("kit/solana: a relayer (appId) or feePayer is required to recover");
+      }
+    }
+    const adapter = new SolanaAdapter({ programId: opts.programId, connection, signer });
+    return new _CavosSolana(
+      opts.identity,
+      existing.address,
+      "ready",
+      connection,
+      adapter,
+      devicePubkey,
+      relayer,
+      opts.feePayer
+    );
+  }
+  async send(ixs) {
+    if (this.relayer) return this.relayer.send(ixs);
+    if (this.feePayer) {
+      return sendAndConfirmTransaction(this.connection, new Transaction().add(...ixs), [this.feePayer]);
+    }
+    throw new Error("kit/solana: no relayer or feePayer configured to submit transactions");
+  }
+};
+var defaultRegistry = new InMemoryWalletRegistry();
+
+// src/chains/stellar/constants.ts
+var FACTORY_CONTRACT_ID = {
+  // Re-deployed 2026-07-01 with the passkey-approval device-account wasm (batched
+  // multi-chain challenge). The factory pins the wasm hash immutably, so a new
+  // wasm needs a new factory → new account addresses; testnet has no prod wallets.
+  "stellar-testnet": "CBCJIODXIEBOXXD66KCUCF7ZDYJARKI4ZIVQOVWPULOBH5XGNCDP6W3I",
+  // Set once the factory is deployed to mainnet (its address differs — network id
+  // is part of contract-address derivation).
+  "stellar-mainnet": ""
+};
+var DEVICE_ACCOUNT_WASM_HASH = {
+  "stellar-testnet": "2671b085578e59a385ef5a5664e42f0450322fe3249539f588e1263ed5a31dce",
+  "stellar-mainnet": ""
+};
+var STELLAR_NETWORKS = {
+  "stellar-testnet": {
+    rpcUrl: "https://soroban-testnet.stellar.org",
+    passphrase: "Test SDF Network ; September 2015"
+  },
+  "stellar-mainnet": {
+    rpcUrl: "https://soroban-rpc.mainnet.stellar.gateway.fm",
+    passphrase: "Public Global Stellar Network ; September 2015"
+  }
+};
+var NATIVE_SAC_ID = {
+  "stellar-testnet": "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC",
+  "stellar-mainnet": "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA"
+};
+var SECP256R1_N2 = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n;
+var StellarAdapter = class {
+  constructor(opts) {
+    this.chain = "stellar";
+    this.network = opts.network;
+    this.passphrase = STELLAR_NETWORKS[opts.network].passphrase;
+    this.rpcUrl = opts.rpcUrl ?? STELLAR_NETWORKS[opts.network].rpcUrl;
+    this.factoryId = opts.factoryId ?? FACTORY_CONTRACT_ID[opts.network];
+    if (!this.factoryId) {
+      throw new Error(`kit/stellar: no factory contract id configured for ${opts.network}`);
+    }
+    this.signer = opts.signer;
+  }
+  server() {
+    if (!this._server) {
+      this._server = new rpc.Server(this.rpcUrl, {
+        allowHttp: this.rpcUrl.startsWith("http://")
+      });
+    }
+    return this._server;
+  }
+  networkId() {
+    return hash$1(Buffer.from(this.passphrase));
+  }
+  /**
+   * Deterministic account address for `(addressSeed, initialSigner)` — computed
+   * off-chain, byte-identical to the factory's on-chain `account_address`.
+   * `contractId = sha256(HashIdPreimage(networkId, factory, salt))` with
+   * `salt = sha256(addressSeed || sec1(initialSigner))`.
+   */
+  computeAddress(addressSeed, initialSigner) {
+    const salt = this.accountSalt(addressSeed, initialSigner);
+    const preimage = xdr.HashIdPreimage.envelopeTypeContractId(
+      new xdr.HashIdPreimageContractId({
+        networkId: this.networkId(),
+        contractIdPreimage: xdr.ContractIdPreimage.contractIdPreimageFromAddress(
+          new xdr.ContractIdPreimageFromAddress({
+            address: new Address(this.factoryId).toScAddress(),
+            salt
+          })
+        )
+      })
+    );
+    return StrKey.encodeContract(hash$1(preimage.toXDR()));
+  }
+  /** `salt = sha256(addressSeed(32) || sec1(initialSigner)(65))` — matches the factory. */
+  accountSalt(addressSeed, initialSigner) {
+    return hash$1(Buffer.concat([Buffer.from(addressSeed), Buffer.from(sec1Pubkey(initialSigner))]));
+  }
+  /** Host function: `factory.deploy(address_seed, initial_signer)`. */
+  buildDeploy(addressSeed, initialSigner) {
+    return invokeFunc(this.factoryId, "deploy", [
+      bytesScVal(addressSeed),
+      bytesScVal(sec1Pubkey(initialSigner))
+    ]);
+  }
+  /** Host function: `account.add_signer(new_signer)` (requires device auth). */
+  buildAddSigner(accountAddress, signer) {
+    return invokeFunc(accountAddress, "add_signer", [bytesScVal(sec1Pubkey(signer))]);
+  }
+  /** Host function: `account.remove_signer(signer)` (requires device auth). */
+  buildRemoveSigner(accountAddress, signer) {
+    return invokeFunc(accountAddress, "remove_signer", [bytesScVal(sec1Pubkey(signer))]);
+  }
+  /** Host function: `account.add_approver(passkey)` (requires device auth). */
+  buildAddApprover(accountAddress, passkey) {
+    return invokeFunc(accountAddress, "add_approver", [bytesScVal(sec1Pubkey(passkey))]);
+  }
+  /** Host function: `account.remove_approver(passkey)` (requires device auth). */
+  buildRemoveApprover(accountAddress, passkey) {
+    return invokeFunc(accountAddress, "remove_approver", [bytesScVal(sec1Pubkey(passkey))]);
+  }
+  /** This chain's leaf for approving `add_signer(newSigner)` at `nonce`:
+   * `sha256(sec1(new_signer) || nonce_be8)`. The batch challenge the passkey signs
+   * is `sha256(concat(leaves))` across chains. */
+  passkeyLeaf(newSigner, nonce) {
+    const msg = new Uint8Array(65 + 8);
+    msg.set(sec1Pubkey(newSigner), 0);
+    const n = new Uint8Array(8);
+    let v = nonce;
+    for (let i = 7; i >= 0; i--) {
+      n[i] = Number(v & 0xffn);
+      v >>= 8n;
+    }
+    msg.set(n, 65);
+    return sha256(msg);
+  }
+  /** Host function: passkey-authorized `add_signer_via_passkey` (no device auth —
+   * authorized by the embedded WebAuthn assertion, so any relayer can submit).
+   * `leaves`/`leafIndex` place this chain's leaf in the multi-chain batch. */
+  buildAddSignerViaPasskey(accountAddress, newSigner, passkey, nonce, leaves, leafIndex, assertion) {
+    const sig = encodeLowSSignature2({ r: assertion.r, s: assertion.s});
+    const leavesScVal = xdr.ScVal.scvVec(leaves.map((l) => bytesScVal(l)));
+    return invokeFunc(accountAddress, "add_signer_via_passkey", [
+      bytesScVal(sec1Pubkey(newSigner)),
+      bytesScVal(sec1Pubkey(passkey)),
+      nativeToScVal(nonce, { type: "u64" }),
+      leavesScVal,
+      nativeToScVal(leafIndex, { type: "u32" }),
+      bytesScVal(assertion.authenticatorData),
+      bytesScVal(assertion.clientDataJSON),
+      nativeToScVal(assertion.challengeOffset, { type: "u32" }),
+      bytesScVal(sig)
+    ]);
+  }
+  /** Read whether `passkey` is a registered approver (read-only simulation). */
+  /** True if the account has at least one passkey registered as an approver.
+   * Reads the contract's `approvers` view and checks the list is non-empty. */
+  async hasPasskeyApprover(accountAddress, readSource) {
+    if (!await this.isDeployed(accountAddress)) return false;
+    const { Account: Account3, TransactionBuilder: TransactionBuilder2, BASE_FEE: BASE_FEE2 } = await import('@stellar/stellar-sdk');
+    const src = new Account3(readSource, "0");
+    const op = Operation.invokeHostFunction({
+      func: invokeFunc(accountAddress, "approvers", []),
+      auth: []
+    });
+    const tx2 = new TransactionBuilder2(src, { fee: BASE_FEE2, networkPassphrase: this.passphrase }).addOperation(op).setTimeout(30).build();
+    const sim = await this.server().simulateTransaction(tx2);
+    if (rpc.Api.isSimulationError(sim)) {
+      throw new Error(`kit/stellar: approvers simulation failed: ${sim.error}`);
+    }
+    if (!sim.result?.retval) return false;
+    const list = scValToNative(sim.result.retval);
+    return Array.isArray(list) && list.length > 0;
+  }
+  async isApprover(accountAddress, passkey, readSource) {
+    if (!await this.isDeployed(accountAddress)) return false;
+    const { Account: Account3, TransactionBuilder: TransactionBuilder2, BASE_FEE: BASE_FEE2 } = await import('@stellar/stellar-sdk');
+    const src = new Account3(readSource, "0");
+    const op = Operation.invokeHostFunction({
+      func: invokeFunc(accountAddress, "is_approver", [bytesScVal(sec1Pubkey(passkey))]),
+      auth: []
+    });
+    const tx2 = new TransactionBuilder2(src, { fee: BASE_FEE2, networkPassphrase: this.passphrase }).addOperation(op).setTimeout(30).build();
+    const sim = await this.server().simulateTransaction(tx2);
+    if (rpc.Api.isSimulationError(sim)) {
+      throw new Error(`kit/stellar: is_approver simulation failed: ${sim.error}`);
+    }
+    if (!sim.result?.retval) return false;
+    return scValToNative(sim.result.retval) === true;
+  }
+  /** Read the current passkey-approval nonce (read-only simulation). */
+  async passkeyNonce(accountAddress, readSource) {
+    if (!await this.isDeployed(accountAddress)) return 0n;
+    const { Account: Account3, TransactionBuilder: TransactionBuilder2, BASE_FEE: BASE_FEE2 } = await import('@stellar/stellar-sdk');
+    const src = new Account3(readSource, "0");
+    const op = Operation.invokeHostFunction({
+      func: invokeFunc(accountAddress, "passkey_nonce", []),
+      auth: []
+    });
+    const tx2 = new TransactionBuilder2(src, { fee: BASE_FEE2, networkPassphrase: this.passphrase }).addOperation(op).setTimeout(30).build();
+    const sim = await this.server().simulateTransaction(tx2);
+    if (rpc.Api.isSimulationError(sim)) {
+      throw new Error(`kit/stellar: passkey_nonce simulation failed: ${sim.error}`);
+    }
+    if (!sim.result?.retval) return 0n;
+    return BigInt(scValToNative(sim.result.retval));
+  }
+  /** Host function: SEP-41 `token.transfer(from=account, to, amount)` (device auth). */
+  buildTransfer(tokenId, accountAddress, destination, amount) {
+    return invokeFunc(tokenId, "transfer", [
+      new Address(accountAddress).toScVal(),
+      new Address(destination).toScVal(),
+      nativeToScVal(amount, { type: "i128" })
+    ]);
+  }
+  /**
+   * Sign a Soroban authorization entry with the silent device key, producing the
+   * `Vec<DeviceSignature>` the account's `__check_auth` verifies. The device
+   * signs `sha256(preimage)` (WebCrypto hashes once more internally), which is
+   * exactly what the contract recomputes. Mutates + returns the entry.
+   */
+  async signAuthEntry(entry, validUntilLedger) {
+    const addrCreds = entry.credentials().address();
+    addrCreds.signatureExpirationLedger(validUntilLedger);
+    const preimage = xdr.HashIdPreimage.envelopeTypeSorobanAuthorization(
+      new xdr.HashIdPreimageSorobanAuthorization({
+        networkId: this.networkId(),
+        nonce: addrCreds.nonce(),
+        signatureExpirationLedger: validUntilLedger,
+        invocation: entry.rootInvocation()
+      })
+    );
+    const payload = hash$1(preimage.toXDR());
+    const sig = await this.signer.sign(new Uint8Array(payload));
+    const pubkey = await this.signer.getPublicKey();
+    addrCreds.signature(deviceSignatureScVal(pubkey, sig));
+    return entry;
+  }
+  /**
+   * Read a SEP-41 token balance of `account` via a read-only simulation of
+   * `token.balance(account)`. Returns 0 when the account isn't deployed or holds
+   * none. `readSource` is any funded G-account (used only for the simulation).
+   */
+  async readBalance(tokenId, account, readSource) {
+    if (!await this.isDeployed(account)) return 0n;
+    const { Account: Account3, TransactionBuilder: TransactionBuilder2, BASE_FEE: BASE_FEE2 } = await import('@stellar/stellar-sdk');
+    const src = new Account3(readSource, "0");
+    const op = Operation.invokeHostFunction({
+      func: invokeFunc(tokenId, "balance", [new Address(account).toScVal()]),
+      auth: []
+    });
+    const tx2 = new TransactionBuilder2(src, { fee: BASE_FEE2, networkPassphrase: this.passphrase }).addOperation(op).setTimeout(30).build();
+    const sim = await this.server().simulateTransaction(tx2);
+    if (rpc.Api.isSimulationError(sim) || !sim.result?.retval) return 0n;
+    return BigInt(scValToNative(sim.result.retval));
+  }
+  /** Whether the account contract instance exists on-chain (is deployed). */
+  async isDeployed(accountAddress) {
+    try {
+      const res = await this.server().getContractData(
+        accountAddress,
+        xdr.ScVal.scvLedgerKeyContractInstance(),
+        rpc.Durability.Persistent
+      );
+      return !!res;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Read whether `signer` is a currently-authorized signer of the account, via a
+   * read-only simulation of `account.is_authorized(signer)`. `readSource` is any
+   * funded G-account (used only for the simulation's source/sequence).
+   */
+  async isAuthorizedSigner(accountAddress, signer, readSource) {
+    if (!await this.isDeployed(accountAddress)) return false;
+    const { Account: Account3, TransactionBuilder: TransactionBuilder2, BASE_FEE: BASE_FEE2 } = await import('@stellar/stellar-sdk');
+    const src = new Account3(readSource, "0");
+    const op = Operation.invokeHostFunction({
+      func: invokeFunc(accountAddress, "is_authorized", [bytesScVal(sec1Pubkey(signer))]),
+      auth: []
+    });
+    const tx2 = new TransactionBuilder2(src, { fee: BASE_FEE2, networkPassphrase: this.passphrase }).addOperation(op).setTimeout(30).build();
+    const sim = await this.server().simulateTransaction(tx2);
+    if (rpc.Api.isSimulationError(sim)) {
+      throw new Error(`kit/stellar: is_authorized simulation failed: ${sim.error}`);
+    }
+    if (!sim.result?.retval) return false;
+    return scValToNative(sim.result.retval) === true;
+  }
+};
+function sec1Pubkey(pk) {
+  const out = new Uint8Array(65);
+  out[0] = 4;
+  out.set(bigIntTo32Bytes(pk.x), 1);
+  out.set(bigIntTo32Bytes(pk.y), 33);
+  return out;
+}
+function encodeLowSSignature2(sig) {
+  const lowS2 = sig.s > SECP256R1_N2 / 2n ? SECP256R1_N2 - sig.s : sig.s;
+  const out = new Uint8Array(64);
+  out.set(bigIntTo32Bytes(sig.r), 0);
+  out.set(bigIntTo32Bytes(lowS2), 32);
+  return out;
+}
+function deviceSignatureScVal(pubkey, sig) {
+  const element = nativeToScVal(
+    {
+      public_key: Buffer.from(sec1Pubkey(pubkey)),
+      signature: Buffer.from(encodeLowSSignature2(sig))
+    },
+    { type: { public_key: ["symbol", "bytes"], signature: ["symbol", "bytes"] } }
+  );
+  return xdr.ScVal.scvVec([element]);
+}
+function invokeFunc(contractId, method, args) {
+  return xdr.HostFunction.hostFunctionTypeInvokeContract(
+    new xdr.InvokeContractArgs({
+      contractAddress: new Address(contractId).toScAddress(),
+      functionName: method,
+      args
+    })
+  );
+}
+function bytesScVal(bytes) {
+  return xdr.ScVal.scvBytes(Buffer.from(bytes));
+}
+
+// src/chains/stellar/StellarRelayer.ts
+var StellarRelayer = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /** The relayer's source/fee-payer G-account (fetched + cached from the backend). */
+  async getSource() {
+    if (this.source) return this.source;
+    const res = await fetch(`${this.opts.baseUrl}/api/stellar/relay?network=${this.opts.network}`);
+    if (!res.ok) throw new Error(`kit/stellar: relayer source lookup failed (${res.status})`);
+    const { fee_payer } = await res.json();
+    this.source = fee_payer;
+    return this.source;
+  }
+  /**
+   * POST the assembled, device-authorized transaction XDR to the relayer to sign
+   * the envelope + submit. Returns the confirmed transaction hash.
+   */
+  async submit(transactionXdr) {
+    const res = await fetch(`${this.opts.baseUrl}/api/stellar/relay`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        app_id: this.opts.appId,
+        network: this.opts.network,
+        transaction: transactionXdr
+      })
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`kit/stellar: relay failed (${res.status}) ${detail}`);
+    }
+    const { hash: hash6 } = await res.json();
+    return hash6;
+  }
+};
+var CavosStellar = class _CavosStellar {
+  constructor(identity, address, status, network, adapter, devicePubkey, relayer, sourceKeypair) {
+    this.identity = identity;
+    this.address = address;
+    this.status = status;
+    this.network = network;
+    this.adapter = adapter;
+    this.devicePubkey = devicePubkey;
+    this.relayer = relayer;
+    this.sourceKeypair = sourceKeypair;
+    /** Discriminant for the `CavosWallet` union — narrows `execute()` per chain. */
+    this.chain = "stellar";
+    /** True when this connect just created a brand-new account (first sign-up). */
+    this.isNewAccount = false;
+  }
+  get publicKey() {
+    return this.devicePubkey;
+  }
+  static async connect(opts) {
+    const identity = opts.identity ?? await opts.auth?.authenticate();
+    if (!identity) throw new Error("kit/stellar: connect requires `identity` or `auth`");
+    const signer = opts.createSigner ? await opts.createSigner(`${identity.userId}:${opts.appSalt}`) : await WebCryptoSigner.loadOrCreate({ keyId: `${identity.userId}:${opts.appSalt}` });
+    const devicePubkey = await signer.getPublicKey();
+    const adapter = new StellarAdapter({
+      network: opts.network,
+      rpcUrl: opts.rpcUrl,
+      factoryId: opts.factoryId,
+      signer
+    });
+    const addressSeed = deriveAddressSeedStellar({ userId: identity.userId, appSalt: opts.appSalt });
+    const backendUrl = opts.backendUrl ?? "https://cavos.xyz";
+    const registry = opts.registry ?? (opts.appId ? new HttpWalletRegistry({ baseUrl: backendUrl, appId: opts.appId, network: opts.network }) : defaultRegistry2);
+    const relayer = opts.relayer ?? (opts.appId ? new StellarRelayer({ baseUrl: backendUrl, appId: opts.appId, network: opts.network }) : void 0);
+    const build = (address2, status) => new _CavosStellar(identity, address2, status, opts.network, adapter, devicePubkey, relayer, opts.sourceKeypair);
+    const self = build("", "needs-device-approval");
+    const readSource = await self.resolveSource();
+    const existing = await registry.lookup(identity.userId);
+    if (existing) {
+      const isSigner2 = await adapter.isAuthorizedSigner(existing.address, devicePubkey, readSource);
+      return build(existing.address, isSigner2 ? "ready" : "needs-device-approval");
+    }
+    const address = adapter.computeAddress(addressSeed, devicePubkey);
+    const wasDeployed = await adapter.isDeployed(address);
+    if (!wasDeployed) {
+      const func = adapter.buildDeploy(addressSeed, devicePubkey);
+      await self.submitHostFunction(func, void 0);
+    }
+    await registry.register({ userId: identity.userId, address, initialSigner: devicePubkey });
+    const isSigner = await adapter.isAuthorizedSigner(address, devicePubkey, readSource);
+    const wallet = build(address, isSigner ? "ready" : "needs-device-approval");
+    wallet.isNewAccount = !wasDeployed && isSigner;
+    return wallet;
+  }
+  /** Authorize an additional device signer (device-signed via `__check_auth`). */
+  async addSigner(pubkey) {
+    const func = this.adapter.buildAddSigner(this.address, pubkey);
+    return this.submitHostFunction(func, this.address);
+  }
+  /**
+   * Enroll a passkey as an approver (2FA-style step-up). Device-signed + gasless;
+   * requires a ready device. Idempotent. Returns the passkey pubkey + tx hash.
+   */
+  async enrollPasskey(passkey, params) {
+    const enrolled = await passkey.enroll(params);
+    const { transactionHash } = await this.addApprover(enrolled.publicKey);
+    return { publicKey: enrolled.publicKey, transactionHash };
+  }
+  /** Register an already-enrolled passkey pubkey as an approver (gasless).
+   * Idempotent. Lets one passkey be registered across chains without re-prompting. */
+  async addApprover(pubkey) {
+    if (this.status !== "ready") {
+      throw new Error("kit/stellar: addApprover requires a ready, authorized device");
+    }
+    const readSource = await this.resolveSource();
+    if (await this.adapter.isApprover(this.address, pubkey, readSource)) return {};
+    const func = this.adapter.buildAddApprover(this.address, pubkey);
+    const transactionHash = await this.submitHostFunction(func, this.address);
+    return { transactionHash };
+  }
+  /** True if this account already has a passkey enrolled as an approver, so a
+   * new device can be approved with the passkey instead of the email flow. */
+  async hasPasskey() {
+    const readSource = await this.resolveSource();
+    return this.adapter.hasPasskeyApprover(this.address, readSource);
+  }
+  /** Re-read (from chain) whether THIS device is now an authorized signer.
+   * Used to poll for readiness after a passkey approval before it's indexed. */
+  async isReady() {
+    const readSource = await this.resolveSource();
+    return this.adapter.isAuthorizedSigner(this.address, this.devicePubkey, readSource);
+  }
+  /**
+   * From a fresh browser (status `needs-device-approval`), approve adding THIS
+   * device using the user's synced passkey. Gasless via the relayer — the call
+   * carries the WebAuthn assertion, so no device signature is needed. Returns the
+   * tx hash. No trip back to an already-authorized device.
+   */
+  async approveThisDeviceWithPasskey(passkey) {
+    if (this.status === "ready") {
+      throw new Error("kit/stellar: this device is already an authorized signer");
+    }
+    const { leaf, nonce } = await this.passkeyLeafForThisDevice();
+    const leaves = [leaf];
+    const assertion = await passkey.assert(batchChallenge(leaves));
+    const { transactionHash } = await this.submitPasskeyApproval(assertion, leaves, 0, nonce);
+    return transactionHash;
+  }
+  /** This device's leaf + passkey nonce for a (possibly multi-chain) batch. */
+  async passkeyLeafForThisDevice() {
+    const readSource = await this.resolveSource();
+    const nonce = await this.adapter.passkeyNonce(this.address, readSource);
+    return { leaf: this.adapter.passkeyLeaf(this.devicePubkey, nonce), nonce };
+  }
+  /** Submit `add_signer_via_passkey` given a shared assertion + batch position.
+   * No device auth entry — authorized purely by the passkey assertion. */
+  async submitPasskeyApproval(assertion, leaves, leafIndex, nonce) {
+    const readSource = await this.resolveSource();
+    const digest = webauthnDigest(assertion.authenticatorData, assertion.clientDataJSON);
+    const candidates = recoverCandidatePublicKeys(assertion.r, assertion.s, digest);
+    let approver = null;
+    for (const cand of candidates) {
+      if (await this.adapter.isApprover(this.address, cand.publicKey, readSource)) {
+        approver = cand.publicKey;
+        break;
+      }
+    }
+    if (!approver) throw new Error("kit/stellar: this passkey is not a registered approver");
+    const func = this.adapter.buildAddSignerViaPasskey(
+      this.address,
+      this.devicePubkey,
+      approver,
+      nonce,
+      leaves,
+      leafIndex,
+      assertion
+    );
+    return { transactionHash: await this.submitHostFunction(func, void 0) };
+  }
+  /** Move `amount` stroops of native XLM to `destination` (device-signed). */
+  async execute(amount, destination) {
+    return this.executeTransfer(NATIVE_SAC_ID[this.network], amount, destination);
+  }
+  /** Read this account's balance of `tokenId` (defaults to native XLM), in stroops. */
+  async balance(tokenId = NATIVE_SAC_ID[this.network]) {
+    const readSource = await this.resolveSource();
+    return this.adapter.readBalance(tokenId, this.address, readSource);
+  }
+  /** Transfer `amount` of any SEP-41 token out of the account (device-signed). */
+  async executeTransfer(tokenId, amount, destination) {
+    if (this.status !== "ready") {
+      throw new Error("kit/stellar: this device is not yet an authorized signer of the wallet");
+    }
+    const func = this.adapter.buildTransfer(tokenId, this.address, destination, amount);
+    return this.submitHostFunction(func, this.address);
+  }
+  /**
+   * Register the backup signer derived from `code` as an authorized signer of
+   * this account (device-signed). Idempotent. The code never leaves the device —
+   * only the derived public key travels on-chain. Mirrors the other chains.
+   */
+  async setupRecovery(code) {
+    if (this.status !== "ready") {
+      throw new Error("kit/stellar: setupRecovery requires a ready, registered device");
+    }
+    const { publicKey: backupPubkey } = deriveBackupKey(code);
+    const readSource = await this.resolveSource();
+    if (await this.adapter.isAuthorizedSigner(this.address, backupPubkey, readSource)) return void 0;
+    return this.addSigner(backupPubkey);
+  }
+  /**
+   * Recover an account after losing every device signer: derive the backup key
+   * from `code`, use it (not the new device) to authorize `add_signer(newDevice)`,
+   * and return a ready handle bound to the new device. The address is unchanged.
+   */
+  static async recover(opts) {
+    const signer = opts.createSigner ? await opts.createSigner(`${opts.identity.userId}:${opts.appSalt}`) : await WebCryptoSigner.loadOrCreate({ keyId: `${opts.identity.userId}:${opts.appSalt}` });
+    const devicePubkey = await signer.getPublicKey();
+    const backup = BackupSigner.fromCode(opts.code);
+    const backupAdapter = new StellarAdapter({
+      network: opts.network,
+      rpcUrl: opts.rpcUrl,
+      factoryId: opts.factoryId,
+      signer: backup
+    });
+    const backendUrl = opts.backendUrl ?? "https://cavos.xyz";
+    const registry = opts.registry ?? (opts.appId ? new HttpWalletRegistry({ baseUrl: backendUrl, appId: opts.appId, network: opts.network }) : defaultRegistry2);
+    const existing = await registry.lookup(opts.identity.userId);
+    if (!existing) {
+      throw new Error("kit/stellar: no account found for this identity \u2014 nothing to recover");
+    }
+    const relayer = opts.relayer ?? (opts.appId ? new StellarRelayer({ baseUrl: backendUrl, appId: opts.appId, network: opts.network }) : void 0);
+    const backupHandle = new _CavosStellar(
+      opts.identity,
+      existing.address,
+      "ready",
+      opts.network,
+      backupAdapter,
+      devicePubkey,
+      relayer,
+      opts.sourceKeypair
+    );
+    const readSource = await backupHandle.resolveSource();
+    if (!await backupAdapter.isAuthorizedSigner(existing.address, devicePubkey, readSource)) {
+      await backupHandle.addSigner(devicePubkey);
+    }
+    const adapter = new StellarAdapter({
+      network: opts.network,
+      rpcUrl: opts.rpcUrl,
+      factoryId: opts.factoryId,
+      signer
+    });
+    return new _CavosStellar(
+      opts.identity,
+      existing.address,
+      "ready",
+      opts.network,
+      adapter,
+      devicePubkey,
+      relayer,
+      opts.sourceKeypair
+    );
+  }
+  /** The transaction source/fee-payer G-address (relayer or self-funded). */
+  async resolveSource() {
+    if (this.relayer) return this.relayer.getSource();
+    if (this.sourceKeypair) return this.sourceKeypair.publicKey();
+    throw new Error("kit/stellar: a relayer (appId) or sourceKeypair is required");
+  }
+  /**
+   * Build → simulate → device-sign auth → assemble → submit an invoke-contract
+   * host function. `authAccount` is the account whose `__check_auth` must sign the
+   * operation's Soroban auth entry (undefined for a plain factory deploy).
+   */
+  async submitHostFunction(func, authAccount) {
+    const server = this.adapter.server();
+    const sourceAddr = await this.resolveSource();
+    const simSource = new Account(sourceAddr, "0");
+    const unsignedOp = Operation.invokeHostFunction({ func, auth: [] });
+    const simTx = new TransactionBuilder(simSource, {
+      fee: BASE_FEE,
+      networkPassphrase: this.adapter.passphrase
+    }).addOperation(unsignedOp).setTimeout(180).build();
+    const sim = await server.simulateTransaction(simTx);
+    if (rpc.Api.isSimulationError(sim)) {
+      throw new Error(`kit/stellar: simulation failed: ${sim.error}`);
+    }
+    const validUntil = (await server.getLatestLedger()).sequence + 100;
+    const entries = sim.result?.auth ?? [];
+    const signedAuth = [];
+    for (const entry of entries) {
+      if (authAccount && isAddressCredentialFor(entry, authAccount)) {
+        signedAuth.push(await this.adapter.signAuthEntry(entry, validUntil));
+      } else {
+        signedAuth.push(entry);
+      }
+    }
+    const account = await server.getAccount(sourceAddr);
+    const finalOp = Operation.invokeHostFunction({ func, auth: signedAuth });
+    const built = new TransactionBuilder(account, {
+      fee: BASE_FEE,
+      networkPassphrase: this.adapter.passphrase
+    }).addOperation(finalOp).setTimeout(180).build();
+    const authSim = await server.simulateTransaction(built);
+    if (rpc.Api.isSimulationError(authSim)) {
+      throw new Error(`kit/stellar: auth simulation failed: ${authSim.error}`);
+    }
+    const assembled = rpc.assembleTransaction(built, authSim).build();
+    if (this.relayer) {
+      return this.relayer.submit(assembled.toXDR());
+    }
+    if (this.sourceKeypair) {
+      assembled.sign(this.sourceKeypair);
+      return this.sendAndConfirm(assembled);
+    }
+    throw new Error("kit/stellar: no relayer or sourceKeypair configured to submit");
+  }
+  /** Submit a signed tx via RPC and poll to confirmation. Returns the hash. */
+  async sendAndConfirm(tx2) {
+    const server = this.adapter.server();
+    const sent = await server.sendTransaction(tx2);
+    if (sent.status === "ERROR") {
+      throw new Error(`kit/stellar: submit rejected: ${JSON.stringify(sent.errorResult)}`);
+    }
+    const hash6 = sent.hash;
+    for (let i = 0; i < 30; i++) {
+      const got = await server.getTransaction(hash6);
+      if (got.status === rpc.Api.GetTransactionStatus.SUCCESS) return hash6;
+      if (got.status === rpc.Api.GetTransactionStatus.FAILED) {
+        throw new Error(`kit/stellar: tx ${hash6} failed`);
+      }
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+    throw new Error(`kit/stellar: tx ${hash6} not confirmed in time`);
+  }
+};
+function isAddressCredentialFor(entry, accountAddress) {
+  const creds = entry.credentials();
+  if (creds.switch() !== xdr.SorobanCredentialsType.sorobanCredentialsAddress()) return false;
+  return Address.fromScAddress(creds.address().address()).toString() === accountAddress;
+}
+var defaultRegistry2 = new InMemoryWalletRegistry();
+
+// src/recovery/HttpRecoveryClient.ts
+function toHex2(n) {
+  return "0x" + n.toString(16);
+}
+function fromHex2(s) {
+  return BigInt(s);
+}
+function deviceLabel() {
+  if (typeof navigator !== "undefined") {
+    return navigator.userAgent || "a new device";
+  }
+  return "a new device";
+}
+var HttpRecoveryClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async requestDeviceAddition(params) {
+    const res = await fetch(new URL("/api/devices/request", this.opts.baseUrl), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        app_id: this.opts.appId,
+        wallet_address: params.accountAddress,
+        new_pub_x: toHex2(params.newSigner.x),
+        new_pub_y: toHex2(params.newSigner.y),
+        device_label: params.deviceLabel ?? deviceLabel(),
+        ...params.email ? { email: params.email } : {}
+      })
+    });
+    if (!res.ok) {
+      const t = await res.text().catch(() => "");
+      throw new Error(`requestDeviceAddition failed: ${res.status} ${t}`);
+    }
+    const data = await res.json();
+    return { requestId: data.request_id };
+  }
+  async getPendingRequest(requestId) {
+    const url = new URL("/api/devices/request", this.opts.baseUrl);
+    url.searchParams.set("id", requestId);
+    const res = await fetch(url, { headers: { "Content-Type": "application/json" } });
+    if (!res.ok) throw new Error(`getPendingRequest failed: ${res.status}`);
+    const data = await res.json();
+    if (!data.found) return null;
+    const status = data.status;
+    return {
+      requestId: data.request_id,
+      appId: data.app_id,
+      userId: "",
+      // the approving device already knows its own identity
+      accountAddress: data.wallet_address,
+      newSigner: { x: fromHex2(data.new_pub_x), y: fromHex2(data.new_pub_y) },
+      createdAt: data.created_at,
+      status
+    };
+  }
+  async confirmDeviceAddition(params) {
+    const res = await fetch(
+      new URL(`/api/devices/request/${params.requestId}/confirm`, this.opts.baseUrl),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tx_hash: params.txHash })
+      }
+    );
+    if (!res.ok) {
+      const t = await res.text().catch(() => "");
+      throw new Error(`confirmDeviceAddition failed: ${res.status} ${t}`);
+    }
+  }
+};
+var STARKNET_ENV = {
+  mainnet: "mainnet",
+  testnet: "sepolia"
+};
+var SOLANA_ENV = {
+  mainnet: "solana-mainnet",
+  testnet: "solana-devnet"
+};
+var STELLAR_ENV = {
+  mainnet: "stellar-mainnet",
+  testnet: "stellar-testnet"
+};
+var Cavos = class _Cavos {
+  constructor(identity, address, status, account, adapter, devicePubkey, paymaster) {
+    this.identity = identity;
+    this.address = address;
+    this.status = status;
+    this.account = account;
+    this.adapter = adapter;
+    this.devicePubkey = devicePubkey;
+    this.paymaster = paymaster;
+    /** Discriminant for the `CavosWallet` union — narrows `execute()` per chain. */
+    this.chain = "starknet";
+    /** Request id of the pending device-addition, when status is needs-device-approval. */
+    this.pendingRequestId = null;
+    /** True when this connect just created & deployed a brand-new account (first
+     * sign-up), so the UI can offer a one-time "secure your account" step. */
+    this.isNewAccount = false;
+  }
+  /**
+   * Unified entry point. Pick a `chain` and an `network` environment; the kit
+   * resolves the concrete network (sepolia/devnet for testnet, mainnet for
+   * mainnet) and returns a chain-native wallet. The result is a discriminated
+   * union (`wallet.chain`), so `execute()` keeps each chain's native signature:
+   *
+   *   const wallet = await Cavos.connect({ chain: "solana", network: "testnet", identity, appSalt, appId });
+   *   if (wallet.chain === "starknet") await wallet.execute(calls);
+   *   else                              await wallet.execute(amount, dest);
+   */
+  static async connect(opts) {
+    if (opts.chain === "solana") {
+      return CavosSolana.connect({
+        network: SOLANA_ENV[opts.network],
+        ...opts.auth ? { auth: opts.auth } : {},
+        ...opts.identity ? { identity: opts.identity } : {},
+        appSalt: opts.appSalt,
+        ...opts.appId ? { appId: opts.appId } : {},
+        ...opts.backendUrl ? { backendUrl: opts.backendUrl } : {},
+        ...opts.registry ? { registry: opts.registry } : {},
+        ...opts.rpcUrl ? { rpcUrl: opts.rpcUrl } : {},
+        ...opts.programId ? { programId: opts.programId } : {},
+        ...opts.createSigner ? { createSigner: opts.createSigner } : {},
+        ...opts.relayer ? { relayer: opts.relayer } : {},
+        ...opts.feePayer ? { feePayer: opts.feePayer } : {}
+      });
+    }
+    if (opts.chain === "stellar") {
+      return CavosStellar.connect({
+        network: STELLAR_ENV[opts.network],
+        ...opts.auth ? { auth: opts.auth } : {},
+        ...opts.identity ? { identity: opts.identity } : {},
+        appSalt: opts.appSalt,
+        ...opts.appId ? { appId: opts.appId } : {},
+        ...opts.backendUrl ? { backendUrl: opts.backendUrl } : {},
+        ...opts.registry ? { registry: opts.registry } : {},
+        ...opts.rpcUrl ? { rpcUrl: opts.rpcUrl } : {},
+        ...opts.factoryId ? { factoryId: opts.factoryId } : {},
+        ...opts.createSigner ? { createSigner: opts.createSigner } : {},
+        ...opts.stellarRelayer ? { relayer: opts.stellarRelayer } : {},
+        ...opts.stellarSourceKeypair ? { sourceKeypair: opts.stellarSourceKeypair } : {}
+      });
+    }
+    if (!opts.paymasterApiKey) {
+      throw new Error("kit: `paymasterApiKey` is required for Starknet connections");
+    }
+    return _Cavos.connectStarknet({
+      network: STARKNET_ENV[opts.network],
+      auth: opts.auth,
+      identity: opts.identity,
+      appSalt: opts.appSalt,
+      appId: opts.appId,
+      backendUrl: opts.backendUrl,
+      registry: opts.registry,
+      recovery: opts.recovery,
+      paymasterApiKey: opts.paymasterApiKey,
+      paymasterUrl: opts.paymasterUrl,
+      rpcUrl: opts.rpcUrl,
+      classHash: opts.classHash,
+      createSigner: opts.createSigner
+    });
+  }
+  static async connectStarknet(opts) {
+    const identity = opts.identity ?? await opts.auth?.authenticate();
+    if (!identity) throw new Error("kit: connect requires `identity` or `auth`");
+    const classHash = opts.classHash ?? DEVICE_ACCOUNT_CLASS_HASH[opts.network];
+    if (!classHash) throw new Error(`kit: no DeviceAccount class hash for ${opts.network}`);
+    const provider = new RpcProvider({
+      nodeUrl: opts.rpcUrl ?? STARKNET_NETWORKS[opts.network].rpcUrl
+    });
+    const paymasterUrl = opts.paymasterUrl ?? CAVOS_PAYMASTER_URL[opts.network];
+    const paymasterConfig = { url: paymasterUrl, apiKey: opts.paymasterApiKey };
+    const paymaster = new PaymasterRpc({
+      nodeUrl: paymasterUrl,
+      headers: { "x-paymaster-api-key": opts.paymasterApiKey }
+    });
+    const addressSeed = deriveAddressSeed({ userId: identity.userId, appSalt: opts.appSalt });
+    const signer = opts.createSigner ? await opts.createSigner(`${identity.userId}:${opts.appSalt}`) : await WebCryptoSigner.loadOrCreate({ keyId: `${identity.userId}:${opts.appSalt}` });
+    const devicePubkey = await signer.getPublicKey();
+    const adapter = new StarknetAdapter({ classHash, signer, provider });
+    const makeAccount = (address2) => new Account$1({
+      provider,
+      address: address2,
+      signer: new StarknetDeviceSigner(signer),
+      paymaster,
+      cairoVersion: "1"
+    });
+    const backendUrl = opts.backendUrl ?? "https://cavos.xyz";
+    const registry = opts.registry ?? (opts.appId ? new HttpWalletRegistry({ baseUrl: backendUrl, appId: opts.appId, network: opts.network }) : defaultRegistry3);
+    const recovery = opts.recovery ?? (opts.appId ? new HttpRecoveryClient({ baseUrl: backendUrl, appId: opts.appId }) : null);
+    const existing = await registry.lookup(identity.userId);
+    if (existing) {
+      const account2 = makeAccount(existing.address);
+      const isSigner2 = await adapter.isAuthorizedSigner(existing.address, devicePubkey);
+      const cavos2 = new _Cavos(
+        identity,
+        existing.address,
+        isSigner2 ? "ready" : "needs-device-approval",
+        account2,
+        adapter,
+        devicePubkey,
+        paymasterConfig
+      );
+      if (!isSigner2 && recovery) {
+        const dedup = lastDeviceRequest.get(identity.userId);
+        const fresh = dedup && Date.now() - dedup.requestedAt < DEVICE_REQUEST_DEDUP_MS;
+        try {
+          if (fresh) {
+            cavos2.pendingRequestId = dedup.requestId;
+          } else {
+            const { requestId } = await recovery.requestDeviceAddition({
+              userId: identity.userId,
+              accountAddress: existing.address,
+              newSigner: devicePubkey,
+              ...identity.email ? { email: identity.email } : {}
+            });
+            cavos2.pendingRequestId = requestId;
+            lastDeviceRequest.set(identity.userId, { requestId, requestedAt: Date.now() });
+          }
+        } catch (e) {
+          console.warn("[Cavos] requestDeviceAddition failed:", e);
+        }
+      }
+      return cavos2;
+    }
+    const address = adapter.computeAddress({ addressSeed, initialSigner: devicePubkey });
+    const account = makeAccount(address);
+    const alreadyDeployed = await isDeployed(provider, address);
+    if (!alreadyDeployed) {
+      const deploymentData = {
+        address,
+        class_hash: classHash,
+        salt: num.toHex(addressSeed),
+        calldata: adapter.constructorCalldata(addressSeed, devicePubkey),
+        version: 1
+      };
+      const deployRes = await account.executePaymasterTransaction([], {
+        feeMode: { mode: "sponsored" },
+        deploymentData
+      });
+      try {
+        await provider.waitForTransaction(deployRes.transaction_hash);
+      } catch (e) {
+        console.warn("[Cavos] deploy receipt wait failed:", e);
+      }
+    }
+    await registry.register({ userId: identity.userId, address, initialSigner: devicePubkey });
+    let isSigner;
+    try {
+      isSigner = await adapter.isAuthorizedSigner(address, devicePubkey);
+    } catch (e) {
+      console.warn("[Cavos] isAuthorizedSigner read failed:", e);
+      isSigner = !alreadyDeployed;
+    }
+    const cavos = new _Cavos(
+      identity,
+      address,
+      isSigner ? "ready" : "needs-device-approval",
+      account,
+      adapter,
+      devicePubkey,
+      paymasterConfig
+    );
+    cavos.isNewAccount = !alreadyDeployed && isSigner;
+    return cavos;
+  }
+  /** This device's public key (e.g. to request addition to an existing wallet). */
+  get publicKey() {
+    return this.devicePubkey;
+  }
+  /** Execute a sponsored (gasless) multicall, signed silently by the device. */
+  async execute(calls) {
+    if (this.status !== "ready") {
+      throw new Error("kit: this device is not yet an authorized signer of the wallet");
+    }
+    const res = await this.account.executePaymasterTransaction(calls, {
+      feeMode: { mode: "sponsored" }
+    });
+    return { transactionHash: res.transaction_hash };
+  }
+  /** Authorize an additional device signer (sponsored). Self-submitted. */
+  async addSigner(pubkey) {
+    return this.execute([this.adapter.buildAddSigner(this.address, pubkey)]);
+  }
+  /**
+   * Enroll a passkey as an APPROVER so the user can later add devices from any
+   * browser (2FA-style step-up). Requires a ready device (the enrollment call is
+   * device-signed and gasless). Idempotent: a no-op if the passkey is already an
+   * approver. Call this whenever the app decides to prompt "turn on device
+   * approvals". Returns the passkey's public key + the enrollment tx hash.
+   */
+  async enrollPasskey(passkey, params) {
+    const enrolled = await passkey.enroll(params);
+    const { transactionHash } = await this.addApprover(enrolled.publicKey);
+    return { publicKey: enrolled.publicKey, transactionHash };
+  }
+  /**
+   * Register an ALREADY-enrolled passkey public key as an approver (gasless,
+   * device-signed). Idempotent. Use this to register ONE passkey across multiple
+   * chains without re-prompting `passkey.enroll()` on each: enroll once, then
+   * call `addApprover(pubkey)` on each chain's wallet.
+   */
+  async addApprover(pubkey) {
+    if (this.status !== "ready") {
+      throw new Error("kit: addApprover requires a ready, authorized device");
+    }
+    if (await this.adapter.isApprover(this.address, pubkey)) return {};
+    const { transactionHash } = await this.execute([
+      this.adapter.buildAddApprover(this.address, pubkey)
+    ]);
+    try {
+      await this.account.waitForTransaction(transactionHash);
+    } catch (e) {
+      console.warn("[Cavos] add_approver receipt wait failed:", e);
+    }
+    return { transactionHash };
+  }
+  /** True if this account already has a passkey enrolled as an approver, so a
+   * new device can be approved with the passkey instead of the email flow. */
+  async hasPasskey() {
+    return this.adapter.hasPasskeyApprover(this.address);
+  }
+  /** Re-read (from chain) whether THIS device is now an authorized signer.
+   * Cheap and side-effect free — used to poll for readiness after a passkey /
+   * device approval submits, before the new signer is indexed. */
+  async isReady() {
+    return this.adapter.isAuthorizedSigner(this.address, this.devicePubkey);
+  }
+  /**
+   * From a brand-new browser (status `needs-device-approval`), use the user's
+   * synced passkey to authorize adding THIS device — no trip back to an already-
+   * authorized device.
+   *
+   * `add_signer_via_passkey` is a public external authorized by the embedded
+   * WebAuthn assertion (no device signature), so by default we sponsor it through
+   * the Cavos paymaster's `paymaster_executeDirectTransaction` (the forwarder's
+   * `execute_sponsored` runs a generic call — it does NOT require SNIP-9). Pass a
+   * custom `submit` to route it through your own relayer instead. Returns the tx.
+   */
+  async approveThisDeviceWithPasskey(opts) {
+    if (this.status === "ready") {
+      throw new Error("kit: this device is already an authorized signer");
+    }
+    const { leaf, nonce } = await this.passkeyLeafForThisDevice();
+    const leaves = [leaf];
+    const assertion = await opts.passkey.assert(batchChallenge(leaves));
+    return this.submitPasskeyApproval(assertion, leaves, 0, nonce, opts.submit);
+  }
+  /** This device's leaf + the current passkey nonce, for a (possibly multi-chain)
+   * passkey approval batch. See `approveDeviceEverywhere`. */
+  async passkeyLeafForThisDevice() {
+    const nonce = await this.adapter.getPasskeyNonce(this.address);
+    return { leaf: this.adapter.passkeyLeaf(this.devicePubkey, nonce), nonce };
+  }
+  /** Submit `add_signer_via_passkey` given a (shared) assertion + this chain's
+   * position in the batch. The assertion doesn't carry the passkey pubkey, so we
+   * recover both candidates and pick the enrolled approver via the on-chain view
+   * (no backend). Defaults to sponsoring through the paymaster. */
+  async submitPasskeyApproval(assertion, leaves, leafIndex, nonce, submit) {
+    const digest = webauthnDigest(assertion.authenticatorData, assertion.clientDataJSON);
+    const candidates = recoverCandidatePublicKeys(assertion.r, assertion.s, digest);
+    let yParity = null;
+    for (const cand of candidates) {
+      if (await this.adapter.isApprover(this.address, cand.publicKey)) {
+        yParity = cand.yParity;
+        break;
+      }
+    }
+    if (yParity === null) {
+      throw new Error("kit: this passkey is not a registered approver of the wallet");
+    }
+    const call = this.adapter.buildAddSignerViaPasskey(
+      this.address,
+      this.devicePubkey,
+      nonce,
+      leaves,
+      leafIndex,
+      assertion,
+      yParity
+    );
+    if (submit) return submit(call);
+    if (!this.paymaster) {
+      throw new Error("kit: no paymaster configured \u2014 pass a `submit` relayer to approveThisDeviceWithPasskey");
+    }
+    return paymasterExecuteDirect(this.paymaster, this.address, call);
+  }
+  /**
+   * Register a self-custodial backup signer derived from `code`, so the account
+   * can be recovered after the user loses every device. Idempotent: if the
+   * derived backup key is already an authorised signer, this is a no-op.
+   *
+   * The code never leaves the device — only its deterministic public key is
+   * added on-chain as an ordinary signer. Sponsor this like any other
+   * add_signer (gasless). Returns the transaction hash (or undefined when the
+   * backup was already set up).
+   */
+  async setupRecovery(code) {
+    const { publicKey: backupPubkey } = deriveBackupKey(code);
+    const already = await this.adapter.isAuthorizedSigner(this.address, backupPubkey);
+    if (already) return void 0;
+    return this.addSigner(backupPubkey);
+  }
+  /**
+   * Recover an account after losing every device signer. Derives the backup key
+   * from `code`, uses it (not the new device key) to sign an `add_signer` for
+   * the new device, and returns a ready Cavos bound to the new device. The
+   * account address is unchanged.
+   *
+   * Self-custodial: only someone holding the code (i.e. the rightful owner) can
+   * re-derive the backup key. The backend never sees the code.
+   */
+  static async recover(opts) {
+    const network = STARKNET_ENV[opts.network];
+    const classHash = opts.classHash ?? DEVICE_ACCOUNT_CLASS_HASH[network];
+    if (!classHash) throw new Error(`kit: no DeviceAccount class hash for ${network}`);
+    const provider = new RpcProvider({
+      nodeUrl: opts.rpcUrl ?? STARKNET_NETWORKS[network].rpcUrl
+    });
+    const paymaster = new PaymasterRpc({
+      nodeUrl: opts.paymasterUrl ?? CAVOS_PAYMASTER_URL[network],
+      headers: { "x-paymaster-api-key": opts.paymasterApiKey }
+    });
+    const signer = opts.createSigner ? await opts.createSigner(`${opts.identity.userId}:${opts.appSalt}`) : await WebCryptoSigner.loadOrCreate({ keyId: `${opts.identity.userId}:${opts.appSalt}` });
+    const devicePubkey = await signer.getPublicKey();
+    const backup = BackupSigner.fromCode(opts.code);
+    const backupAdapter = new StarknetAdapter({ classHash, signer: backup, provider });
+    const backendUrl = opts.backendUrl ?? "https://cavos.xyz";
+    const registry = opts.registry ?? (opts.appId ? new HttpWalletRegistry({ baseUrl: backendUrl, appId: opts.appId, network }) : defaultRegistry3);
+    const existing = await registry.lookup(opts.identity.userId);
+    if (!existing) {
+      throw new Error("kit: no account found for this identity \u2014 nothing to recover");
+    }
+    const backupAccount = new Account$1({
+      provider,
+      address: existing.address,
+      signer: new StarknetDeviceSigner(backup),
+      paymaster,
+      cairoVersion: "1"
+    });
+    const alreadyAuthed = await backupAdapter.isAuthorizedSigner(existing.address, devicePubkey);
+    if (!alreadyAuthed) {
+      const res = await backupAccount.executePaymasterTransaction(
+        [backupAdapter.buildAddSigner(existing.address, devicePubkey)],
+        { feeMode: { mode: "sponsored" } }
+      );
+      try {
+        await provider.waitForTransaction(res.transaction_hash);
+      } catch (e) {
+        console.warn("[Cavos] recovery add_signer receipt wait failed:", e);
+      }
+    }
+    const adapter = new StarknetAdapter({ classHash, signer, provider });
+    const account = new Account$1({
+      provider,
+      address: existing.address,
+      signer: new StarknetDeviceSigner(signer),
+      paymaster,
+      cairoVersion: "1"
+    });
+    return new _Cavos(opts.identity, existing.address, "ready", account, adapter, devicePubkey);
+  }
+};
+var defaultRegistry3 = new InMemoryWalletRegistry();
+var DEVICE_REQUEST_DEDUP_MS = 5 * 60 * 1e3;
+var lastDeviceRequest = /* @__PURE__ */ new Map();
+async function isDeployed(provider, address) {
+  try {
+    const classHash = await provider.getClassHashAt(address);
+    return !!classHash && classHash !== "0x0";
+  } catch {
+    return false;
+  }
+}
+async function approveDeviceEverywhere(wallets, passkey) {
+  const targets = wallets.filter((w) => w.status === "needs-device-approval");
+  if (targets.length === 0) return [];
+  const infos = await Promise.all(targets.map((w) => w.passkeyLeafForThisDevice()));
+  const leaves = infos.map((i) => i.leaf);
+  const assertion = await passkey.assert(batchChallenge(leaves));
+  const settled = await Promise.allSettled(
+    targets.map((w, i) => w.submitPasskeyApproval(assertion, leaves, i, infos[i].nonce))
+  );
+  return settled.map(
+    (r, i) => r.status === "fulfilled" ? { chain: targets[i].chain, transactionHash: r.value.transactionHash } : {
+      chain: targets[i].chain,
+      error: r.reason instanceof Error ? r.reason.message : String(r.reason)
+    }
+  );
+}
+async function paymasterExecuteDirect(paymaster, userAddress, call) {
+  const body = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "paymaster_executeDirectTransaction",
+    params: {
+      transaction: {
+        type: "invoke",
+        invoke: {
+          user_address: userAddress,
+          execute_from_outside_call: {
+            to: call.contractAddress,
+            selector: hash.getSelectorFromName(call.entrypoint),
+            calldata: call.calldata.map((c) => num.toHex(c))
+          }
+        }
+      },
+      parameters: { version: "0x1", fee_mode: { mode: "sponsored" } }
+    }
+  };
+  const res = await fetch(paymaster.url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...paymaster.apiKey ? { "x-paymaster-api-key": paymaster.apiKey } : {}
+    },
+    body: JSON.stringify(body)
+  });
+  const json = await res.json();
+  if (json.error) {
+    throw new Error(`kit: paymaster passkey approval failed: ${JSON.stringify(json.error)}`);
+  }
+  return { transactionHash: json.result?.transaction_hash ?? json.result?.tracking_id };
+}
+var CavosAuth = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    /** Most recent nonce sent to the backend (for the pending OAuth/OTP request). */
+    this.pendingNonce = null;
+    this.last = null;
+    this.backendUrl = opts.backendUrl ?? "https://cavos.xyz";
+  }
+  /** Redirect URL for Google login (open it; user returns to your redirectUri). */
+  async getGoogleOAuthUrl(redirectUri) {
+    return this.oauthUrl("google", redirectUri);
+  }
+  /** Redirect URL for Apple login. */
+  async getAppleOAuthUrl(redirectUri) {
+    return this.oauthUrl("apple", redirectUri);
+  }
+  async oauthUrl(provider, redirectUri) {
+    if (typeof window === "undefined") throw new Error("kit/auth: OAuth requires a browser");
+    const params = new URLSearchParams({
+      nonce: this.freshNonce(),
+      redirect_uri: redirectUri ?? window.location.href,
+      ...this.opts.appId ? { app_id: this.opts.appId } : {}
+    });
+    const { url } = await this.get(`/api/oauth/${provider}?${params}`);
+    return url;
+  }
+  /**
+   * Resolve the identity from an OAuth callback. The auth data is carried in the
+   * `auth_data` (or `zk_auth_data`) query param on return. We only extract `sub`.
+   */
+  async handleCallback(authDataOrSearch) {
+    const authData = extractAuthData(authDataOrSearch);
+    return this.identityFromAuthData(authData, "oauth");
+  }
+  /** Send a one-time code to an email (Firebase OTP). */
+  async sendOtp(email) {
+    await this.post("/api/oauth/firebase/otp/request", {
+      email,
+      nonce: this.freshNonce(),
+      ...this.opts.appId ? { app_id: this.opts.appId } : {}
+    });
+  }
+  /** Send a passwordless magic-link sign-in email (Firebase). */
+  async sendMagicLink(email) {
+    await this.post("/api/oauth/firebase/magic-link", {
+      email,
+      nonce: this.freshNonce(),
+      ...this.opts.appId ? { app_id: this.opts.appId } : {},
+      ...typeof window !== "undefined" ? { redirect_uri: window.location.href } : {}
+    });
+  }
+  /** Verify the OTP and resolve the identity. */
+  async verifyOtp(email, code) {
+    const res = await this.post("/api/oauth/firebase/otp/verify", {
+      email,
+      code,
+      nonce: this.consumeNonce(),
+      ...this.opts.appId ? { app_id: this.opts.appId } : {}
+    });
+    return this.identityFromAuthData(res.id_token ?? res.jwt ?? res.token ?? JSON.stringify(res), "otp", email);
+  }
+  /** AuthProvider: returns the identity resolved by the last login step. */
+  async authenticate() {
+    if (!this.last) throw new Error("kit/auth: no identity yet \u2014 complete a login first");
+    return this.last;
+  }
+  // ── internals ──────────────────────────────────────────────────────────────
+  /**
+   * Build an `Identity` from whatever the backend returned. The Cavos backend
+   * wraps the user id in a JWT (its `sub` claim); for the device model we only
+   * need that stable id — the signature is never checked on-chain.
+   */
+  async identityFromAuthData(authData, provider, emailOverride) {
+    let token = authData;
+    try {
+      const parsed = JSON.parse(authData);
+      token = parsed.id_token ?? parsed.jwt ?? parsed.token ?? authData;
+    } catch {
+    }
+    const claims = parseJwt(token);
+    return this.remember({
+      userId: String(claims.sub ?? claims.user_id ?? claims.uid),
+      email: claims.email ?? emailOverride,
+      provider: claims.firebase?.sign_in_provider ?? claims.provider ?? provider
+    });
+  }
+  /** Generate (and remember) the nonce the Cavos backend expects on requests. */
+  freshNonce() {
+    const bytes = crypto.getRandomValues(new Uint8Array(31));
+    const h = hash.computePoseidonHashOnElements([bytesToChunks(bytes)]);
+    this.pendingNonce = num.toHex(h);
+    return this.pendingNonce;
+  }
+  /** Return the pending nonce (for the verify step), clearing it. */
+  consumeNonce() {
+    if (!this.pendingNonce) return this.freshNonce();
+    const n = this.pendingNonce;
+    this.pendingNonce = null;
+    return n;
+  }
+  remember(id) {
+    this.last = id;
+    return id;
+  }
+  async get(path) {
+    const r = await fetch(`${this.backendUrl}${path}`);
+    if (!r.ok) throw new Error(`kit/auth: ${path} -> ${r.status} ${await r.text()}`);
+    return r.json();
+  }
+  async post(path, body) {
+    const r = await fetch(`${this.backendUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!r.ok) throw new Error(`kit/auth: ${path} -> ${r.status} ${await r.text()}`);
+    return r.json();
+  }
+};
+function extractAuthData(input) {
+  if (input.includes("auth_data=") || input.includes("zk_auth_data=")) {
+    const params = new URLSearchParams(input.startsWith("?") ? input : `?${input}`);
+    return params.get("auth_data") ?? params.get("zk_auth_data") ?? input;
+  }
+  return input;
+}
+function parseJwt(jwt) {
+  const part = jwt.split(".")[1];
+  if (!part) throw new Error("kit/auth: malformed JWT");
+  const json = atob(part.replace(/-/g, "+").replace(/_/g, "/"));
+  return JSON.parse(json);
+}
+function bytesToChunks(bytes) {
+  let w = 0n;
+  for (const b of bytes.subarray(0, 31)) w = w << 8n | BigInt(b);
+  return w;
+}
+var PasskeySigner = class {
+  constructor(opts = {}) {
+    if (typeof window === "undefined" || !navigator.credentials) {
+      throw new Error("kit/passkey: WebAuthn is only available in a browser");
+    }
+    this.rpId = opts.rpId ?? window.location.hostname;
+    this.rpName = opts.rpName ?? this.rpId;
+    if (isIpAddress(this.rpId)) {
+      throw new Error(
+        `kit/passkey: passkeys can't use an IP address as the domain ("${this.rpId}"). Use http://localhost, a real HTTPS domain, or a tunnel (cloudflared/ngrok) \u2014 or pass an explicit \`rpId\`. (The silent device key works over an IP; passkeys don't.)`
+      );
+    }
+  }
+  /** True if this platform advertises a usable passkey (platform authenticator). */
+  static async isSupported() {
+    if (typeof window === "undefined" || !window.PublicKeyCredential) return false;
+    try {
+      return await window.PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
+    } catch {
+      return false;
+    }
+  }
+  /** Create a new synced passkey and return its P-256 public key. */
+  async enroll(params) {
+    const challenge = crypto.getRandomValues(new Uint8Array(32));
+    const cred = await navigator.credentials.create({
+      publicKey: {
+        challenge: buf(challenge),
+        rp: { id: this.rpId, name: this.rpName },
+        user: {
+          id: buf(userHandle(params.userId)),
+          name: params.userName,
+          displayName: params.displayName ?? params.userName
+        },
+        pubKeyCredParams: [{ type: "public-key", alg: -7 }],
+        // ES256 (P-256)
+        authenticatorSelection: {
+          residentKey: "required",
+          requireResidentKey: true,
+          userVerification: "preferred"
+        },
+        attestation: "none"
+      }
+    });
+    if (!cred) throw new Error("kit/passkey: enrollment cancelled");
+    const response = cred.response;
+    const spki = new Uint8Array(response.getPublicKey());
+    return { publicKey: spkiToPublicKey(spki), credentialId: new Uint8Array(cred.rawId) };
+  }
+  /**
+   * Produce a WebAuthn assertion over `challenge` (a 32-byte value the caller
+   * derives from the signer being added + the on-chain nonce). Uses discoverable
+   * credentials — no `allowCredentials` — so it works on a brand-new browser.
+   */
+  async assert(challenge) {
+    const cred = await navigator.credentials.get({
+      publicKey: {
+        challenge: buf(challenge),
+        rpId: this.rpId,
+        allowCredentials: [],
+        userVerification: "preferred"
+      }
+    });
+    if (!cred) throw new Error("kit/passkey: assertion cancelled");
+    const response = cred.response;
+    const authenticatorData = new Uint8Array(response.authenticatorData);
+    const clientDataJSON = new Uint8Array(response.clientDataJSON);
+    const { r, s } = derToRs(new Uint8Array(response.signature));
+    const challengeOffset = challengeOffsetOf(clientDataJSON, base64urlEncode(challenge));
+    return { authenticatorData, clientDataJSON, r, s, challengeOffset };
+  }
+};
+function isIpAddress(host) {
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(host)) return true;
+  if (host.includes(":")) return true;
+  return false;
+}
+function userHandle(userId) {
+  const bytes = new TextEncoder().encode(userId);
+  return bytes.length <= 64 ? bytes : sha256(bytes);
+}
+function buf(bytes) {
+  return bytes.slice();
+}
+
+export { BackupSigner, Cavos, CavosAuth, CavosSolana, CavosStellar, DEVICE_ACCOUNT_CLASS_HASH, DEVICE_ACCOUNT_PROGRAM_ID, DEVICE_ACCOUNT_WASM_HASH, FACTORY_CONTRACT_ID, HttpRecoveryClient, HttpWalletRegistry, InMemoryWalletRegistry, NATIVE_SAC_ID, PasskeySigner, SECP256R1_PROGRAM_ID, SOLANA_NETWORKS, STARKNET_NETWORKS, STELLAR_NETWORKS, SolanaAdapter, SolanaRelayer, StarknetAdapter, StarknetDeviceSigner, StellarAdapter, StellarRelayer, UDC_ADDRESS, WebCryptoSigner, anchorDiscriminator, approveDeviceEverywhere, base64urlEncode, batchChallenge, bigIntTo32Bytes, buildSecp256r1Instruction, bytesToBigInt, bytesToHex, compressedPubkey, deriveAddressSeed, deriveAddressSeedSolana, deriveAddressSeedStellar, deriveBackupKey, deviceSignatureScVal, encodeLowSSignature, encodeLowSSignature2, generateRecoveryCode, hexToBytes, lowS, recoverCandidatePublicKeys, recoverYParity, sec1Pubkey, serializeInstructions, signatureToFelts, u256ToFelts, webauthnDigest };
+//# sourceMappingURL=chunk-F2J25XSL.mjs.map
+//# sourceMappingURL=chunk-F2J25XSL.mjs.map