@cavos/kit 0.0.2 → 0.0.4

package/dist/chunk-PEUQQZB5.mjs

@@ -1,1672 +0,0 @@
-import { p256 } from '@noble/curves/p256';
-import { sha256 } from '@noble/hashes/sha256';
-import { hash, num, Signer, RpcProvider, PaymasterRpc, Account } 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';
-
-// 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 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: "0x1840aded59e8a0d2b440a134cb9079a7fc11b06c77f58ed189ab436a034ca6a",
-  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));
-  }
-};
-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 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 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, 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;
-  }
-  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 lowS = s > SECP256R1_N / 2n ? SECP256R1_N - s : s;
-  const out = new Uint8Array(SIGNATURE_SIZE);
-  out.set(bigIntTo32Bytes(r), 0);
-  out.set(bigIntTo32Bytes(lowS), 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 u64le(n) {
-  const b = Buffer.alloc(8);
-  new DataView(b.buffer, b.byteOffset, 8).setBigUint64(0, BigInt(n), true);
-  return b;
-}
-function readU64le(buf, offset) {
-  return new DataView(buf.buffer, buf.byteOffset, buf.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"
-];
-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";
-  }
-  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);
-    return new _CavosSolana(
-      identity,
-      address,
-      isSigner ? "ready" : "needs-device-approval",
-      connection,
-      adapter,
-      devicePubkey,
-      relayer,
-      opts.feePayer
-    );
-  }
-  /** 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);
-  }
-  /** 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/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 Cavos = class _Cavos {
-  constructor(identity, address, status, account, adapter, devicePubkey) {
-    this.identity = identity;
-    this.address = address;
-    this.status = status;
-    this.account = account;
-    this.adapter = adapter;
-    this.devicePubkey = devicePubkey;
-    /** 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;
-  }
-  /**
-   * 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.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 paymaster = new PaymasterRpc({
-      nodeUrl: opts.paymasterUrl ?? CAVOS_PAYMASTER_URL[opts.network],
-      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({
-      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 }) : defaultRegistry2);
-    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 cavos = new _Cavos(
-        identity,
-        existing.address,
-        isSigner2 ? "ready" : "needs-device-approval",
-        account2,
-        adapter,
-        devicePubkey
-      );
-      if (!isSigner2 && recovery) {
-        const dedup = lastDeviceRequest.get(identity.userId);
-        const fresh = dedup && Date.now() - dedup.requestedAt < DEVICE_REQUEST_DEDUP_MS;
-        try {
-          if (fresh) {
-            cavos.pendingRequestId = dedup.requestId;
-          } else {
-            const { requestId } = await recovery.requestDeviceAddition({
-              userId: identity.userId,
-              accountAddress: existing.address,
-              newSigner: devicePubkey,
-              ...identity.email ? { email: identity.email } : {}
-            });
-            cavos.pendingRequestId = requestId;
-            lastDeviceRequest.set(identity.userId, { requestId, requestedAt: Date.now() });
-          }
-        } catch (e) {
-          console.warn("[Cavos] requestDeviceAddition failed:", e);
-        }
-      }
-      return cavos;
-    }
-    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;
-    }
-    return new _Cavos(
-      identity,
-      address,
-      isSigner ? "ready" : "needs-device-approval",
-      account,
-      adapter,
-      devicePubkey
-    );
-  }
-  /** 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)]);
-  }
-  /**
-   * 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 }) : defaultRegistry2);
-    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({
-      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({
-      provider,
-      address: existing.address,
-      signer: new StarknetDeviceSigner(signer),
-      paymaster,
-      cairoVersion: "1"
-    });
-    return new _Cavos(opts.identity, existing.address, "ready", account, adapter, devicePubkey);
-  }
-};
-var defaultRegistry2 = 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;
-  }
-}
-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;
-}
-
-export { BackupSigner, Cavos, CavosAuth, CavosSolana, DEVICE_ACCOUNT_CLASS_HASH, DEVICE_ACCOUNT_PROGRAM_ID, HttpRecoveryClient, HttpWalletRegistry, InMemoryWalletRegistry, SECP256R1_PROGRAM_ID, SOLANA_NETWORKS, STARKNET_NETWORKS, SolanaAdapter, SolanaRelayer, StarknetAdapter, StarknetDeviceSigner, UDC_ADDRESS, WebCryptoSigner, anchorDiscriminator, bigIntTo32Bytes, buildSecp256r1Instruction, bytesToBigInt, bytesToHex, compressedPubkey, deriveAddressSeed, deriveAddressSeedSolana, deriveBackupKey, encodeLowSSignature, generateRecoveryCode, hexToBytes, recoverYParity, serializeInstructions, signatureToFelts, u256ToFelts };
-//# sourceMappingURL=chunk-PEUQQZB5.mjs.map
-//# sourceMappingURL=chunk-PEUQQZB5.mjs.map