@chipi-stack/backend 14.4.0 → 14.7.0

package/dist/index.js

@@ -1,8 +1,9 @@
 'use strict';
 
+var starknet = require('starknet');
 var shared = require('@chipi-stack/shared');
 var CryptoES = require('crypto-es');
-var starknet = require('starknet');
+var crypto = require('crypto');
 var types = require('@chipi-stack/types');
 var core = require('@chipi-stack/core');
 
@@ -10,7 +11,649 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var CryptoES__default = /*#__PURE__*/_interopDefault(CryptoES);
 
-// src/chipi-sdk.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function poseidon(values) {
+  const felts = values.map((v) => typeof v === "bigint" ? "0x" + v.toString(16) : v);
+  return BigInt(starknet.hash.computePoseidonHashOnElements(felts));
+}
+function ownerCommitment(kindTag, pubkey) {
+  return poseidon([kindTag, ...pubkey]);
+}
+function computeAddressSalt(primaryKind, pubkey) {
+  if (pubkey.length === 0) {
+    throw new Error(
+      "computeAddressSalt: pubkey must contain at least one felt \u2014 empty signer material is rejected to prevent silent address mismatch."
+    );
+  }
+  const kindTag = BigInt(starknet.shortString.encodeShortString(primaryKind));
+  const pubkeyHash = ownerCommitment(kindTag, pubkey);
+  return poseidon([kindTag, pubkeyHash]);
+}
+function computeShhhAddress(input) {
+  const {
+    classHash,
+    primaryKind,
+    pubkey,
+    verifierClassHash,
+    label = "primary",
+    deployerAddress = 0n
+  } = input;
+  const salt = computeAddressSalt(primaryKind, pubkey);
+  const kindTag = BigInt(starknet.shortString.encodeShortString(primaryKind));
+  const labelFelt = BigInt(starknet.shortString.encodeShortString(label));
+  const ctor = [
+    kindTag,
+    verifierClassHash,
+    BigInt(pubkey.length),
+    ...pubkey,
+    labelFelt
+  ];
+  const addressHex = starknet.hash.calculateContractAddressFromHash(
+    "0x" + salt.toString(16),
+    "0x" + classHash.toString(16),
+    ctor.map((x) => typeof x === "bigint" ? "0x" + x.toString(16) : x),
+    "0x" + deployerAddress.toString(16)
+  );
+  return BigInt(addressHex);
+}
+var init_compute_wallet_address = __esm({
+  "src/shhh/compute-wallet-address.ts"() {
+  }
+});
+function computeISignerId() {
+  return BigInt(starknet.hash.starknetKeccak(exports.ISIGNER_CANONICAL_LABEL));
+}
+function toBigInt(x) {
+  if (typeof x === "bigint") return x;
+  if (typeof x === "number") return BigInt(x);
+  return BigInt(x);
+}
+function poseidonSpan(values) {
+  const felts = values.map((v) => typeof v === "bigint" ? "0x" + v.toString(16) : v);
+  return BigInt(starknet.hash.computePoseidonHashOnElements(felts));
+}
+function hashCall(call) {
+  const calldataFelts = starknet.CallData.toHex(
+    Array.isArray(call.calldata) ? call.calldata : [call.calldata]
+  );
+  const calldataItems = calldataFelts.map((x) => BigInt(x));
+  const calldataHash = poseidonSpan(calldataItems);
+  return poseidonSpan([
+    CALL_TYPE_HASH_REV1,
+    toBigInt(call.contractAddress),
+    toBigInt(starknet.hash.getSelectorFromName(call.entrypoint)),
+    calldataHash
+  ]);
+}
+function hashCalls(calls) {
+  const callHashes = calls.map(hashCall);
+  return poseidonSpan(callHashes);
+}
+function hashStarknetDomain(chainIdFelt) {
+  return poseidonSpan([
+    STARKNET_DOMAIN_TYPE_HASH_REV1,
+    BigInt(exports.OE_DOMAIN_NAME),
+    exports.OE_DOMAIN_VERSION,
+    toBigInt(chainIdFelt),
+    exports.OE_DOMAIN_REVISION
+  ]);
+}
+function hashOutsideExecutionStruct(oe) {
+  const callsArrayHash = hashCalls(oe.calls);
+  return poseidonSpan([
+    OUTSIDE_EXECUTION_TYPE_HASH_REV1,
+    toBigInt(oe.caller),
+    toBigInt(oe.nonce),
+    oe.execute_after,
+    oe.execute_before,
+    callsArrayHash
+  ]);
+}
+function computeSnip12Hash(oe, contractAddress, chainIdFelt) {
+  const domainHash = hashStarknetDomain(chainIdFelt);
+  const structHash = hashOutsideExecutionStruct(oe);
+  return poseidonSpan([
+    BigInt(exports.STARKNET_MESSAGE_PREFIX),
+    domainHash,
+    toBigInt(contractAddress),
+    structHash
+  ]);
+}
+function snip12HashToHexAsciiBytes(h) {
+  const hex = h.toString(16).padStart(64, "0");
+  return new TextEncoder().encode(hex);
+}
+var OUTSIDE_EXECUTION_TYPE_HASH_REV1, CALL_TYPE_HASH_REV1, STARKNET_DOMAIN_TYPE_HASH_REV1; exports.STARKNET_MESSAGE_PREFIX = void 0; exports.OE_DOMAIN_NAME = void 0; exports.OE_DOMAIN_VERSION = void 0; exports.OE_DOMAIN_REVISION = void 0; exports.SIG_VERSION_V1_HEX_ASCII = void 0; exports.SIG_VERSION_V2_SNIP12 = void 0; exports.SIG_VERSION_V2_THRESHOLD = void 0; exports.ISRC9_V2_ID = void 0; exports.ISIGNER_ID = void 0; exports.ISIGNER_CANONICAL_LABEL = void 0;
+var init_snip12_hash = __esm({
+  "src/shhh/snip12-hash.ts"() {
+    OUTSIDE_EXECUTION_TYPE_HASH_REV1 = 0x5a4b49e17039355cd95d1f0981d75901191d1319b1f4b05a9a791d218d7e0cn;
+    CALL_TYPE_HASH_REV1 = 0x3635c7f2a7ba93844c0d064e18e487f35ab90f7c39d00f186a781fc3f0c2ca9n;
+    STARKNET_DOMAIN_TYPE_HASH_REV1 = 0x1ff2f602e42168014d405a94f75e8a93d640751d71d16311266e140d8b0a210n;
+    exports.STARKNET_MESSAGE_PREFIX = starknet.shortString.encodeShortString("StarkNet Message");
+    exports.OE_DOMAIN_NAME = starknet.shortString.encodeShortString("Account.execute_from_outside");
+    exports.OE_DOMAIN_VERSION = 2n;
+    exports.OE_DOMAIN_REVISION = 1n;
+    exports.SIG_VERSION_V1_HEX_ASCII = starknet.shortString.encodeShortString("V1_HEX_ASCII");
+    exports.SIG_VERSION_V2_SNIP12 = starknet.shortString.encodeShortString("V2_SNIP12");
+    exports.SIG_VERSION_V2_THRESHOLD = starknet.shortString.encodeShortString("V2_THRESHOLD");
+    exports.ISRC9_V2_ID = BigInt(
+      "0x1d1144bb2138366ff28d8e9ab57456b1d332ac42196230c3a602003c89872"
+    );
+    exports.ISIGNER_ID = BigInt(
+      "0x94c5a761f34b25a4e603c651ac0e1fc4fad9cdb5517f7fa1bb54044c7e5ef8"
+    );
+    exports.ISIGNER_CANONICAL_LABEL = "ISigner_V1";
+  }
+});
+function assertValidV2Snip12Envelope(envelope) {
+  if (envelope.length < 2) {
+    throw new Error(
+      `THRESH: inner envelope must have at least 2 felts (tag + owner_id); got ${envelope.length}`
+    );
+  }
+  const tag = envelope[0];
+  if (tag !== V2_SNIP12_TAG) {
+    if (tag === V2_THRESHOLD_TAG) {
+      throw new Error(
+        "THRESH: nested threshold envelopes are not allowed; inner envelopes must be V2_SNIP12"
+      );
+    }
+    const decoded = _tryDecodeShortString(tag);
+    throw new Error(
+      `THRESH: inner envelope tag must be V2_SNIP12; got ${decoded ?? "0x" + tag.toString(16)}`
+    );
+  }
+  return envelope[1];
+}
+function _tryDecodeShortString(felt) {
+  try {
+    return starknet.shortString.decodeShortString("0x" + felt.toString(16));
+  } catch {
+    return null;
+  }
+}
+function buildThresholdEnvelope(args) {
+  const { innerEnvelopes } = args;
+  if (innerEnvelopes.length < exports.MIN_THRESHOLD_OWNERS) {
+    throw new Error(
+      `THRESH: need at least ${exports.MIN_THRESHOLD_OWNERS} inner envelopes; got ${innerEnvelopes.length}. Use wrap_v2_snip12_envelope for single-owner OEs.`
+    );
+  }
+  const seenOwners = /* @__PURE__ */ new Set();
+  const out = [V2_THRESHOLD_TAG, BigInt(innerEnvelopes.length)];
+  for (let i = 0; i < innerEnvelopes.length; i++) {
+    const env = innerEnvelopes[i];
+    const ownerId = assertValidV2Snip12Envelope(env);
+    const key = ownerId.toString();
+    if (seenOwners.has(key)) {
+      throw new Error(
+        `THRESH: duplicate owner_id ${"0x" + ownerId.toString(16)} at inner envelope ${i}`
+      );
+    }
+    seenOwners.add(key);
+    out.push(BigInt(env.length));
+    for (const felt of env) {
+      if (felt < 0n) {
+        throw new RangeError(
+          `THRESH: envelope ${i} contains negative felt (cannot serialize as felt252)`
+        );
+      }
+      out.push(felt);
+    }
+  }
+  return out;
+}
+function parseThresholdEnvelope(envelope) {
+  if (envelope.length < 2) {
+    throw new Error(`THRESH: envelope too short (need at least [tag, n]); got ${envelope.length}`);
+  }
+  if (envelope[0] !== V2_THRESHOLD_TAG) {
+    throw new Error(`THRESH: envelope tag must be V2_THRESHOLD; got 0x${envelope[0].toString(16)}`);
+  }
+  const n = Number(envelope[1]);
+  if (!Number.isInteger(n) || n < exports.MIN_THRESHOLD_OWNERS) {
+    throw new Error(`THRESH: n must be an integer >= ${exports.MIN_THRESHOLD_OWNERS}; got ${envelope[1]}`);
+  }
+  const seenOwners = /* @__PURE__ */ new Set();
+  const innerEnvelopes = [];
+  let cursor = 2;
+  for (let i = 0; i < n; i++) {
+    if (cursor >= envelope.length) {
+      throw new Error(`THRESH: envelope truncated at inner ${i} (no length felt)`);
+    }
+    const envLen = Number(envelope[cursor]);
+    cursor += 1;
+    if (!Number.isInteger(envLen) || envLen < 2) {
+      throw new Error(`THRESH: inner ${i} env_len must be >= 2; got ${envLen}`);
+    }
+    if (cursor + envLen > envelope.length) {
+      throw new Error(
+        `THRESH: inner ${i} would overflow envelope (env_len ${envLen}, cursor ${cursor}, total ${envelope.length})`
+      );
+    }
+    const inner = envelope.slice(cursor, cursor + envLen);
+    for (const felt of inner) {
+      if (felt < 0n) {
+        throw new RangeError(
+          `THRESH: inner ${i} contains negative felt (cannot serialize as felt252)`
+        );
+      }
+    }
+    const ownerId = assertValidV2Snip12Envelope(inner);
+    const key = ownerId.toString();
+    if (seenOwners.has(key)) {
+      throw new Error(
+        `THRESH: duplicate owner_id ${"0x" + ownerId.toString(16)} at inner envelope ${i}`
+      );
+    }
+    seenOwners.add(key);
+    innerEnvelopes.push(inner);
+    cursor += envLen;
+  }
+  if (cursor !== envelope.length) {
+    throw new Error(
+      `THRESH: trailing bytes after inner ${n - 1} (cursor ${cursor}, length ${envelope.length})`
+    );
+  }
+  return { innerEnvelopes };
+}
+function estimateThresholdGasOverhead(owners) {
+  if (owners.length < exports.MIN_THRESHOLD_OWNERS) {
+    throw new Error(
+      `THRESH: need at least ${exports.MIN_THRESHOLD_OWNERS} owners to estimate threshold gas; got ${owners.length}`
+    );
+  }
+  let total = 0;
+  for (const { signerKind } of owners) {
+    const overhead = shared.SHHH_KIND_GAS_OVERHEAD[signerKind];
+    if (overhead === void 0) {
+      throw new Error(
+        `THRESH: unknown signer kind ${signerKind} \u2014 missing from SHHH_KIND_GAS_OVERHEAD`
+      );
+    }
+    total += overhead;
+  }
+  return total;
+}
+var V2_SNIP12_TAG, V2_THRESHOLD_TAG; exports.MIN_THRESHOLD_OWNERS = void 0;
+var init_threshold = __esm({
+  "src/shhh/threshold.ts"() {
+    init_snip12_hash();
+    V2_SNIP12_TAG = BigInt(exports.SIG_VERSION_V2_SNIP12);
+    V2_THRESHOLD_TAG = BigInt(exports.SIG_VERSION_V2_THRESHOLD);
+    exports.MIN_THRESHOLD_OWNERS = 2;
+  }
+});
+
+// src/shhh/oe.ts
+var oe_exports = {};
+__export(oe_exports, {
+  ANY_CALLER_FELT: () => exports.ANY_CALLER_FELT,
+  MAX_OE_VALIDITY_WINDOW_SECONDS: () => exports.MAX_OE_VALIDITY_WINDOW_SECONDS,
+  OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER: () => OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER,
+  buildOutsideExecution: () => buildOutsideExecution,
+  computeOeHash: () => computeOeHash,
+  wrapV2Snip12Envelope: () => wrapV2Snip12Envelope,
+  wrapV2ThresholdEnvelope: () => wrapV2ThresholdEnvelope
+});
+function buildOutsideExecution(params) {
+  const nowSec = BigInt(Math.floor(Date.now() / 1e3));
+  const after = params.executeAfter ?? nowSec - BigInt(OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER);
+  const before = params.executeBefore ?? nowSec + BigInt(exports.MAX_OE_VALIDITY_WINDOW_SECONDS) - BigInt(OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER);
+  if (before <= after) {
+    throw new Error(
+      `executeBefore (${before}) must be strictly greater than executeAfter (${after}).`
+    );
+  }
+  if (before - after > BigInt(exports.MAX_OE_VALIDITY_WINDOW_SECONDS)) {
+    throw new Error(
+      `OE validity window ${before - after}s exceeds max ${exports.MAX_OE_VALIDITY_WINDOW_SECONDS}s (audit M-2). Adjust executeBefore.`
+    );
+  }
+  return {
+    caller: params.caller ?? exports.ANY_CALLER_FELT,
+    nonce: params.nonce,
+    execute_after: after,
+    execute_before: before,
+    calls: params.calls
+  };
+}
+function computeOeHash(oe, accountAddress, chainId) {
+  return computeSnip12Hash(oe, accountAddress, chainId);
+}
+function wrapV2Snip12Envelope(params) {
+  const tag = typeof params.kindTag === "bigint" ? params.kindTag : BigInt(starknet.shortString.encodeShortString(params.kindTag));
+  return [
+    BigInt(exports.SIG_VERSION_V2_SNIP12),
+    params.ownerId,
+    tag,
+    ...params.payload.map((v) => typeof v === "bigint" ? v : BigInt(v))
+  ];
+}
+function wrapV2ThresholdEnvelope(innerEnvelopes) {
+  return buildThresholdEnvelope({ innerEnvelopes });
+}
+exports.ANY_CALLER_FELT = void 0; exports.MAX_OE_VALIDITY_WINDOW_SECONDS = void 0; var OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER;
+var init_oe = __esm({
+  "src/shhh/oe.ts"() {
+    init_snip12_hash();
+    init_threshold();
+    exports.ANY_CALLER_FELT = BigInt(starknet.shortString.encodeShortString("ANY_CALLER"));
+    exports.MAX_OE_VALIDITY_WINDOW_SECONDS = 2 * 60 * 60;
+    OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER = 60;
+  }
+});
+async function ensureGaragaInit() {
+  if (garagaInitPromise) return garagaInitPromise;
+  const attempt = (async () => {
+    const garaga = await import('garaga');
+    await garaga.init();
+    return garaga;
+  })();
+  garagaInitPromise = attempt;
+  try {
+    return await attempt;
+  } catch (err) {
+    if (garagaInitPromise === attempt) garagaInitPromise = null;
+    throw err;
+  }
+}
+function bytesToLeU256(bytes) {
+  if (bytes.length !== 32) {
+    throw new Error(`Ed25519 value must be exactly 32 bytes; got ${bytes.length}.`);
+  }
+  let low = 0n;
+  let high = 0n;
+  for (let i = 0; i < 16; i++) low += BigInt(bytes[i]) << BigInt(8 * i);
+  for (let i = 0; i < 16; i++) high += BigInt(bytes[16 + i]) << BigInt(8 * i);
+  return { low, high };
+}
+function bytesToLeBigInt(bytes) {
+  let x = 0n;
+  for (let i = bytes.length - 1; i >= 0; i--) x = x << 8n | BigInt(bytes[i]);
+  return x;
+}
+function ed25519SignedBytes(messageHash) {
+  return snip12HashToHexAsciiBytes(messageHash);
+}
+function ed25519OwnerId(publicKey) {
+  const { low, high } = bytesToLeU256(publicKey);
+  return ownerCommitment(ED25519_KIND_TAG_FELT, [low, high]);
+}
+function ed25519PubkeyFelts(publicKey) {
+  const { low, high } = bytesToLeU256(publicKey);
+  return [low, high];
+}
+async function buildEd25519Envelope(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildEd25519Envelope: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32). owner_id is the u32 INDEX into the wallet's owner_set (0 for primary, 1 for second, etc.); do NOT pass an owner_commitment or pubkey here.`
+    );
+  }
+  if (params.privateKey.length !== 32) {
+    throw new Error(
+      `Ed25519 private key must be exactly 32 bytes; got ${params.privateKey.length}.`
+    );
+  }
+  const ed = await import('@noble/ed25519');
+  const publicKey = await ed.getPublicKeyAsync(params.privateKey);
+  const signedBytes = ed25519SignedBytes(params.messageHash);
+  const signature = await ed.signAsync(signedBytes, params.privateKey);
+  return assembleEd25519Envelope({
+    R: signature.slice(0, 32),
+    s: signature.slice(32, 64),
+    publicKey,
+    signedBytes,
+    ownerIndex
+  });
+}
+async function buildEd25519EnvelopeFromSignature(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildEd25519EnvelopeFromSignature: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32). owner_id is the u32 INDEX into the wallet's owner_set (0 for primary); do NOT pass an owner_commitment or pubkey here.`
+    );
+  }
+  if (params.signature.length !== 64) {
+    throw new Error(
+      `Ed25519 signature must be exactly 64 bytes (R\u2016s); got ${params.signature.length}.`
+    );
+  }
+  if (params.publicKey.length !== 32) {
+    throw new Error(`Ed25519 public key must be exactly 32 bytes; got ${params.publicKey.length}.`);
+  }
+  const signedBytes = ed25519SignedBytes(params.messageHash);
+  return assembleEd25519Envelope({
+    R: params.signature.slice(0, 32),
+    s: params.signature.slice(32, 64),
+    publicKey: params.publicKey,
+    signedBytes,
+    ownerIndex
+  });
+}
+async function assembleEd25519Envelope(parts) {
+  const garaga = await ensureGaragaInit();
+  const payload = garaga.eddsaCalldataBuilder(
+    bytesToLeBigInt(parts.R),
+    bytesToLeBigInt(parts.s),
+    bytesToLeBigInt(parts.publicKey),
+    parts.signedBytes,
+    false
+  );
+  return wrapV2Snip12Envelope({
+    ownerId: parts.ownerIndex,
+    kindTag: ED25519_KIND_TAG,
+    payload
+  });
+}
+var ED25519_KIND_TAG, ED25519_KIND_TAG_FELT, garagaInitPromise;
+var init_ed25519 = __esm({
+  "src/shhh/signers/ed25519.ts"() {
+    init_compute_wallet_address();
+    init_oe();
+    init_snip12_hash();
+    ED25519_KIND_TAG = "ED25519";
+    ED25519_KIND_TAG_FELT = BigInt(starknet.shortString.encodeShortString(ED25519_KIND_TAG));
+    garagaInitPromise = null;
+  }
+});
+exports.encryptPrivateKey = void 0; exports.decryptPrivateKey = void 0;
+var init_encryption = __esm({
+  "src/lib/encryption.ts"() {
+    exports.encryptPrivateKey = (privateKey, password) => {
+      if (!privateKey || !password) {
+        throw new Error("Private key and password are required");
+      }
+      return CryptoES__default.default.AES.encrypt(privateKey, password).toString();
+    };
+    exports.decryptPrivateKey = (encryptedPrivateKey, password) => {
+      if (!encryptedPrivateKey || !password) {
+        throw new Error("Encrypted private key and password are required");
+      }
+      try {
+        const bytes = CryptoES__default.default.AES.decrypt(encryptedPrivateKey, password);
+        const decrypted = bytes.toString(CryptoES__default.default.enc.Utf8);
+        if (!decrypted) {
+          throw new Error("Decryption resulted in empty string");
+        }
+        return decrypted;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw error;
+        }
+        throw new Error(`Decryption failed: ${error}`);
+      }
+    };
+  }
+});
+
+// src/encryption.ts
+var init_encryption2 = __esm({
+  "src/encryption.ts"() {
+    init_encryption();
+  }
+});
+function buildStarkEnvelope(params) {
+  const pkHex = "0x" + (typeof params.privateKey === "bigint" ? params.privateKey : BigInt(params.privateKey)).toString(16).padStart(64, "0");
+  const sig = starknet.ec.starkCurve.sign("0x" + params.messageHash.toString(16), pkHex);
+  const r = BigInt("0x" + sig.r.toString(16));
+  const s = BigInt("0x" + sig.s.toString(16));
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildStarkEnvelope: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32). owner_id is the u32 INDEX into the wallet's owner_set (0 for primary, 1 for second, etc.); do NOT pass an owner_commitment or pubkey here.`
+    );
+  }
+  return wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: STARK_KIND_TAG,
+    payload: [r, s]
+  });
+}
+function starkOwnerId(starkPubKey) {
+  return ownerCommitment(STARK_KIND_TAG_FELT, [starkPubKey]);
+}
+function starkPubkeyFelts(starkPubKey) {
+  return [typeof starkPubKey === "bigint" ? starkPubKey : BigInt(starkPubKey)];
+}
+var STARK_KIND_TAG, STARK_KIND_TAG_FELT;
+var init_stark = __esm({
+  "src/shhh/signers/stark.ts"() {
+    init_compute_wallet_address();
+    init_oe();
+    STARK_KIND_TAG = "STARK";
+    STARK_KIND_TAG_FELT = BigInt(starknet.shortString.encodeShortString(STARK_KIND_TAG));
+  }
+});
+
+// src/shhh/execute-paymaster-raw.ts
+var execute_paymaster_raw_exports = {};
+__export(execute_paymaster_raw_exports, {
+  executeShhhSponsoredRaw: () => executeShhhSponsoredRaw,
+  resolveShhhChainId: () => resolveShhhChainId,
+  serializeExecuteFromOutsideV2Calldata: () => serializeExecuteFromOutsideV2Calldata
+});
+function resolveShhhChainId(params) {
+  if (params.override !== void 0) {
+    return typeof params.override === "bigint" ? "0x" + params.override.toString(16) : params.override;
+  }
+  const url = (params.baseUrl ?? "").toLowerCase();
+  if (url.includes("sepolia")) return SN_SEPOLIA_CHAIN_ID;
+  return SN_MAIN_CHAIN_ID;
+}
+function serializeExecuteFromOutsideV2Calldata(params) {
+  const out = [];
+  const oe = params.outsideExecution;
+  const toBig = (v) => typeof v === "bigint" ? v : BigInt(v);
+  out.push(toBig(oe.caller));
+  out.push(toBig(oe.nonce));
+  out.push(oe.execute_after);
+  out.push(oe.execute_before);
+  out.push(BigInt(oe.calls.length));
+  for (const call of oe.calls) {
+    out.push(BigInt(call.contractAddress));
+    out.push(BigInt(starknet.hash.getSelectorFromName(call.entrypoint)));
+    const callData = Array.isArray(call.calldata) ? call.calldata : [];
+    out.push(BigInt(callData.length));
+    for (const datum of callData) {
+      out.push(typeof datum === "bigint" ? datum : BigInt(datum));
+    }
+  }
+  out.push(BigInt(params.signature.length));
+  for (const sigFelt of params.signature) {
+    out.push(sigFelt);
+  }
+  return out.map((v) => "0x" + v.toString(16));
+}
+function newOeNonce() {
+  const tsMs = BigInt(Date.now());
+  const rand = BigInt(Math.floor(Math.random() * 16777215));
+  return tsMs << 24n | rand;
+}
+async function executeShhhSponsoredRaw(params) {
+  const signerKind = params.signerKind ?? "STARK";
+  const SDK_SHIPPED_OE_KINDS = ["STARK", "ED25519"];
+  if (!SDK_SHIPPED_OE_KINDS.includes(signerKind)) {
+    throw new Error(
+      `SHHH signerKind="${signerKind}" is not yet shipped from the SDK (Wave B ships STARK + ED25519). Wait for the follow-up PR that adds external-rooted (MetaMask, Phantom, passkey, Apple) signing.`
+    );
+  }
+  const privateKeyHex = exports.decryptPrivateKey(params.wallet.encryptedPrivateKey, params.encryptKey);
+  if (!privateKeyHex) {
+    throw new Error(
+      "Failed to decrypt private key for SHHH OE. Verify the encryptKey matches the one used at wallet creation."
+    );
+  }
+  const oe = buildOutsideExecution({
+    nonce: params.nonce ?? newOeNonce(),
+    calls: params.calls,
+    caller: exports.ANY_CALLER_FELT
+  });
+  const chainId = resolveShhhChainId({
+    override: params.chainId,
+    baseUrl: params.client.baseUrl
+  });
+  const messageHash = computeOeHash(oe, params.wallet.publicKey, chainId);
+  let signature;
+  if (signerKind === "STARK") {
+    signature = buildStarkEnvelope({
+      privateKey: privateKeyHex,
+      messageHash
+    });
+  } else {
+    const edKeyHex = privateKeyHex.startsWith("0x") ? privateKeyHex.slice(2) : privateKeyHex;
+    if (edKeyHex.length !== 64) {
+      throw new Error(
+        `SHHH ED25519 private key is ${edKeyHex.length} hex chars; expected 64 (32 raw bytes). The stored ciphertext does not look like a Chipi-held Ed25519 key \u2014 check wallet provenance.`
+      );
+    }
+    const edPrivKey = Uint8Array.from(Buffer.from(edKeyHex, "hex"));
+    signature = await buildEd25519Envelope({
+      privateKey: edPrivKey,
+      messageHash
+    });
+  }
+  const calldata = serializeExecuteFromOutsideV2Calldata({
+    outsideExecution: oe,
+    signature
+  });
+  const response = await params.client.post({
+    endpoint: "/transactions/execute-sponsored-raw",
+    bearerToken: params.bearerToken,
+    body: {
+      accountAddress: params.wallet.publicKey,
+      calldata,
+      signerKind,
+      ...params.externalUserId ? { externalUserId: params.externalUserId } : {}
+    }
+  });
+  if (!response || !response.transactionHash) {
+    throw new Error(
+      "execute-sponsored-raw response missing transactionHash. Check the chipi-back logs for upstream paymaster errors."
+    );
+  }
+  return response.transactionHash;
+}
+var SN_MAIN_CHAIN_ID, SN_SEPOLIA_CHAIN_ID;
+var init_execute_paymaster_raw = __esm({
+  "src/shhh/execute-paymaster-raw.ts"() {
+    init_encryption2();
+    init_oe();
+    init_stark();
+    init_ed25519();
+    SN_MAIN_CHAIN_ID = "0x534e5f4d41494e";
+    SN_SEPOLIA_CHAIN_ID = "0x534e5f5345504f4c4941";
+  }
+});
 var ChipiClient = class {
   constructor(config) {
     if (!shared.isValidApiKey(config.apiPublicKey)) {
@@ -193,294 +836,60 @@ var ChipiClient = class {
     }
   }
 };
-var encryptPrivateKey = (privateKey, password) => {
-  if (!privateKey || !password) {
-    throw new Error("Private key and password are required");
+
+// src/wallets.ts
+init_compute_wallet_address();
+init_ed25519();
+init_encryption2();
+
+// src/migrate-to-shhh.ts
+init_encryption2();
+
+// src/execute-paymaster-transaction.ts
+init_encryption2();
+function unwrapPrepareResponse(response) {
+  if (!response || typeof response !== "object") {
+    throw new Error(
+      "Invalid response from /transactions/prepare-typed-data: response is not an object"
+    );
   }
-  return CryptoES__default.default.AES.encrypt(privateKey, password).toString();
-};
-var decryptPrivateKey = (encryptedPrivateKey, password) => {
-  if (!encryptedPrivateKey || !password) {
-    throw new Error("Encrypted private key and password are required");
+  if ("typedData" in response) {
+    const resp = response;
+    if (!resp.typedData || typeof resp.typedData !== "object" || !("types" in resp.typedData) || !("message" in resp.typedData)) {
+      throw new Error(
+        "Invalid response from /transactions/prepare-typed-data: typedData structure is invalid"
+      );
+    }
+    return { typedData: resp.typedData, walletType: resp.walletType };
   }
-  try {
-    const bytes = CryptoES__default.default.AES.decrypt(encryptedPrivateKey, password);
-    const decrypted = bytes.toString(CryptoES__default.default.enc.Utf8);
-    if (!decrypted) {
-      throw new Error("Decryption resulted in empty string");
+  if ("types" in response && "message" in response) {
+    return { typedData: response };
+  }
+  const apiMessage = typeof response.message === "string" ? response.message : void 0;
+  throw new Error(
+    apiMessage ?? "Invalid response from /transactions/prepare-typed-data: typedData is missing"
+  );
+}
+function normalizeSignature(signature) {
+  if (Array.isArray(signature)) {
+    if (signature.length < 2) {
+      throw new Error(`Array signature must have at least 2 elements, got ${signature.length}`);
     }
-    return decrypted;
-  } catch (error) {
-    if (error instanceof Error) {
-      throw error;
+    const r = signature[0];
+    const s = signature[1];
+    if (r == null || s == null) {
+      throw new Error(`Signature elements must not be null/undefined. Got r=${r}, s=${s}`);
     }
-    throw new Error(`Decryption failed: ${error}`);
+    return { r: String(r), s: String(s) };
   }
-};
-
-// src/wallets.ts
-var ChipiWallets = class {
-  constructor(client) {
-    this.client = client;
-    this.getPrivateKeyAX = () => {
-      const privateKeyBytes = CryptoES__default.default.lib.WordArray.random(32);
-      const privateKey = privateKeyBytes.toString(CryptoES__default.default.enc.Hex);
-      const fullPrivateKey = `0x${privateKey}`;
-      const maxStarknetValue = BigInt(
-        "0x800000000000000000000000000000000000000000000000000000000000000"
-      );
-      const privateKeyBigInt = BigInt(fullPrivateKey) % maxStarknetValue;
-      return `0x${privateKeyBigInt.toString(16)}`;
-    };
-  }
-  async createWallet(params) {
-    try {
-      const {
-        encryptKey,
-        externalUserId,
-        bearerToken,
-        userId,
-        walletType = "CHIPI",
-        // Default to CHIPI wallet
-        classHash: customClassHash,
-        usePasskey,
-        chain
-      } = params;
-      if (!encryptKey) {
-        if (usePasskey) {
-          throw new Error(
-            "encryptKey is required when using passkey. The passkey authentication should have provided the encryptKey."
-          );
-        }
-        throw new Error("encryptKey is required for wallet creation");
-      }
-      const rpcUrl = walletType === "READY" ? shared.WALLET_RPC_ENDPOINTS.READY : shared.WALLET_RPC_ENDPOINTS.CHIPI;
-      const provider = new starknet.RpcProvider({ nodeUrl: rpcUrl });
-      const privateKeyAX = this.getPrivateKeyAX();
-      const starkKeyPubAX = starknet.ec.starkCurve.getStarkKey(privateKeyAX);
-      const constructorCallData = this.buildConstructorCallData(walletType, starkKeyPubAX);
-      const accountClassHash = customClassHash ?? (walletType === "READY" ? shared.WALLET_CLASS_HASHES.READY : shared.WALLET_CLASS_HASHES.CHIPI);
-      const publicKey = starknet.hash.calculateContractAddressFromHash(
-        starkKeyPubAX,
-        accountClassHash,
-        constructorCallData,
-        0
-      );
-      const account = new starknet.Account({ provider, address: publicKey, signer: privateKeyAX });
-      const typedDataResponse = await this.client.post({
-        endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/prepare-creation`,
-        bearerToken,
-        body: {
-          chain,
-          publicKey,
-          walletType,
-          starkKeyPubAX,
-          ...customClassHash && { classHash: customClassHash }
-        }
-      });
-      const { typedData: typedData2, accountClassHash: accountClassHashResponse } = typedDataResponse;
-      const userSignature = await account.signMessage(typedData2);
-      const deploymentData = {
-        class_hash: accountClassHashResponse,
-        salt: starkKeyPubAX,
-        unique: `${starknet.num.toHex(0)}`,
-        calldata: constructorCallData.map((value) => starknet.num.toHex(value))
-      };
-      const encryptedPrivateKey = encryptPrivateKey(privateKeyAX, encryptKey);
-      const encryptedPrivateKeyBackup = params.encryptKeyBackup ? encryptPrivateKey(privateKeyAX, params.encryptKeyBackup) : void 0;
-      const executeTransactionResponse = await this.client.post({
-        endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}`,
-        bearerToken,
-        body: {
-          externalUserId,
-          userId,
-          publicKey,
-          walletType,
-          chain,
-          userSignature: {
-            r: userSignature.r.toString(),
-            s: userSignature.s.toString(),
-            recovery: userSignature.recovery
-          },
-          typedData: typedData2,
-          encryptedPrivateKey,
-          ...encryptedPrivateKeyBackup && { encryptedPrivateKeyBackup },
-          ...params.authMethod && { authMethod: params.authMethod },
-          ...params.credentialId && { credentialId: params.credentialId },
-          ...params.prfSupported != null && { prfSupported: params.prfSupported },
-          ...params.deviceType && { deviceType: params.deviceType },
-          deploymentData: {
-            ...deploymentData,
-            salt: `${deploymentData.salt}`,
-            calldata: deploymentData.calldata.map((data) => `${data}`)
-          }
-        }
-      });
-      return executeTransactionResponse;
-    } catch (error) {
-      console.error("Detailed error:", error);
-      if (error instanceof Error && error.message.includes("SSL")) {
-        throw new Error(
-          "SSL connection error. Try using NODE_TLS_REJECT_UNAUTHORIZED=0 or verify the RPC URL"
-        );
-      }
-      throw new shared.ChipiTransactionError(
-        `Failed to create wallet: ${error instanceof Error ? error.message : "Unknown error"}`,
-        "WALLET_CREATION_FAILED"
-      );
-    }
-  }
-  /**
-   * Build constructor calldata based on wallet type
-   * - CHIPI: Simple OpenZeppelin account with just public_key
-   * - ARGENT: Argent X Account with owner/guardian structure
-   */
-  buildConstructorCallData(walletType, starkKeyPubAX) {
-    if (walletType === "READY") {
-      const axSigner = new starknet.CairoCustomEnum({
-        Starknet: { pubkey: starkKeyPubAX }
-      });
-      const axGuardian = new starknet.CairoOption(starknet.CairoOptionVariant.None);
-      return starknet.CallData.compile({
-        owner: axSigner,
-        guardian: axGuardian
-      });
-    }
-    return starknet.CallData.compile({
-      public_key: starkKeyPubAX
-    });
-  }
-  /**
-   * Create a custodial merchant wallet
-   */
-  async createCustodialWallet({
-    params,
-    bearerToken
-  }) {
-    const response = await this.client.post({
-      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/custodial`,
-      bearerToken,
-      body: params
-    });
-    return response;
-  }
-  async getWallet(params, bearerToken) {
-    try {
-      const { externalUserId } = params;
-      const getWalletResponse = await this.client.get({
-        endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/by-user`,
-        params: { externalUserId },
-        bearerToken
-      });
-      return getWalletResponse;
-    } catch (err) {
-      if (err instanceof shared.ChipiApiError && err.status === 404) {
-        return null;
-      }
-      throw err;
-    }
-  }
-  /**
-   * Recover passkey credential metadata for a wallet.
-   * Used when localStorage is cleared — SDK recovers credentialId from backend.
-   */
-  async getCredentialRecovery(params, bearerToken) {
-    return this.client.get({
-      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/credential-recovery`,
-      params: { externalUserId: params.externalUserId },
-      bearerToken
-    });
-  }
-  async updateWalletEncryption(params, bearerToken) {
-    const body = {
-      externalUserId: params.externalUserId,
-      newEncryptedPrivateKey: params.newEncryptedPrivateKey
-    };
-    if (params.publicKey != null) {
-      body.publicKey = params.publicKey;
-    }
-    return this.client.patch({
-      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/update-encryption-details`,
-      bearerToken,
-      body
-    });
-  }
-  async getTokenBalance({
-    params,
-    bearerToken
-  }) {
-    const getBalanceResponse = await this.client.get({
-      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/token-balance`,
-      params,
-      bearerToken
-    });
-    return getBalanceResponse;
-  }
-  /**
-   * Prepare a wallet upgrade (e.g., READY → CHIPI or CHIPI v29 → v33).
-   * Returns typed data that must be signed by the wallet owner.
-   */
-  async prepareWalletUpgrade(params, bearerToken) {
-    return this.client.post({
-      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/prepare-upgrade`,
-      bearerToken,
-      body: params
-    });
-  }
-  /**
-   * Execute a wallet upgrade after the owner has signed the typed data.
-   */
-  async executeWalletUpgrade(params, bearerToken) {
-    return this.client.post({
-      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/upgrade`,
-      bearerToken,
-      body: params
-    });
-  }
-};
-function unwrapPrepareResponse(response) {
-  if (!response || typeof response !== "object") {
-    throw new Error(
-      "Invalid response from /transactions/prepare-typed-data: response is not an object"
-    );
-  }
-  if ("typedData" in response) {
-    const resp = response;
-    if (!resp.typedData || typeof resp.typedData !== "object" || !("types" in resp.typedData) || !("message" in resp.typedData)) {
-      throw new Error(
-        "Invalid response from /transactions/prepare-typed-data: typedData structure is invalid"
-      );
-    }
-    return { typedData: resp.typedData, walletType: resp.walletType };
-  }
-  if ("types" in response && "message" in response) {
-    return { typedData: response };
-  }
-  const apiMessage = typeof response.message === "string" ? response.message : void 0;
-  throw new Error(
-    apiMessage ?? "Invalid response from /transactions/prepare-typed-data: typedData is missing"
-  );
-}
-function normalizeSignature(signature) {
-  if (Array.isArray(signature)) {
-    if (signature.length < 2) {
-      throw new Error(`Array signature must have at least 2 elements, got ${signature.length}`);
-    }
-    const r = signature[0];
-    const s = signature[1];
-    if (r == null || s == null) {
-      throw new Error(`Signature elements must not be null/undefined. Got r=${r}, s=${s}`);
-    }
-    return { r: String(r), s: String(s) };
-  }
-  if (signature && typeof signature === "object" && "r" in signature && "s" in signature) {
-    const sig = signature;
-    if (sig.r == null || sig.s == null) {
-      throw new Error(`Object signature has null/undefined fields. Got r=${sig.r}, s=${sig.s}`);
-    }
-    return {
-      r: String(sig.r),
-      s: String(sig.s)
+  if (signature && typeof signature === "object" && "r" in signature && "s" in signature) {
+    const sig = signature;
+    if (sig.r == null || sig.s == null) {
+      throw new Error(`Object signature has null/undefined fields. Got r=${sig.r}, s=${sig.s}`);
+    }
+    return {
+      r: String(sig.r),
+      s: String(sig.s)
     };
   }
   throw new Error("Unrecognized signature format from account.signMessage()");
@@ -544,12 +953,28 @@ var executePaymasterTransaction = async ({
       );
     }
     const walletType = wallet.walletType ?? "READY";
+    if (walletType === "SHHH") {
+      const { executeShhhSponsoredRaw: executeShhhSponsoredRaw2 } = await Promise.resolve().then(() => (init_execute_paymaster_raw(), execute_paymaster_raw_exports));
+      const shhhSignerKind = (wallet.signerKind ?? "STARK") || "STARK";
+      return await executeShhhSponsoredRaw2({
+        client,
+        bearerToken,
+        wallet: {
+          publicKey: wallet.publicKey,
+          encryptedPrivateKey: wallet.encryptedPrivateKey,
+          walletType: wallet.walletType
+        },
+        encryptKey,
+        calls,
+        signerKind: shhhSignerKind
+      });
+    }
     const isKnownType = Object.prototype.hasOwnProperty.call(shared.WALLET_RPC_ENDPOINTS, walletType) && Object.prototype.hasOwnProperty.call(shared.WALLET_CLASS_HASHES, walletType);
     const rpcUrl = isKnownType ? shared.WALLET_RPC_ENDPOINTS[walletType] : shared.WALLET_RPC_ENDPOINTS["CHIPI"];
     const accountClassHash = isKnownType ? shared.WALLET_CLASS_HASHES[walletType] : shared.WALLET_CLASS_HASHES["CHIPI"];
     let privateKeyDecrypted;
     try {
-      privateKeyDecrypted = decryptPrivateKey(wallet.encryptedPrivateKey, encryptKey);
+      privateKeyDecrypted = exports.decryptPrivateKey(wallet.encryptedPrivateKey, encryptKey);
     } catch {
       throw new Error("Failed to decrypt private key. Verify the encryptKey is correct.");
     }
@@ -628,16 +1053,15 @@ var executePaymasterTransactionWithSession = async ({
   client
 }) => {
   const { encryptKey, wallet, session, calls, saveToDatabase } = params;
-  if (wallet.walletType !== "CHIPI") {
+  if (wallet.walletType !== "CHIPI" && wallet.walletType !== "SHHH") {
     console.error("[ChipiSDK:Session:Execute] Invalid wallet type for session execution", {
       provided: wallet.walletType,
-      required: "CHIPI",
-      expectedClassHash: shared.WALLET_CLASS_HASHES.CHIPI,
+      required: "CHIPI or SHHH",
       walletAddress: wallet.publicKey?.slice(0, 15) + "...",
-      hint: "Session keys only work with CHIPI wallets (SNIP-9 compatible)"
+      hint: "Session keys require a SNIP-163 sessions component (CHIPI v29 or SHHH V8.4)."
     });
     throw new shared.ChipiSessionError(
-      `Session execution requires CHIPI wallet type. Got: "${wallet.walletType || "undefined"}"`,
+      `Session execution requires CHIPI or SHHH wallet type. Got: "${wallet.walletType || "undefined"}"`,
       shared.SESSION_ERRORS.INVALID_WALLET_TYPE_FOR_SESSION
     );
   }
@@ -656,7 +1080,7 @@ var executePaymasterTransactionWithSession = async ({
   try {
     let sessionPrivateKey;
     try {
-      sessionPrivateKey = decryptPrivateKey(session.encryptedPrivateKey, encryptKey);
+      sessionPrivateKey = exports.decryptPrivateKey(session.encryptedPrivateKey, encryptKey);
     } catch {
       console.error("[ChipiSDK:Session:Execute] Failed to decrypt session private key", {
         sessionPubKey: session.publicKey?.slice(0, 15) + "...",
@@ -679,6 +1103,52 @@ var executePaymasterTransactionWithSession = async ({
         shared.SESSION_ERRORS.SESSION_DECRYPTION_FAILED
       );
     }
+    if (wallet.walletType === "SHHH") {
+      const { buildOutsideExecution: buildOutsideExecution2, computeOeHash: computeOeHash2, ANY_CALLER_FELT: ANY_CALLER_FELT2 } = await Promise.resolve().then(() => (init_oe(), oe_exports));
+      const { resolveShhhChainId: resolveShhhChainId2, serializeExecuteFromOutsideV2Calldata: serializeExecuteFromOutsideV2Calldata2 } = await Promise.resolve().then(() => (init_execute_paymaster_raw(), execute_paymaster_raw_exports));
+      const oe = buildOutsideExecution2({
+        nonce: BigInt(Date.now()) << 24n | BigInt(Math.floor(Math.random() * 16777215)),
+        calls,
+        caller: ANY_CALLER_FELT2
+      });
+      const chainId = resolveShhhChainId2({ baseUrl: client.baseUrl });
+      const messageHash = computeOeHash2(oe, wallet.publicKey, chainId);
+      const messageHashHex = "0x" + messageHash.toString(16);
+      const { r: r2, s: s2 } = starknet.ec.starkCurve.sign(messageHashHex, sessionPrivateKey);
+      const sessionSignature2 = [
+        BigInt(session.publicKey),
+        BigInt(r2),
+        BigInt(s2),
+        BigInt(session.validUntil)
+      ];
+      const calldata = serializeExecuteFromOutsideV2Calldata2({
+        outsideExecution: oe,
+        signature: sessionSignature2
+      });
+      const response = await client.post({
+        endpoint: "/transactions/execute-sponsored-raw",
+        bearerToken,
+        body: {
+          accountAddress: wallet.publicKey,
+          calldata,
+          // Gas budget for the session-sig path is the same as STARK
+          // primary (~2M l2_gas). The paymaster's kind-detection
+          // branch reads signature[0] == 'V2_SNIP12' to look up the
+          // per-kind gas overhead; signature[0] here is the
+          // session_pubkey (not the V2_SNIP12 prefix), so the
+          // detection falls through to the STARK default — which is
+          // correct, since the session verifier is STARK ECDSA.
+          signerKind: "STARK"
+        }
+      });
+      if (!response?.transactionHash) {
+        throw new shared.ChipiSessionError(
+          "execute-sponsored-raw response missing transactionHash. Check chipi-back logs for upstream paymaster errors.",
+          shared.SESSION_ERRORS.SESSION_INVALID_RESPONSE
+        );
+      }
+      return response.transactionHash;
+    }
     const accountClassHash = shared.WALLET_CLASS_HASHES.CHIPI;
     const prepareResponse = await client.post({
       endpoint: "/transactions/prepare-typed-data",
@@ -763,11 +1233,572 @@ var executePaymasterTransactionWithSession = async ({
       walletAddress: wallet.publicKey?.slice(0, 15) + "...",
       sessionPubKey: session.publicKey?.slice(0, 15) + "..."
     });
-    throw error;
+    throw error;
+  }
+};
+var BOOTSTRAP_DOMAIN_SEPARATOR = BigInt(
+  starknet.shortString.encodeShortString("SHHH_BOOTSTRAP_V8_4")
+);
+var UPGRADE_ENTRYPOINT = "upgrade";
+var BOOTSTRAP_ENTRYPOINT = "bootstrap_from_sessions";
+var BOOTSTRAP_SIGNED_ENTRYPOINT = "bootstrap_from_sessions_signed";
+function _asHex(x) {
+  return typeof x === "bigint" ? "0x" + x.toString(16) : x;
+}
+function _felt(x) {
+  if (typeof x === "bigint") return x;
+  return BigInt(x);
+}
+function labelToFelt(label) {
+  if (label.length === 0) return 0n;
+  for (let i = 0; i < label.length; i++) {
+    if (label.charCodeAt(i) > 127) {
+      throw new RangeError(
+        `migrate label must be ASCII-only (starknet.js short-string encoder rejects non-ASCII)`
+      );
+    }
+  }
+  if (label.length > 31) {
+    throw new RangeError(
+      `migrate label must fit in felt252 short-string (\u226431 ASCII characters); got ${label.length}`
+    );
+  }
+  return BigInt(starknet.shortString.encodeShortString(label));
+}
+function buildMigrationCalls(params) {
+  const upgradeCall = {
+    contractAddress: _asHex(params.legacyAccountAddress),
+    entrypoint: UPGRADE_ENTRYPOINT,
+    calldata: [_asHex(params.shhhAccountClassHash)]
+  };
+  const labelFelt = labelToFelt(params.label ?? "migrated");
+  const bootstrapCall = {
+    contractAddress: _asHex(params.legacyAccountAddress),
+    entrypoint: BOOTSTRAP_ENTRYPOINT,
+    calldata: [
+      _asHex(params.legacyPublicKey),
+      _asHex(params.starkVerifierClassHash),
+      "0x" + labelFelt.toString(16)
+    ]
+  };
+  return [upgradeCall, bootstrapCall];
+}
+function computeBootstrapMessage(params) {
+  const accountFelt = _felt(params.accountAddress);
+  const pubkeyFelt = _felt(params.publicKey);
+  const verifierFelt = _felt(params.starkVerifierClassHash);
+  const labelFelt = labelToFelt(params.label ?? "migrated");
+  return BigInt(
+    starknet.hash.computePoseidonHashOnElements([
+      "0x" + BOOTSTRAP_DOMAIN_SEPARATOR.toString(16),
+      "0x" + accountFelt.toString(16),
+      "0x" + pubkeyFelt.toString(16),
+      "0x" + verifierFelt.toString(16),
+      "0x" + labelFelt.toString(16)
+    ])
+  );
+}
+function signBootstrapMessage(params) {
+  const messageHash = computeBootstrapMessage(params.message);
+  const pkHex = _asHex(_felt(params.privateKey));
+  const sig = starknet.ec.starkCurve.sign("0x" + messageHash.toString(16), pkHex);
+  return {
+    r: BigInt("0x" + sig.r.toString(16)),
+    s: BigInt("0x" + sig.s.toString(16))
+  };
+}
+function buildBootstrapSignedCall(params) {
+  const labelFelt = labelToFelt(params.label ?? "migrated");
+  return {
+    contractAddress: _asHex(params.accountAddress),
+    entrypoint: BOOTSTRAP_SIGNED_ENTRYPOINT,
+    calldata: [
+      _asHex(params.publicKey),
+      _asHex(params.starkVerifierClassHash),
+      "0x" + labelFelt.toString(16),
+      _asHex(params.signatureR),
+      _asHex(params.signatureS)
+    ]
+  };
+}
+
+// src/migrate-to-shhh.ts
+async function migrateChipiWalletToShhh(params) {
+  const prepare = await params.client.post({
+    endpoint: "/chipi-wallets/prepare-migrate-to-shhh",
+    bearerToken: params.bearerToken,
+    body: {
+      walletId: params.walletId,
+      externalUserId: params.externalUserId
+    }
+  });
+  if (prepare.migrationPath === "ALREADY_MIGRATED") {
+    return {
+      kind: "ALREADY_MIGRATED",
+      walletAddress: prepare.walletAddress,
+      onChainClassHash: prepare.onChainClassHash,
+      primaryKind: prepare.primaryKind
+    };
+  }
+  if (prepare.migrationPath === "STRANDED") {
+    throw new Error(
+      "SHHH stranded-state recovery is not yet shipped in the SDK client. The wallet is at V8.4 class hash but primary_kind == 0, which means a prior migration completed `upgrade(SHHH)` but the `bootstrap_from_sessions` call silently reverted. Recovery requires `bootstrap_from_sessions_signed`; see `buildBootstrapSignedCall` in @chipi-stack/backend/src/shhh/migrate.ts."
+    );
+  }
+  if (prepare.migrationPath !== "HAPPY") {
+    throw new Error(
+      "SHHH migration: unexpected migrationPath " + JSON.stringify(prepare.migrationPath) + " returned by chipi-back. This SDK build only handles HAPPY / STRANDED / ALREADY_MIGRATED; upgrade @chipi-stack/backend to a version that knows this path."
+    );
+  }
+  const privateKeyHex = exports.decryptPrivateKey(params.wallet.encryptedPrivateKey, params.encryptKey);
+  if (!privateKeyHex) {
+    throw new Error(
+      "Failed to decrypt STARK private key for migration. Verify the encryptKey matches the one used at wallet creation."
+    );
+  }
+  const starkKeyPub = BigInt(starknet.ec.starkCurve.getStarkKey(privateKeyHex));
+  const calls = buildMigrationCalls({
+    legacyAccountAddress: params.wallet.publicKey,
+    legacyPublicKey: starkKeyPub,
+    shhhAccountClassHash: BigInt(prepare.shhhClassHash),
+    starkVerifierClassHash: BigInt(prepare.shhhVerifierClassHash),
+    label: prepare.label
+  });
+  const transactionHash = await executePaymasterTransaction({
+    params: {
+      encryptKey: params.encryptKey,
+      wallet: {
+        publicKey: params.wallet.publicKey,
+        encryptedPrivateKey: params.wallet.encryptedPrivateKey,
+        // Explicit walletType: the wallet IS still CHIPI v29 at sign
+        // time. The upgrade(SHHH) inside the multicall changes the
+        // class hash mid-tx; that's after signature verification.
+        walletType: "CHIPI"
+      },
+      calls,
+      // Persist the migration tx so it shows up in the user's tx
+      // history. The on-chain receipt is the load-bearing artifact;
+      // the DB row is convenience surfacing.
+      saveToDatabase: true
+    },
+    bearerToken: params.bearerToken,
+    client: params.client
+  });
+  const execute = await params.client.post({
+    endpoint: "/chipi-wallets/execute-migrate-to-shhh",
+    bearerToken: params.bearerToken,
+    body: {
+      walletId: params.walletId,
+      externalUserId: params.externalUserId,
+      transactionHash
+    }
+  });
+  return { kind: "MIGRATED", ...execute };
+}
+
+// src/wallets.ts
+var ChipiWallets = class {
+  constructor(client) {
+    this.client = client;
+    this.getPrivateKeyAX = () => {
+      const privateKeyBytes = CryptoES__default.default.lib.WordArray.random(32);
+      const privateKey = privateKeyBytes.toString(CryptoES__default.default.enc.Hex);
+      const fullPrivateKey = `0x${privateKey}`;
+      const maxStarknetValue = BigInt(
+        "0x800000000000000000000000000000000000000000000000000000000000000"
+      );
+      const privateKeyBigInt = BigInt(fullPrivateKey) % maxStarknetValue;
+      return `0x${privateKeyBigInt.toString(16)}`;
+    };
+  }
+  /**
+   * Create a new wallet on Starknet (gasless, paymaster-sponsored).
+   *
+   * **PIN is weak — not recommended for production.** `encryptKey` here
+   * doubles as the only thing decrypting the wallet's private key. A
+   * user-typed PIN is short, low-entropy, and trivially compromised
+   * by shoulder-surfing or phishing. Production embedded-wallet apps
+   * should derive `encryptKey` from a platform passkey
+   * (`@chipi-stack/chipi-passkey` `getWalletEncryptKey` for the legacy
+   * PRF flow, or — preferred — `createShhhPasskey` for new SHHH
+   * V8.4 wallets where the P-256 key never leaves the platform
+   * authenticator at all). PIN remains only as a last-resort
+   * recovery surface for users without WebAuthn / biometrics.
+   */
+  async createWallet(params) {
+    try {
+      const {
+        encryptKey,
+        externalUserId,
+        bearerToken,
+        userId,
+        // P2.2 default flip (re-applied 2026-05-29 after #270 revert and
+        // the post-revert SHHH bug-fix run #271–#296). New wallets
+        // default to SHHH V8.4 instead of legacy CHIPI v29 — pluggable-
+        // signer Starknet account, guardian recovery, threshold support
+        // out of the box. Existing wallets unaffected; this only
+        // changes the default for callers that omit `walletType`.
+        // Callers who explicitly pass `walletType: "CHIPI"` or
+        // `"READY"` continue producing those.
+        //
+        // Server-side override: chipi-back's CHIPI_SHHH_DEFAULT env
+        // var (chipi-back#267) lets ops force the legacy default back
+        // for callers that bypass the SDK and POST to /chipi-wallets
+        // directly without walletType.
+        //
+        // signerKind under the SHHH branch defaults to "STARK" further
+        // down — same kind the original #267 P2.2 used and the same
+        // kind every mainnet smoke since 2026-05-26 has been signing
+        // under.
+        walletType = "SHHH",
+        classHash: customClassHash,
+        usePasskey,
+        chain
+      } = params;
+      if (!encryptKey) {
+        if (usePasskey) {
+          throw new Error(
+            "encryptKey is required when using passkey. The passkey authentication should have provided the encryptKey."
+          );
+        }
+        throw new Error("encryptKey is required for wallet creation");
+      }
+      const isShhh = walletType === "SHHH";
+      const effectiveSignerKind = isShhh ? params.signerKind ?? "STARK" : void 0;
+      const SDK_SHIPPED_SHHH_KINDS = [
+        "STARK",
+        "ED25519",
+        "WEBAUTHN_P256",
+        "EIP191_SECP256K1"
+      ];
+      if (isShhh && !SDK_SHIPPED_SHHH_KINDS.includes(
+        effectiveSignerKind
+      )) {
+        throw new Error(
+          `SHHH signerKind=${effectiveSignerKind} is not yet shipped from the SDK (supports STARK, ED25519, WEBAUTHN_P256, EIP191_SECP256K1). JWT_ES256_APPLE_SUB and others remain deferred to their follow-up PRs (OAuth / Apple-Developer context).`
+        );
+      }
+      const rpcUrl = walletType === "READY" ? shared.WALLET_RPC_ENDPOINTS.READY : shared.WALLET_RPC_ENDPOINTS.CHIPI;
+      const provider = new starknet.RpcProvider({ nodeUrl: rpcUrl });
+      const privateKeyAX = this.getPrivateKeyAX();
+      const starkKeyPubAX = starknet.ec.starkCurve.getStarkKey(privateKeyAX);
+      let constructorCallData;
+      let accountClassHash;
+      let publicKey;
+      let deploymentSalt;
+      let shhhOwnerPubkeyFelts;
+      let shhhKeyForEncryption = privateKeyAX;
+      if (isShhh) {
+        let pubkeyFelts;
+        let shhhPrivateKeyHex;
+        if (effectiveSignerKind === "STARK") {
+          pubkeyFelts = [BigInt(starkKeyPubAX)];
+          shhhPrivateKeyHex = privateKeyAX;
+        } else if (effectiveSignerKind === "ED25519") {
+          if (params.ownerPubkeyFelts && params.ownerPubkeyFelts.length > 0) {
+            if (params.ownerPubkeyFelts.length !== 2) {
+              throw new Error(
+                `SHHH ED25519 ownerPubkeyFelts must be [low_u128, high_u128] (2 felts); got ${params.ownerPubkeyFelts.length}.`
+              );
+            }
+            pubkeyFelts = params.ownerPubkeyFelts.map((s) => BigInt(s));
+            shhhPrivateKeyHex = "";
+          } else {
+            const edPrivKey = crypto.randomBytes(32);
+            const ed = await import('@noble/ed25519');
+            const edPubKey = await ed.getPublicKeyAsync(edPrivKey);
+            pubkeyFelts = ed25519PubkeyFelts(edPubKey);
+            shhhPrivateKeyHex = Buffer.from(edPrivKey).toString("hex");
+          }
+        } else if (effectiveSignerKind === "WEBAUTHN_P256" || effectiveSignerKind === "EIP191_SECP256K1") {
+          if (!params.ownerPubkeyFelts || params.ownerPubkeyFelts.length !== 4) {
+            throw new Error(
+              `SHHH ${effectiveSignerKind} ownerPubkeyFelts must be [x_low, x_high, y_low, y_high] (4 felts); got ${params.ownerPubkeyFelts?.length ?? 0}.`
+            );
+          }
+          pubkeyFelts = params.ownerPubkeyFelts.map((s) => BigInt(s));
+          shhhPrivateKeyHex = "";
+        } else {
+          throw new Error(
+            `SHHH signerKind=${effectiveSignerKind} reached the address-derivation block without an implementation.`
+          );
+        }
+        shhhOwnerPubkeyFelts = pubkeyFelts.map((f) => "0x" + f.toString(16));
+        shhhKeyForEncryption = shhhPrivateKeyHex;
+        const verifierClassHash = BigInt(
+          shared.SHHH_VERIFIER_CLASS_HASHES[effectiveSignerKind]
+        );
+        const shhhClassHash = customClassHash ?? shared.WALLET_CLASS_HASHES.SHHH;
+        const computedAddress = computeShhhAddress({
+          classHash: BigInt(shhhClassHash),
+          primaryKind: effectiveSignerKind,
+          pubkey: pubkeyFelts,
+          verifierClassHash
+        });
+        publicKey = "0x" + computedAddress.toString(16);
+        accountClassHash = shhhClassHash;
+        const labelFelt = BigInt(starknet.shortString.encodeShortString("primary"));
+        const kindTagFelt = BigInt(starknet.shortString.encodeShortString(effectiveSignerKind));
+        constructorCallData = [
+          kindTagFelt.toString(),
+          verifierClassHash.toString(),
+          pubkeyFelts.length.toString(),
+          ...pubkeyFelts.map((f) => f.toString()),
+          labelFelt.toString()
+        ];
+        const salt = (() => {
+          const ownerCommit = BigInt(
+            starknet.hash.computePoseidonHashOnElements([
+              "0x" + kindTagFelt.toString(16),
+              ...pubkeyFelts.map((f) => "0x" + f.toString(16))
+            ])
+          );
+          return BigInt(
+            starknet.hash.computePoseidonHashOnElements([
+              "0x" + kindTagFelt.toString(16),
+              "0x" + ownerCommit.toString(16)
+            ])
+          );
+        })();
+        deploymentSalt = "0x" + salt.toString(16);
+      } else {
+        constructorCallData = this.buildConstructorCallData(walletType, starkKeyPubAX);
+        accountClassHash = customClassHash ?? (walletType === "READY" ? shared.WALLET_CLASS_HASHES.READY : shared.WALLET_CLASS_HASHES.CHIPI);
+        publicKey = starknet.hash.calculateContractAddressFromHash(
+          starkKeyPubAX,
+          accountClassHash,
+          constructorCallData,
+          0
+        );
+        deploymentSalt = starkKeyPubAX;
+      }
+      const account = new starknet.Account({ provider, address: publicKey, signer: privateKeyAX });
+      const typedDataResponse = await this.client.post({
+        endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/prepare-creation`,
+        bearerToken,
+        body: {
+          chain,
+          publicKey,
+          walletType,
+          starkKeyPubAX,
+          ...customClassHash && { classHash: customClassHash },
+          // SHHH: tell chipi-back which signer kind + pubkey felts
+          // produced this deployment so it can validate against the
+          // expected SHHH constructor shape and populate the new
+          // wallet row columns.
+          ...isShhh && {
+            signerKind: effectiveSignerKind,
+            ownerPubkeyFelts: shhhOwnerPubkeyFelts
+          }
+        }
+      });
+      const { typedData: typedData2, accountClassHash: accountClassHashResponse } = typedDataResponse;
+      let userSignaturePayload;
+      if (isShhh) {
+        userSignaturePayload = {
+          r: "0x0",
+          s: "0x0",
+          recovery: 0
+        };
+      } else {
+        const userSignature = await account.signMessage(typedData2);
+        userSignaturePayload = {
+          r: userSignature.r.toString(),
+          s: userSignature.s.toString(),
+          recovery: userSignature.recovery
+        };
+      }
+      const deploymentData = {
+        class_hash: accountClassHashResponse,
+        salt: deploymentSalt,
+        unique: `${starknet.num.toHex(0)}`,
+        calldata: constructorCallData.map((value) => starknet.num.toHex(value))
+      };
+      const encryptedPrivateKey = shhhKeyForEncryption === "" ? void 0 : exports.encryptPrivateKey(shhhKeyForEncryption, encryptKey);
+      const encryptedPrivateKeyBackup = params.encryptKeyBackup && shhhKeyForEncryption !== "" ? exports.encryptPrivateKey(shhhKeyForEncryption, params.encryptKeyBackup) : void 0;
+      const executeTransactionResponse = await this.client.post({
+        endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}`,
+        bearerToken,
+        body: {
+          externalUserId,
+          userId,
+          publicKey,
+          walletType,
+          chain,
+          userSignature: userSignaturePayload,
+          typedData: typedData2,
+          ...encryptedPrivateKey !== void 0 && { encryptedPrivateKey },
+          // SHHH: write the signer kind to the new wallet row.
+          ...isShhh && { signerKind: effectiveSignerKind },
+          // External-rooted SHHH (passkey / MetaMask / Phantom): no
+          // Chipi-held key, so chipi-back needs the pubkey felts (address
+          // derivation) + `ownerPublicKey` as the credential source it
+          // stores (encryptedPrivateKey stays null). Canonical
+          // ownerPublicKey = comma-joined felts. STARK / Chipi-held kinds
+          // are untouched — encryptedPrivateKey is their credential source.
+          ...isShhh && encryptedPrivateKey === void 0 && shhhOwnerPubkeyFelts && {
+            ownerPubkeyFelts: shhhOwnerPubkeyFelts,
+            ownerPublicKey: shhhOwnerPubkeyFelts.join(",")
+          },
+          ...encryptedPrivateKeyBackup && { encryptedPrivateKeyBackup },
+          ...params.authMethod && { authMethod: params.authMethod },
+          ...params.credentialId && { credentialId: params.credentialId },
+          ...params.prfSupported != null && { prfSupported: params.prfSupported },
+          ...params.deviceType && { deviceType: params.deviceType },
+          deploymentData: {
+            ...deploymentData,
+            salt: `${deploymentData.salt}`,
+            calldata: deploymentData.calldata.map((data) => `${data}`)
+          }
+        }
+      });
+      return executeTransactionResponse;
+    } catch (error) {
+      console.error("Detailed error:", error);
+      if (error instanceof Error && error.message.includes("SSL")) {
+        throw new Error(
+          "SSL connection error. Try using NODE_TLS_REJECT_UNAUTHORIZED=0 or verify the RPC URL"
+        );
+      }
+      throw new shared.ChipiTransactionError(
+        `Failed to create wallet: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "WALLET_CREATION_FAILED"
+      );
+    }
+  }
+  /**
+   * Build constructor calldata based on wallet type
+   * - CHIPI: Simple OpenZeppelin account with just public_key
+   * - ARGENT: Argent X Account with owner/guardian structure
+   */
+  buildConstructorCallData(walletType, starkKeyPubAX) {
+    if (walletType === "READY") {
+      const axSigner = new starknet.CairoCustomEnum({
+        Starknet: { pubkey: starkKeyPubAX }
+      });
+      const axGuardian = new starknet.CairoOption(starknet.CairoOptionVariant.None);
+      return starknet.CallData.compile({
+        owner: axSigner,
+        guardian: axGuardian
+      });
+    }
+    return starknet.CallData.compile({
+      public_key: starkKeyPubAX
+    });
+  }
+  /**
+   * Create a custodial merchant wallet
+   */
+  async createCustodialWallet({
+    params,
+    bearerToken
+  }) {
+    const response = await this.client.post({
+      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/custodial`,
+      bearerToken,
+      body: params
+    });
+    return response;
+  }
+  async getWallet(params, bearerToken) {
+    try {
+      const { externalUserId } = params;
+      const getWalletResponse = await this.client.get({
+        endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/by-user`,
+        params: { externalUserId },
+        bearerToken
+      });
+      return getWalletResponse;
+    } catch (err) {
+      if (err instanceof shared.ChipiApiError && err.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Recover passkey credential metadata for a wallet.
+   * Used when localStorage is cleared — SDK recovers credentialId from backend.
+   */
+  async getCredentialRecovery(params, bearerToken) {
+    return this.client.get({
+      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/credential-recovery`,
+      params: { externalUserId: params.externalUserId },
+      bearerToken
+    });
+  }
+  async updateWalletEncryption(params, bearerToken) {
+    const body = {
+      externalUserId: params.externalUserId,
+      newEncryptedPrivateKey: params.newEncryptedPrivateKey
+    };
+    if (params.publicKey != null) {
+      body.publicKey = params.publicKey;
+    }
+    return this.client.patch({
+      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/update-encryption-details`,
+      bearerToken,
+      body
+    });
+  }
+  async getTokenBalance({
+    params,
+    bearerToken
+  }) {
+    const getBalanceResponse = await this.client.get({
+      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/token-balance`,
+      params,
+      bearerToken
+    });
+    return getBalanceResponse;
+  }
+  /**
+   * Prepare a wallet upgrade (e.g., READY → CHIPI or CHIPI v29 → v33).
+   * Returns typed data that must be signed by the wallet owner.
+   */
+  async prepareWalletUpgrade(params, bearerToken) {
+    return this.client.post({
+      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/prepare-upgrade`,
+      bearerToken,
+      body: params
+    });
+  }
+  /**
+   * Execute a wallet upgrade after the owner has signed the typed data.
+   */
+  async executeWalletUpgrade(params, bearerToken) {
+    return this.client.post({
+      endpoint: `${shared.API_ENDPOINTS.CHIPI_WALLETS}/upgrade`,
+      bearerToken,
+      body: params
+    });
+  }
+  /**
+   * Migrate a CHIPI v29 wallet to SHHH V8.4 in-place at the same
+   * on-chain address. Composes the two-phase chipi-back endpoint:
+   * prepare returns the path decision + parameters, then this method
+   * builds the [upgrade, bootstrap_from_sessions] multicall locally,
+   * signs the V8.4 OE with the wallet's STARK key (decrypted via
+   * the user's encryptKey), and sends the signed calldata to the
+   * execute endpoint. Server forwards verbatim to the paymaster.
+   *
+   * Returns `{kind: "ALREADY_MIGRATED"}` if the wallet is already
+   * SHHH on chain (DB row gets patched server-side; no on-chain tx
+   * fires); otherwise `{kind: "MIGRATED", transactionHash, ...}`.
+   *
+   * Throws on STRANDED-state recovery, UNDEPLOYED wallets, and
+   * other deferred-feature paths with actionable error messages.
+   *
+   * Endpoints contract shipped in chipi-back task #28 (PR #272).
+   */
+  async migrateToShhh(params, bearerToken) {
+    return migrateChipiWalletToShhh({
+      client: this.client,
+      bearerToken,
+      ...params
+    });
   }
 };
-
-// src/transactions.ts
 var ChipiTransactions = class {
   constructor(client) {
     this.client = client;
@@ -900,9 +1931,9 @@ var ChipiTransactions = class {
   /**
    * Get on-chain transaction status
    */
-  async getTransactionStatus(hash3, bearerToken) {
+  async getTransactionStatus(hash9, bearerToken) {
     return this.client.get({
-      endpoint: `${shared.API_ENDPOINTS.TRANSACTIONS}/${hash3}/status`,
+      endpoint: `${shared.API_ENDPOINTS.TRANSACTIONS}/${hash9}/status`,
       bearerToken
     });
   }
@@ -1069,25 +2100,39 @@ var ChipiSkus = class {
     });
   }
 };
+
+// src/sessions.ts
+init_encryption2();
 var ChipiSessions = class {
   constructor(client) {
     this.client = client;
   }
   /**
-   * Validate that the wallet is a CHIPI wallet (required for session operations).
-   * Throws ChipiSessionError if wallet type is not CHIPI.
+   * Validate that the wallet supports SNIP-163 session keys.
+   *
+   * Both CHIPI v29 (sessions-smart-contract) and SHHH V8.4
+   * (ShhhAccount) embed the same SNIP-163 SessionKeyComponent, so
+   * `add_or_update_session_key` / `revoke_session_key` /
+   * `get_session_data` selectors exist on both. The 4-felt session
+   * signature shape (`[session_pubkey, r, s, valid_until]`) is the
+   * same on both — V8.4's `execute_from_outside_v2` checks
+   * `signature.len() == 4` at account.cairo:389 BEFORE the
+   * V2_SNIP12 envelope dispatch, so sessions land through the
+   * legacy fast path on V8.4 wallets too.
+   *
+   * READY (Argent X v0.4.0) does NOT implement SNIP-163; reject with
+   * a clear error.
    */
-  validateChipiWallet(walletType, operation, walletPublicKey) {
-    if (walletType !== "CHIPI") {
+  validateWalletSupportsSessions(walletType, operation, walletPublicKey) {
+    if (walletType !== "CHIPI" && walletType !== "SHHH") {
       console.error(`[ChipiSDK:Session:${operation}] Invalid wallet type`, {
         provided: walletType,
-        required: "CHIPI",
-        expectedClassHash: shared.WALLET_CLASS_HASHES["CHIPI"],
+        required: "CHIPI or SHHH",
         walletAddress: walletPublicKey ? walletPublicKey.slice(0, 15) + "..." : "(not provided)",
-        hint: "Session keys only work with CHIPI wallets (SNIP-9 compatible)"
+        hint: "Session keys require a SNIP-163 sessions component. CHIPI v29 + SHHH V8.4 both embed it; READY (Argent X) does not."
       });
       throw new shared.ChipiSessionError(
-        `Session keys require CHIPI wallet type. Got: "${walletType || "undefined"}". Session keys are only supported for CHIPI wallets with class hash ${shared.WALLET_CLASS_HASHES["CHIPI"]}`,
+        `Session keys require CHIPI or SHHH wallet type. Got: "${walletType || "undefined"}".`,
         shared.SESSION_ERRORS.INVALID_WALLET_TYPE_FOR_SESSION
       );
     }
@@ -1107,6 +2152,15 @@ var ChipiSessions = class {
    *
    * After generating, call `addSessionKeyToContract()` to register the session on-chain.
    *
+   * **PIN is weak — not recommended for production.** `encryptKey` here
+   * is the symmetric key the SDK uses to encrypt the session's private
+   * key at rest. If you're passing a user-typed PIN, anyone who
+   * observes that PIN can decrypt the session. Derive `encryptKey`
+   * from a platform passkey (`@chipi-stack/chipi-passkey`) — for SHHH
+   * V8.4 wallets prefer `createShhhPasskey` + `signShhhMessage`, where
+   * the wallet's primary key never needs to be decrypted client-side
+   * at all.
+   *
    * @param params - Session creation parameters
    * @returns SessionKeyData for external storage
    *
@@ -1133,7 +2187,7 @@ var ChipiSessions = class {
       const privateKeyHex = this.toHex(rawPrivateKey);
       const publicKey = starknet.ec.starkCurve.getStarkKey(privateKeyHex);
       const validUntil = Math.floor(Date.now() / 1e3) + durationSeconds;
-      const encryptedPrivateKey = encryptPrivateKey(privateKeyHex, encryptKey);
+      const encryptedPrivateKey = exports.encryptPrivateKey(privateKeyHex, encryptKey);
       return {
         publicKey,
         encryptedPrivateKey,
@@ -1179,7 +2233,7 @@ var ChipiSessions = class {
    */
   async addSessionKeyToContract(params, bearerToken) {
     const { encryptKey, wallet, sessionConfig } = params;
-    this.validateChipiWallet(wallet.walletType, "AddToContract", wallet.publicKey);
+    this.validateWalletSupportsSessions(wallet.walletType, "AddToContract", wallet.publicKey);
     try {
       console.log("[ChipiSDK:Session:AddToContract] Registering session on-chain", {
         walletAddress: wallet.publicKey.slice(0, 15) + "...",
@@ -1199,7 +2253,7 @@ var ChipiSessions = class {
       const txHash = await executePaymasterTransaction({
         params: {
           encryptKey,
-          wallet: { ...wallet, walletType: "CHIPI" },
+          wallet,
           calls: [
             {
               contractAddress: wallet.publicKey,
@@ -1253,7 +2307,7 @@ var ChipiSessions = class {
    */
   async revokeSessionKey(params, bearerToken) {
     const { encryptKey, wallet, sessionPublicKey } = params;
-    this.validateChipiWallet(wallet.walletType, "Revoke", wallet.publicKey);
+    this.validateWalletSupportsSessions(wallet.walletType, "Revoke", wallet.publicKey);
     try {
       console.log("[ChipiSDK:Session:Revoke] Revoking session from contract", {
         walletAddress: wallet.publicKey.slice(0, 15) + "...",
@@ -1262,7 +2316,7 @@ var ChipiSessions = class {
       const txHash = await executePaymasterTransaction({
         params: {
           encryptKey,
-          wallet: { ...wallet, walletType: "CHIPI" },
+          wallet,
           calls: [
             {
               contractAddress: wallet.publicKey,
@@ -1435,16 +2489,16 @@ var ChipiSessions = class {
    */
   async executeTransactionWithSession(params, bearerToken) {
     const { encryptKey, wallet, session, calls } = params;
-    if (wallet.walletType && wallet.walletType !== "CHIPI") {
+    if (wallet.walletType && wallet.walletType !== "CHIPI" && wallet.walletType !== "SHHH") {
       throw new shared.ChipiSessionError(
-        `Session execution only supports CHIPI wallets. Got: ${wallet.walletType}`,
+        `Session execution requires CHIPI or SHHH wallet type. Got: ${wallet.walletType}`,
         shared.SESSION_ERRORS.INVALID_WALLET_TYPE_FOR_SESSION
       );
     }
     return executePaymasterTransactionWithSession({
       params: {
         encryptKey,
-        wallet: { ...wallet, walletType: "CHIPI" },
+        wallet: { ...wallet, walletType: wallet.walletType ?? "CHIPI" },
         session,
         calls,
         saveToDatabase: true
@@ -1869,6 +2923,13 @@ var X402Facilitator = class _X402Facilitator {
    * Otherwise falls back to a presence-only check (backwards compatible).
    */
   async verifySignature(payment) {
+    if (payment.payload?.shhh) {
+      const oeCalldata = payment.payload.shhh.oeCalldata;
+      if (!Array.isArray(oeCalldata) || oeCalldata.length === 0) {
+        return { valid: false, reason: "Missing SHHH oeCalldata" };
+      }
+      return { valid: true };
+    }
     if (!this.provider) {
       if (!payment.payload?.signature?.r || !payment.payload?.signature?.s) {
         return { valid: false, reason: "Missing signature" };
@@ -1922,6 +2983,28 @@ var X402Facilitator = class _X402Facilitator {
       return { success: false, errorReason: "Nonce already consumed (concurrent replay)" };
     }
     try {
+      if (payload.shhh) {
+        const shhhResult = await this.client.post({
+          endpoint: "/transactions/execute-sponsored-raw",
+          bearerToken: this.bearerToken,
+          body: {
+            accountAddress: payload.fromAddress,
+            calldata: payload.shhh.oeCalldata,
+            signerKind: payload.shhh.signerKind
+          }
+        });
+        if (typeof shhhResult?.transactionHash !== "string" || !shhhResult.transactionHash.trim()) {
+          return {
+            success: false,
+            errorReason: shhhResult?.message ?? "execute-sponsored-raw returned no transactionHash"
+          };
+        }
+        return {
+          success: true,
+          transactionHash: shhhResult.transactionHash,
+          networkId: "starknet-mainnet"
+        };
+      }
       const amountU256 = starknet.uint256.bnToUint256(BigInt(payload.amount));
       const transferCall = {
         contractAddress: payload.asset,
@@ -1967,6 +3050,9 @@ var X402Facilitator = class _X402Facilitator {
     }
   }
 };
+
+// src/sign-typed-data.ts
+init_encryption2();
 var signTypedData = async ({
   params
 }) => {
@@ -1988,7 +3074,7 @@ var signTypedData = async ({
     const rpcUrl = shared.WALLET_RPC_ENDPOINTS[walletType];
     let privateKeyDecrypted;
     try {
-      privateKeyDecrypted = decryptPrivateKey(wallet.encryptedPrivateKey, encryptKey);
+      privateKeyDecrypted = exports.decryptPrivateKey(wallet.encryptedPrivateKey, encryptKey);
     } catch {
       throw new Error("Failed to decrypt private key. Verify the encryptKey is correct.");
     }
@@ -2154,9 +3240,7 @@ var ChipiSDK = class {
    * });
    * ```
    */
-  async signTypedData({
-    params
-  }) {
+  async signTypedData({ params }) {
     return signTypedData({ params });
   }
   /**
@@ -2275,8 +3359,8 @@ var ChipiSDK = class {
   /**
    * Get on-chain transaction status (supports polling for confirmation)
    */
-  async getTransactionStatus(hash3, bearerToken) {
-    return this.transactions.getTransactionStatus(hash3, this.resolveBearerToken(bearerToken));
+  async getTransactionStatus(hash9, bearerToken) {
+    return this.transactions.getTransactionStatus(hash9, this.resolveBearerToken(bearerToken));
   }
   /**
    * Prepare a wallet upgrade (e.g., READY → CHIPI or CHIPI v29 → v33).
@@ -2324,6 +3408,207 @@ var ChipiBrowserSDK = class extends ChipiSDK {
   // All methods are inherited from ChipiSDK
   // bearerToken parameter is required for each authenticated request
 };
+
+// src/index.ts
+init_encryption2();
+
+// src/x402/shhh-client.ts
+init_encryption2();
+init_oe();
+init_stark();
+init_execute_paymaster_raw();
+var PAYMENT_REQUIRED_HEADER = "payment-required";
+var DEFAULT_PAYMENT_HEADER = "X-PAYMENT";
+var X402ShhhClient = class {
+  constructor(opts) {
+    this.wallet = opts.wallet;
+    this.encryptKey = opts.encryptKey;
+    this.chipiClient = opts.chipiClient;
+    this.bearerToken = opts.bearerToken;
+    this.config = {
+      headerName: DEFAULT_PAYMENT_HEADER,
+      ...opts.config
+    };
+    this.fetchFn = globalThis.fetch;
+  }
+  /**
+   * Drop-in `fetch` replacement. If the seller returns 402, signs a
+   * payment + retries with the X-PAYMENT header. Same surface as
+   * `X402Client.fetch`.
+   */
+  async fetch(url, init) {
+    const response = await this.fetchFn(url, init);
+    if (response.status !== 402) {
+      return response;
+    }
+    const requirement = this.parsePaymentRequired(response);
+    this.validateRequirement(requirement);
+    const payment = await this.signPayment(requirement);
+    return this.retryWithPayment(url, init, payment);
+  }
+  parsePaymentRequired(response) {
+    const headerValue = response.headers.get(PAYMENT_REQUIRED_HEADER);
+    if (!headerValue) {
+      throw new Error(
+        "Server returned 402 but no PAYMENT-REQUIRED header. The server may not support x402 or is misconfigured."
+      );
+    }
+    let requirement;
+    try {
+      requirement = JSON.parse(headerValue);
+    } catch {
+      throw new Error(
+        `Malformed PAYMENT-REQUIRED header: invalid JSON. Got: "${headerValue.slice(0, 100)}"`
+      );
+    }
+    if (!requirement.scheme || !requirement.network || !requirement.maxAmountRequired) {
+      throw new Error(
+        "Invalid payment requirement: missing required fields (scheme, network, maxAmountRequired)"
+      );
+    }
+    if (requirement.scheme !== "exact") {
+      throw new Error(
+        `Unsupported payment scheme: "${requirement.scheme}". This client only supports "exact".`
+      );
+    }
+    if (requirement.network !== "starknet-mainnet") {
+      throw new Error(
+        `Unsupported payment network: "${requirement.network}". This client only supports "starknet-mainnet" per CLAUDE.md.`
+      );
+    }
+    return requirement;
+  }
+  validateRequirement(req) {
+    if (this.config.allowedRecipients && this.config.allowedRecipients.length > 0 && !this.config.allowedRecipients.includes(req.payTo)) {
+      throw new Error(
+        `Payment recipient ${req.payTo} not in allowed list. Update X402ShhhClientConfig.allowedRecipients to permit this seller.`
+      );
+    }
+    if (this.config.maxPaymentAmount) {
+      const maxBaseUnits = humanUsdcToBaseUnits(this.config.maxPaymentAmount, 6);
+      if (BigInt(req.maxAmountRequired) > maxBaseUnits) {
+        throw new Error(
+          `Payment amount ${req.maxAmountRequired} exceeds client max ${this.config.maxPaymentAmount} USDC.`
+        );
+      }
+    }
+  }
+  /**
+   * Sign an x402 payment as a SHHH V8.4 buyer. Builds the V8.4 OE
+   * containing the single USDC.transfer call, computes the SNIP-12
+   * hash against the wallet address + chain id, signs locally with
+   * the decrypted STARK private key, wraps the result in a V2_SNIP12
+   * envelope, and serializes the full execute_from_outside_v2
+   * calldata. Returns a PaymentPayload with the `shhh` extension
+   * populated; the facilitator's settle branch forwards
+   * `payload.shhh.oeCalldata` verbatim to
+   * `/transactions/execute-sponsored-raw`.
+   *
+   * The `signature: {r, s}` field is also populated with the inner
+   * `(r, s)` pair so the wire format stays valid for receivers that
+   * only inspect the legacy field. The facilitator uses the SHHH
+   * branch when `payload.shhh` is present, so the redundant `{r, s}`
+   * is informational, not load-bearing.
+   */
+  async signPayment(requirement) {
+    const signerKind = this.wallet.signerKind ?? "STARK";
+    if (signerKind !== "STARK") {
+      throw new Error(
+        `X402ShhhClient currently supports signerKind="STARK" only; got "${signerKind}". ED25519 + external-rooted (MetaMask, Phantom, passkey, Apple) x402 buyers ship in a follow-on PR.`
+      );
+    }
+    const nonce = generateNonce();
+    const validUntil = Math.floor(Date.now() / 1e3) + requirement.maxTimeoutSeconds;
+    const amountU256 = starknet.uint256.bnToUint256(BigInt(requirement.maxAmountRequired));
+    const transferCall = {
+      contractAddress: requirement.asset,
+      entrypoint: "transfer",
+      calldata: [requirement.payTo, amountU256.low.toString(), amountU256.high.toString()]
+    };
+    const oe = buildOutsideExecution({
+      nonce: BigInt("0x" + nonceToHexFelt(nonce)),
+      calls: [transferCall],
+      caller: exports.ANY_CALLER_FELT
+    });
+    const chainId = resolveShhhChainId({
+      override: this.config.chainId,
+      baseUrl: this.chipiClient.baseUrl
+    });
+    const messageHash = computeOeHash(oe, this.wallet.publicKey, chainId);
+    const privateKeyHex = exports.decryptPrivateKey(this.wallet.encryptedPrivateKey, this.encryptKey);
+    if (!privateKeyHex) {
+      throw new Error(
+        "Failed to decrypt SHHH STARK private key for x402 payment. Verify the encryptKey matches the wallet creation key."
+      );
+    }
+    const envelope = buildStarkEnvelope({
+      privateKey: privateKeyHex,
+      messageHash
+    });
+    const oeCalldata = serializeExecuteFromOutsideV2Calldata({
+      outsideExecution: oe,
+      signature: envelope
+    });
+    const r = envelope[envelope.length - 2] ?? 0n;
+    const s = envelope[envelope.length - 1] ?? 0n;
+    return {
+      x402Version: 1,
+      scheme: "exact",
+      network: "starknet-mainnet",
+      payload: {
+        signature: {
+          r: "0x" + r.toString(16),
+          s: "0x" + s.toString(16)
+        },
+        fromAddress: this.wallet.publicKey,
+        toAddress: requirement.payTo,
+        amount: requirement.maxAmountRequired,
+        asset: requirement.asset,
+        validUntil,
+        nonce,
+        shhh: {
+          walletType: "SHHH",
+          signerKind,
+          oeCalldata
+        }
+      }
+    };
+  }
+  async retryWithPayment(url, init, payment) {
+    const HeadersCtor = globalThis.Headers;
+    const headerName = this.config.headerName;
+    const paymentJson = JSON.stringify(payment);
+    let headers;
+    if (typeof HeadersCtor === "function") {
+      const merged = new HeadersCtor(init?.headers);
+      merged.set(headerName, paymentJson);
+      headers = merged;
+    } else {
+      const existing = init?.headers ?? {};
+      headers = { ...existing, [headerName]: paymentJson };
+    }
+    return this.fetchFn(url, { ...init, headers });
+  }
+};
+function humanUsdcToBaseUnits(amount, decimals) {
+  const [whole, frac = ""] = amount.trim().split(".");
+  const fracPadded = (frac + "0".repeat(decimals)).slice(0, decimals);
+  return BigInt((whole || "0") + fracPadded);
+}
+function generateNonce() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function nonceToHexFelt(nonce) {
+  const bytes = new TextEncoder().encode(nonce);
+  let hex = "";
+  for (const b of bytes) {
+    hex += b.toString(16).padStart(2, "0");
+  }
+  return hex.slice(0, 60).padStart(60, "0");
+}
 function amountToBaseUnits(amount, decimals) {
   const [whole, frac = ""] = amount.split(".");
   const fracPadded = (frac + "0".repeat(decimals)).slice(0, decimals);
@@ -2448,6 +3733,815 @@ function x402Middleware(config) {
   };
 }
 
+// src/shhh/index.ts
+init_snip12_hash();
+init_compute_wallet_address();
+init_oe();
+init_stark();
+init_ed25519();
+
+// src/shhh/signers/eip191.ts
+init_compute_wallet_address();
+init_oe();
+var EIP191_KIND_TAG = "EIP191_SECP256K1";
+var EIP191_KIND_TAG_FELT = BigInt(starknet.shortString.encodeShortString(EIP191_KIND_TAG));
+var SECP256K1_ORDER = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
+function assertBytes(name, b, len) {
+  if (b.length !== len) {
+    throw new Error(`${name} must be exactly ${len} bytes; got ${b.length}.`);
+  }
+}
+function bytesBeToU256(b) {
+  assertBytes("secp256k1 32B value", b, 32);
+  let x = 0n;
+  for (let i = 0; i < b.length; i++) x = x << 8n | BigInt(b[i]);
+  return { low: x & (1n << 128n) - 1n, high: x >> 128n };
+}
+function eip191PubkeyFelts(pubkey) {
+  const x = bytesBeToU256(pubkey.x);
+  const y = bytesBeToU256(pubkey.y);
+  return [x.low, x.high, y.low, y.high];
+}
+function eip191OwnerId(pubkey) {
+  return ownerCommitment(EIP191_KIND_TAG_FELT, eip191PubkeyFelts(pubkey));
+}
+function parseEip191Signature(signatureHex) {
+  const hex = signatureHex.startsWith("0x") ? signatureHex.slice(2) : signatureHex;
+  if (hex.length !== 130) {
+    throw new Error(`EIP-191 signature must be 65 bytes (130 hex chars); got ${hex.length}.`);
+  }
+  if (!/^[0-9a-fA-F]+$/.test(hex)) {
+    throw new Error("EIP-191 signature contains non-hex characters.");
+  }
+  const bytes = new Uint8Array(65);
+  for (let i = 0; i < 65; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  const r = bytesBeToU256(bytes.slice(0, 32));
+  const s = bytesBeToU256(bytes.slice(32, 64));
+  const v = bytes[64];
+  let yParity;
+  if (v === 27) yParity = 0n;
+  else if (v === 28) yParity = 1n;
+  else if (v === 0) yParity = 0n;
+  else if (v === 1) yParity = 1n;
+  else throw new Error(`Unexpected v byte ${v} in EIP-191 signature; expected 27, 28, 0, or 1.`);
+  if (s.low === 0n && s.high === 0n) {
+    throw new Error("EIP-191 signature s component is zero");
+  }
+  return [r.low, r.high, s.low, s.high, yParity];
+}
+function buildEip191EnvelopeFromSignature(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildEip191EnvelopeFromSignature: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32).`
+    );
+  }
+  const payload = parseEip191Signature(params.signatureHex);
+  return wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: EIP191_KIND_TAG,
+    payload
+  });
+}
+async function buildEip191EnvelopeFromPrivateKey(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildEip191EnvelopeFromPrivateKey: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32).`
+    );
+  }
+  const privBytes = normalizePrivateKey(params.privateKey);
+  const [secp, keccak] = await Promise.all([
+    import('@noble/secp256k1'),
+    // @noble/hashes@2.x ESM exports use the .js suffix per their package.json
+    // exports map.
+    import('@noble/hashes/sha3.js')
+  ]);
+  const msgBe32 = bigintToBe32(params.messageHash);
+  const prefix = new TextEncoder().encode("Ethereum Signed Message:\n32");
+  const prefixedMsg = new Uint8Array(prefix.length + 32);
+  prefixedMsg.set(prefix, 0);
+  prefixedMsg.set(msgBe32, prefix.length);
+  const ethSignedHash = keccak.keccak_256(prefixedMsg);
+  const sig = await secp.signAsync(ethSignedHash, privBytes, {
+    lowS: true
+  });
+  let r = typeof sig.r === "bigint" ? sig.r : BigInt(sig.r);
+  let s = typeof sig.s === "bigint" ? sig.s : BigInt(sig.s);
+  let recovery = typeof sig.recovery === "number" ? sig.recovery : Number(sig.recovery ?? 0);
+  const halfOrder = SECP256K1_ORDER >> 1n;
+  if (s > halfOrder) {
+    s = SECP256K1_ORDER - s;
+    recovery ^= 1;
+  }
+  const rBytes = bigintToBe32(r);
+  const sBytes = bigintToBe32(s);
+  const rU256 = bytesBeToU256(rBytes);
+  const sU256 = bytesBeToU256(sBytes);
+  return wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: EIP191_KIND_TAG,
+    payload: [rU256.low, rU256.high, sU256.low, sU256.high, BigInt(recovery)]
+  });
+}
+function normalizePrivateKey(input) {
+  if (input instanceof Uint8Array) {
+    assertBytes("EIP-191 private key", input, 32);
+    return input;
+  }
+  const hex = input.startsWith("0x") ? input.slice(2) : input;
+  if (hex.length !== 64) {
+    throw new Error(`EIP-191 private key hex must be 64 chars (32 bytes); got ${hex.length}.`);
+  }
+  if (!/^[0-9a-fA-F]+$/.test(hex)) {
+    throw new Error("EIP-191 private key contains non-hex characters.");
+  }
+  const out = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bigintToBe32(x) {
+  if (x < 0n) throw new Error("bigintToBe32: negative input");
+  const out = new Uint8Array(32);
+  for (let i = 31; i >= 0; i--) {
+    out[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  if (x !== 0n) throw new Error("bigintToBe32: input exceeds 256 bits");
+  return out;
+}
+
+// src/shhh/signers/webauthn.ts
+init_compute_wallet_address();
+init_oe();
+var WEBAUTHN_KIND_TAG = "WEBAUTHN_P256";
+var WEBAUTHN_KIND_TAG_FELT = BigInt(starknet.shortString.encodeShortString(WEBAUTHN_KIND_TAG));
+var P256_ORDER = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n;
+function assertBytes2(name, b, len) {
+  if (b.length !== len) {
+    throw new Error(`${name} must be exactly ${len} bytes; got ${b.length}.`);
+  }
+}
+function bytesBeToU2562(b) {
+  assertBytes2("32B value", b, 32);
+  let x = 0n;
+  for (let i = 0; i < b.length; i++) x = x << 8n | BigInt(b[i]);
+  return { low: x & (1n << 128n) - 1n, high: x >> 128n };
+}
+function bigintToBe322(x) {
+  if (x < 0n) throw new Error("bigintToBe32: negative input");
+  const out = new Uint8Array(32);
+  for (let i = 31; i >= 0; i--) {
+    out[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  if (x !== 0n) throw new Error("bigintToBe32: input exceeds 256 bits");
+  return out;
+}
+function base64UrlEncode(bytes) {
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+  const b64 = typeof Buffer !== "undefined" ? Buffer.from(bytes).toString("base64") : btoa(bin);
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function byteArrayToFelts(bytes) {
+  const totalFull = Math.floor(bytes.length / 31);
+  const out = [BigInt(totalFull)];
+  for (let i = 0; i < totalFull; i++) {
+    let v = 0n;
+    for (let j = 0; j < 31; j++) v = v << 8n | BigInt(bytes[i * 31 + j]);
+    out.push(v);
+  }
+  const remStart = totalFull * 31;
+  const remLen = bytes.length - remStart;
+  let pending = 0n;
+  for (let j = 0; j < remLen; j++) {
+    pending = pending << 8n | BigInt(bytes[remStart + j]);
+  }
+  out.push(pending);
+  out.push(BigInt(remLen));
+  return out;
+}
+function parseDerEcdsaSignature(der) {
+  if (der.length < 8) {
+    throw new Error(`DER: input too short (${der.length} bytes)`);
+  }
+  if (der[0] !== 48) throw new Error("DER: expected SEQUENCE (0x30)");
+  const seqLen = der[1];
+  if (seqLen & 128) {
+    throw new Error("DER: long-form sequence length not supported");
+  }
+  if (2 + seqLen !== der.length) {
+    throw new Error(
+      `DER: declared sequence length ${seqLen} does not match buffer (${der.length - 2})`
+    );
+  }
+  let off = 2;
+  if (der[off] !== 2) throw new Error("DER: expected INTEGER (0x02) for r");
+  const rLen = der[off + 1];
+  if (rLen === 0) throw new Error("DER: r component has zero length");
+  if (off + 2 + rLen > der.length) {
+    throw new Error(`DER: r length ${rLen} overruns buffer at offset ${off + 2}`);
+  }
+  off += 2;
+  let rBytes = new Uint8Array(rLen);
+  rBytes.set(der.subarray(off, off + rLen));
+  off += rLen;
+  if (off + 2 > der.length) {
+    throw new Error("DER: no room for s INTEGER header");
+  }
+  if (der[off] !== 2) throw new Error("DER: expected INTEGER (0x02) for s");
+  const sLen = der[off + 1];
+  if (sLen === 0) throw new Error("DER: s component has zero length");
+  if (off + 2 + sLen > der.length) {
+    throw new Error(`DER: s length ${sLen} overruns buffer at offset ${off + 2}`);
+  }
+  off += 2;
+  let sBytes = new Uint8Array(sLen);
+  sBytes.set(der.subarray(off, off + sLen));
+  rBytes = leftPadTo32(stripLeadingZero(rBytes));
+  sBytes = leftPadTo32(stripLeadingZero(sBytes));
+  return { r: rBytes, s: sBytes };
+}
+function stripLeadingZero(b) {
+  const start = b.length > 0 && b[0] === 0 ? 1 : 0;
+  const out = new Uint8Array(b.length - start);
+  out.set(b.subarray(start));
+  return out;
+}
+function leftPadTo32(b) {
+  if (b.length > 32) throw new Error(`P-256 component longer than 32 bytes: ${b.length}`);
+  const out = new Uint8Array(32);
+  out.set(b, 32 - b.length);
+  return out;
+}
+function webauthnPubkeyFelts(pub) {
+  const x = bytesBeToU2562(pub.x);
+  const y = bytesBeToU2562(pub.y);
+  return [x.low, x.high, y.low, y.high];
+}
+function webauthnOwnerId(pub) {
+  return ownerCommitment(WEBAUTHN_KIND_TAG_FELT, webauthnPubkeyFelts(pub));
+}
+function buildWebAuthnEnvelopeFromAssertion(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildWebAuthnEnvelopeFromAssertion: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32).`
+    );
+  }
+  const { r, s } = parseDerEcdsaSignature(params.signatureDer);
+  const expectedChallenge = base64UrlEncode(bigintToBe322(params.messageHash));
+  const needle = `"challenge":"${expectedChallenge}"`;
+  const clientDataStr = new TextDecoder().decode(params.clientDataJSON);
+  const needleStart = clientDataStr.indexOf(needle);
+  if (needleStart < 0) {
+    throw new Error(
+      'WebAuthn clientDataJSON does not contain a `"challenge":"<expected>"` substring for the given messageHash.'
+    );
+  }
+  const challengeOffset = needleStart + '"challenge":"'.length;
+  const rU = bytesBeToU2562(r);
+  const sU = bytesBeToU2562(s);
+  const payload = [
+    ...byteArrayToFelts(params.authenticatorData),
+    ...byteArrayToFelts(params.clientDataJSON),
+    BigInt(challengeOffset),
+    rU.low,
+    rU.high,
+    sU.low,
+    sU.high,
+    params.yParity ?? 0n
+  ];
+  return wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: WEBAUTHN_KIND_TAG,
+    payload
+  });
+}
+async function buildWebAuthnEnvelopeFromPrivateKey(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildWebAuthnEnvelopeFromPrivateKey: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32).`
+    );
+  }
+  const privBytes = normalizePrivateKey2(params.privateKey);
+  const rpId = params.rpId ?? "cifra.mx";
+  const origin = params.origin ?? "https://cifra.mx";
+  const flags = params.flags ?? 5;
+  const signCount = params.signCount ?? 42;
+  if (!Number.isInteger(flags) || flags < 0 || flags > 255) {
+    throw new Error(`WebAuthn flags must be an integer in [0, 255]; got ${flags}.`);
+  }
+  if (!Number.isInteger(signCount) || signCount < 0 || signCount > 4294967295) {
+    throw new Error(`WebAuthn signCount must be an integer in [0, 0xFFFFFFFF]; got ${signCount}.`);
+  }
+  const [{ p256 }, sha2] = await Promise.all([
+    import('@noble/curves/nist.js'),
+    import('@noble/hashes/sha2.js')
+  ]);
+  const hashBytes = bigintToBe322(params.messageHash);
+  const challengeStr = base64UrlEncode(hashBytes);
+  const clientDataStr = `{"type":"webauthn.get","challenge":"${challengeStr}","origin":"${origin}","crossOrigin":false}`;
+  const clientData = new TextEncoder().encode(clientDataStr);
+  const challengeOffset = clientDataStr.indexOf(`"challenge":"${challengeStr}"`) + '"challenge":"'.length;
+  const rpIdHash = sha2.sha256(new TextEncoder().encode(rpId));
+  const authData = new Uint8Array(32 + 1 + 4);
+  authData.set(rpIdHash, 0);
+  authData[32] = flags;
+  authData[33] = signCount >>> 24 & 255;
+  authData[34] = signCount >>> 16 & 255;
+  authData[35] = signCount >>> 8 & 255;
+  authData[36] = signCount & 255;
+  const hClient = sha2.sha256(clientData);
+  const signingBase = new Uint8Array(authData.length + hClient.length);
+  signingBase.set(authData, 0);
+  signingBase.set(hClient, authData.length);
+  const outerHash = sha2.sha256(signingBase);
+  const sigBytes = p256.sign(outerHash, privBytes, {
+    prehash: false
+  });
+  if (sigBytes.length !== 64) {
+    throw new Error(`p256.sign returned ${sigBytes.length} bytes; expected 64`);
+  }
+  let r = bytesBeToBigint(sigBytes.slice(0, 32));
+  let s = bytesBeToBigint(sigBytes.slice(32, 64));
+  const halfOrder = P256_ORDER >> 1n;
+  if (s > halfOrder) s = P256_ORDER - s;
+  const rBytes = bigintToBe322(r);
+  const sBytes = bigintToBe322(s);
+  const rU = bytesBeToU2562(rBytes);
+  const sU = bytesBeToU2562(sBytes);
+  const payload = [
+    ...byteArrayToFelts(authData),
+    ...byteArrayToFelts(clientData),
+    BigInt(challengeOffset),
+    rU.low,
+    rU.high,
+    sU.low,
+    sU.high,
+    0n
+    // y_parity — Cairo verifier handles parity recovery internally
+  ];
+  return wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: WEBAUTHN_KIND_TAG,
+    payload
+  });
+}
+function normalizePrivateKey2(input) {
+  if (input instanceof Uint8Array) {
+    assertBytes2("P-256 private key", input, 32);
+    return input;
+  }
+  const hex = input.startsWith("0x") ? input.slice(2) : input;
+  if (hex.length !== 64) {
+    throw new Error(`P-256 private key hex must be 64 chars (32 bytes); got ${hex.length}.`);
+  }
+  if (!/^[0-9a-fA-F]+$/.test(hex)) {
+    throw new Error("P-256 private key contains non-hex characters.");
+  }
+  const out = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bytesBeToBigint(b) {
+  let x = 0n;
+  for (let i = 0; i < b.length; i++) x = x << 8n | BigInt(b[i]);
+  return x;
+}
+
+// src/shhh/signers/jwt_apple_sub.ts
+init_compute_wallet_address();
+init_oe();
+var JWT_APPLE_SUB_KIND_TAG = "JWT_ES256_APPLE_SUB";
+var JWT_APPLE_SUB_KIND_TAG_FELT = BigInt(starknet.shortString.encodeShortString(JWT_APPLE_SUB_KIND_TAG));
+var APPLE_ISSUER = "https://appleid.apple.com";
+var NONCE_B64URL_LEN = 43;
+var U128_MASK = (1n << 128n) - 1n;
+function assertBytes3(name, b, len) {
+  if (b.length !== len) {
+    throw new Error(`${name} must be exactly ${len} bytes; got ${b.length}.`);
+  }
+}
+function bytesBeToU2563(b) {
+  assertBytes3("secp256r1 32B value", b, 32);
+  let x = 0n;
+  for (let i = 0; i < b.length; i++) x = x << 8n | BigInt(b[i]);
+  return { low: x & U128_MASK, high: x >> 128n };
+}
+function jwtAppleSubHash(sub) {
+  const bytes = new TextEncoder().encode(sub);
+  const felts = Array.from(bytes).map((b) => BigInt(b));
+  return BigInt(starknet.hash.computePoseidonHashOnElements(felts.map((f) => "0x" + f.toString(16))));
+}
+function jwtAppleSubPubkeyFelts(pubkey) {
+  const x = bytesBeToU2563(pubkey.x);
+  const y = bytesBeToU2563(pubkey.y);
+  const subHash = jwtAppleSubHash(pubkey.sub);
+  return [x.low, x.high, y.low, y.high, subHash];
+}
+function jwtAppleSubOwnerId(pubkey) {
+  return ownerCommitment(JWT_APPLE_SUB_KIND_TAG_FELT, jwtAppleSubPubkeyFelts(pubkey));
+}
+function base64urlEncode(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  const b64 = btoaPortable(bin);
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function btoaPortable(bin) {
+  if (typeof btoa === "function") return btoa(bin);
+  const buf = globalThis.Buffer;
+  if (buf) return buf.from(bin, "binary").toString("base64");
+  throw new Error("no base64 encoder available (need btoa or Buffer in scope)");
+}
+function base64urlDecode(s) {
+  const pad = s.length % 4 === 0 ? 0 : 4 - s.length % 4;
+  const std = s.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat(pad);
+  const bin = atobPortable(std);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function atobPortable(s) {
+  if (typeof atob === "function") return atob(s);
+  const buf = globalThis.Buffer;
+  if (buf) return buf.from(s, "base64").toString("binary");
+  throw new Error("no base64 decoder available (need atob or Buffer in scope)");
+}
+function messageHashToNonceB64url(messageHash) {
+  const beBytes = new Uint8Array(32);
+  let x = messageHash;
+  for (let i = 31; i >= 0; i--) {
+    beBytes[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  if (x !== 0n) {
+    throw new RangeError("messageHash exceeds 256 bits");
+  }
+  const out = base64urlEncode(beBytes);
+  if (out.length !== NONCE_B64URL_LEN) {
+    throw new Error(`expected ${NONCE_B64URL_LEN}-char nonce b64url, got ${out.length}`);
+  }
+  return out;
+}
+function findByteOffset(haystack, needle, label) {
+  outer: for (let i = 0; i + needle.length <= haystack.length; i++) {
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) continue outer;
+    }
+    return i;
+  }
+  throw new Error(`JWT_APPLE_SUB: ${label} not found in payload (verifier would reject)`);
+}
+function locateExactClaimValueOffset(payload, claim, expectedValue) {
+  const literal = `"${claim}":"${expectedValue}"`;
+  const literalBytes = new TextEncoder().encode(literal);
+  const idx = findByteOffsetOrMinusOne(payload, literalBytes);
+  if (idx < 0) {
+    throw new Error(
+      `JWT_APPLE_SUB: ${claim} claim with expected value not found in payload (verifier would reject)`
+    );
+  }
+  const prefix = `"${claim}":"`;
+  return idx + new TextEncoder().encode(prefix).length;
+}
+function findByteOffsetOrMinusOne(haystack, needle) {
+  outer: for (let i = 0; i + needle.length <= haystack.length; i++) {
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function parseAppleIdToken(idToken) {
+  const parts = idToken.split(".");
+  if (parts.length !== 3) {
+    throw new Error(
+      `JWT_APPLE_SUB: id_token must have 3 parts separated by '.'; got ${parts.length}`
+    );
+  }
+  const [headerB64, payloadB64, sigB64] = parts;
+  const payloadDecoded = base64urlDecode(payloadB64);
+  const rawSignature = base64urlDecode(sigB64);
+  if (rawSignature.length !== 64) {
+    throw new Error(
+      `JWT_APPLE_SUB: ECDSA signature must be 64 bytes (raw r||s); got ${rawSignature.length}. Apple returns raw 64-byte signatures; if you have a DER-encoded one, decode it first.`
+    );
+  }
+  return { headerB64, payloadDecoded, rawSignature };
+}
+function locateSubClaim(payload) {
+  const SUB_KEY = new TextEncoder().encode('"sub":"');
+  const start = findByteOffset(payload, SUB_KEY, '"sub":"');
+  const valueStart = start + SUB_KEY.length;
+  let end = valueStart;
+  while (end < payload.length && payload[end] !== 34) {
+    if (payload[end] === 92) {
+      throw new Error("JWT_APPLE_SUB: sub claim contains escape sequence; not supported");
+    }
+    end += 1;
+  }
+  if (end >= payload.length) {
+    throw new Error("JWT_APPLE_SUB: sub claim is unterminated");
+  }
+  return { offset: valueStart, length: end - valueStart };
+}
+function serdeByteArray(bytes) {
+  return byteArrayToFelts(bytes);
+}
+function buildEnvelopePayload(fields) {
+  const headerBytes = new TextEncoder().encode(fields.headerB64);
+  const headerSerde = serdeByteArray(headerBytes);
+  const payloadSerde = serdeByteArray(fields.payloadDecoded);
+  return [
+    ...headerSerde,
+    ...payloadSerde,
+    BigInt(fields.nonceOffset),
+    BigInt(fields.issOffset),
+    BigInt(fields.subOffset),
+    BigInt(fields.subLen),
+    fields.r & U128_MASK,
+    fields.r >> 128n,
+    fields.s & U128_MASK,
+    fields.s >> 128n,
+    BigInt(fields.yParity)
+  ];
+}
+function buildJwtAppleSubEnvelopeFromTokenResponse(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildJwtAppleSubEnvelopeFromTokenResponse: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32).`
+    );
+  }
+  const { headerB64, payloadDecoded, rawSignature } = parseAppleIdToken(params.idToken);
+  const expectedNonce = messageHashToNonceB64url(params.messageHash);
+  const nonceOffset = locateExactClaimValueOffset(payloadDecoded, "nonce", expectedNonce);
+  const issOffset = locateExactClaimValueOffset(payloadDecoded, "iss", APPLE_ISSUER);
+  const { offset: subOffset, length: subLen } = locateSubClaim(payloadDecoded);
+  const actualSub = new TextDecoder().decode(
+    payloadDecoded.subarray(subOffset, subOffset + subLen)
+  );
+  if (actualSub !== params.pubkey.sub) {
+    throw new Error(
+      `JWT_APPLE_SUB: id_token sub "${actualSub}" doesn't match pubkey.sub "${params.pubkey.sub}" \u2014 wrong user signed in`
+    );
+  }
+  const { r, s } = parseRawEcdsaSignature(rawSignature);
+  const yParity = 0;
+  return wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: JWT_APPLE_SUB_KIND_TAG,
+    payload: buildEnvelopePayload({
+      headerB64,
+      payloadDecoded,
+      nonceOffset,
+      issOffset,
+      subOffset,
+      subLen,
+      r,
+      s,
+      yParity
+    })
+  });
+}
+function parseRawEcdsaSignature(raw) {
+  if (raw.length !== 64) {
+    throw new Error(`JWT_APPLE_SUB: ECDSA signature must be 64 bytes; got ${raw.length}`);
+  }
+  let r = 0n;
+  for (let i = 0; i < 32; i++) r = r << 8n | BigInt(raw[i]);
+  let s = 0n;
+  for (let i = 32; i < 64; i++) s = s << 8n | BigInt(raw[i]);
+  return { r, s };
+}
+async function buildJwtAppleSubEnvelopeFromTestKey(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildJwtAppleSubEnvelopeFromTestKey: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32).`
+    );
+  }
+  const { p256 } = await import('@noble/curves/nist.js');
+  const { sha256 } = await import('@noble/hashes/sha2.js');
+  if (params.privateKey.length !== 32) {
+    throw new Error(
+      `JWT_APPLE_SUB: P-256 private key must be 32 bytes; got ${params.privateKey.length}`
+    );
+  }
+  const pubUncompressed = p256.getPublicKey(params.privateKey, false);
+  if (pubUncompressed.length !== 65 || pubUncompressed[0] !== 4) {
+    throw new Error("expected 65-byte uncompressed P-256 pubkey");
+  }
+  const pubkey = {
+    x: pubUncompressed.slice(1, 33),
+    y: pubUncompressed.slice(33, 65),
+    sub: params.sub
+  };
+  const headerJson = JSON.stringify({ alg: "ES256", kid: "synthesized" });
+  const headerB64 = base64urlEncode(new TextEncoder().encode(headerJson));
+  const now = Math.floor(Date.now() / 1e3);
+  const nonce = messageHashToNonceB64url(params.messageHash);
+  const payloadObject = {
+    iss: APPLE_ISSUER,
+    aud: params.aud,
+    sub: params.sub,
+    iat: now,
+    exp: now + 600,
+    nonce
+  };
+  const payloadJson = JSON.stringify(payloadObject);
+  const payloadDecoded = new TextEncoder().encode(payloadJson);
+  const payloadB64 = base64urlEncode(payloadDecoded);
+  const signingInput = new TextEncoder().encode(`${headerB64}.${payloadB64}`);
+  const digest = sha256(signingInput);
+  const rawSig = p256.sign(digest, params.privateKey, {
+    lowS: true
+  });
+  if (rawSig.length !== 64) {
+    throw new Error(`expected 64-byte raw ECDSA signature from p256.sign; got ${rawSig.length}`);
+  }
+  const { r, s } = parseRawEcdsaSignature(rawSig);
+  const idToken = `${headerB64}.${payloadB64}.${base64urlEncode(rawSig)}`;
+  const nonceOffset = locateExactClaimValueOffset(payloadDecoded, "nonce", nonce);
+  const issOffset = locateExactClaimValueOffset(payloadDecoded, "iss", APPLE_ISSUER);
+  const { offset: subOffset, length: subLen } = locateSubClaim(payloadDecoded);
+  const envelope = wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: JWT_APPLE_SUB_KIND_TAG,
+    payload: buildEnvelopePayload({
+      headerB64,
+      payloadDecoded,
+      nonceOffset,
+      issOffset,
+      subOffset,
+      subLen,
+      r,
+      s,
+      yParity: 0
+    })
+  });
+  return { envelope, pubkey, idToken };
+}
+var ROLE_OWNER = BigInt(starknet.shortString.encodeShortString("OWNER"));
+var ROLE_GUARDIAN = BigInt(starknet.shortString.encodeShortString("GUARDIAN"));
+var OP_ADD_OWNER = BigInt(starknet.shortString.encodeShortString("ADD_OWNER"));
+var OP_REMOVE_OWNER = BigInt(starknet.shortString.encodeShortString("REMOVE_OWNER"));
+var OP_ROTATE_OWNER = BigInt(starknet.shortString.encodeShortString("ROTATE_OWNER"));
+var OP_SET_THRESHOLD = BigInt(starknet.shortString.encodeShortString("SET_THRESHOLD"));
+var TIMELOCK_SECONDS = {
+  ADD_OWNER: 172800,
+  // 48h
+  REMOVE_OWNER: 86400,
+  // 24h
+  ROTATE_OWNER: 86400,
+  // 24h
+  SET_THRESHOLD: 172800,
+  // 48h
+  ADD_VERIFIER: 172800,
+  // 48h
+  REMOVE_VERIFIER: 86400,
+  // 24h
+  ADD_GUARDIAN: 86400,
+  // 24h
+  REMOVE_GUARDIAN: 86400,
+  // 24h
+  RECOVERY: 604800
+  // 7d — `TIMELOCK_RECOVERY`, the headline UX gate
+};
+var DEFAULT_OP_EXPIRY_SECONDS = 1209600;
+function _felt2(x, field = "felt") {
+  const v = typeof x === "bigint" ? x : BigInt(x);
+  if (v < 0n) {
+    throw new RangeError(`${field} must be a non-negative felt; got ${v.toString()}`);
+  }
+  return v;
+}
+function _encodeOwnerInput(input) {
+  if (input.weight < 0) {
+    throw new RangeError(`NewOwnerInput.weight must be non-negative; got ${input.weight}`);
+  }
+  const kindFelt = _felt2(BigInt(starknet.shortString.encodeShortString(input.kind)), "kind");
+  const roleFelt = input.role === "OWNER" ? ROLE_OWNER : ROLE_GUARDIAN;
+  const pubkey = input.pubkeyBytes.map((p, i) => _felt2(p, `pubkeyBytes[${i}]`));
+  return [
+    kindFelt,
+    BigInt(pubkey.length),
+    ...pubkey,
+    roleFelt,
+    BigInt(input.weight),
+    _felt2(BigInt(starknet.shortString.encodeShortString(input.label)), "label")
+  ];
+}
+function _call(walletAddress, entrypoint, calldata) {
+  for (let i = 0; i < calldata.length; i++) {
+    if (calldata[i] < 0n) {
+      throw new RangeError(
+        `calldata[${i}] must be a non-negative felt; got ${calldata[i].toString()}`
+      );
+    }
+  }
+  return {
+    contractAddress: typeof walletAddress === "bigint" ? "0x" + walletAddress.toString(16) : walletAddress,
+    entrypoint,
+    calldata: calldata.map((v) => "0x" + v.toString(16))
+  };
+}
+function buildProposeAddOwnerCall(args) {
+  const calldata = [BigInt(args.proposer), ..._encodeOwnerInput(args.newOwner)];
+  return _call(args.walletAddress, "propose_add_owner", calldata);
+}
+function buildExecuteAddOwnerCall(args) {
+  const calldata = [_felt2(args.opId), ..._encodeOwnerInput(args.newOwner)];
+  return _call(args.walletAddress, "execute_add_owner", calldata);
+}
+function buildProposeRemoveOwnerCall(args) {
+  return _call(args.walletAddress, "propose_remove_owner", [
+    BigInt(args.proposer),
+    BigInt(args.ownerId)
+  ]);
+}
+function buildExecuteRemoveOwnerCall(args) {
+  return _call(args.walletAddress, "execute_remove_owner", [
+    _felt2(args.opId),
+    BigInt(args.ownerId)
+  ]);
+}
+function buildProposeRotateOwnerCall(args) {
+  return _call(args.walletAddress, "propose_rotate_owner", [
+    BigInt(args.proposer),
+    BigInt(args.ownerId),
+    BigInt(args.newPubkeyBytes.length),
+    ...args.newPubkeyBytes
+  ]);
+}
+function buildExecuteRotateOwnerCall(args) {
+  return _call(args.walletAddress, "execute_rotate_owner", [
+    _felt2(args.opId),
+    BigInt(args.ownerId),
+    BigInt(args.newPubkeyBytes.length),
+    ...args.newPubkeyBytes
+  ]);
+}
+function buildProposeSetThresholdCall(args) {
+  return _call(args.walletAddress, "propose_set_threshold", [
+    BigInt(args.proposer),
+    BigInt(args.newThreshold)
+  ]);
+}
+function buildExecuteSetThresholdCall(args) {
+  return _call(args.walletAddress, "execute_set_threshold", [
+    _felt2(args.opId),
+    BigInt(args.newThreshold)
+  ]);
+}
+function buildCancelPendingOpCall(args) {
+  return _call(args.walletAddress, "cancel_pending_op", [_felt2(args.opId)]);
+}
+function buildInitiateRecoveryCall(args) {
+  const calldata = [BigInt(args.proposer), ..._encodeOwnerInput(args.newOwner)];
+  return _call(args.walletAddress, "initiate_recovery", calldata);
+}
+function buildCancelRecoveryCall(args) {
+  return _call(args.walletAddress, "cancel_recovery", [BigInt(args.ownerId)]);
+}
+function buildFinalizeRecoveryCall(args) {
+  return _call(args.walletAddress, "finalize_recovery", _encodeOwnerInput(args.newOwner));
+}
+var VIEW_SELECTORS = {
+  get_pending_op: starknet.hash.getSelectorFromName("get_pending_op"),
+  get_pending_recovery: starknet.hash.getSelectorFromName("get_pending_recovery"),
+  get_owner: starknet.hash.getSelectorFromName("get_owner")
+};
+function _toSecondsBigInt(value, field) {
+  if (typeof value === "bigint") return value;
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${field} must be a finite timestamp; got ${value}`);
+  }
+  return BigInt(Math.floor(value));
+}
+function isReadyToExecute(validAfterSecs, nowSecs) {
+  return _toSecondsBigInt(nowSecs, "nowSecs") >= _toSecondsBigInt(validAfterSecs, "validAfterSecs");
+}
+function secondsUntilExecutable(validAfterSecs, nowSecs) {
+  const remaining = _toSecondsBigInt(validAfterSecs, "validAfterSecs") - _toSecondsBigInt(nowSecs, "nowSecs");
+  return remaining <= 0n ? 0 : Number(remaining);
+}
+
+// src/shhh/index.ts
+init_threshold();
+init_execute_paymaster_raw();
+
 Object.defineProperty(exports, "Chain", {
   enumerable: true,
   get: function () { return types.Chain; }
@@ -2460,6 +4554,8 @@ Object.defineProperty(exports, "Currency", {
   enumerable: true,
   get: function () { return types.Currency; }
 });
+exports.APPLE_ISSUER = APPLE_ISSUER;
+exports.BOOTSTRAP_DOMAIN_SEPARATOR = BOOTSTRAP_DOMAIN_SEPARATOR;
 exports.ChipiBrowserSDK = ChipiBrowserSDK;
 exports.ChipiClient = ChipiClient;
 exports.ChipiPaymasterAdapter = ChipiPaymasterAdapter;
@@ -2470,10 +4566,86 @@ exports.ChipiSkuPurchases = ChipiSkuPurchases;
 exports.ChipiSkus = ChipiSkus;
 exports.ChipiTransactions = ChipiTransactions;
 exports.ChipiWallets = ChipiWallets;
+exports.DEFAULT_OP_EXPIRY_SECONDS = DEFAULT_OP_EXPIRY_SECONDS;
+exports.OP_ADD_OWNER = OP_ADD_OWNER;
+exports.OP_REMOVE_OWNER = OP_REMOVE_OWNER;
+exports.OP_ROTATE_OWNER = OP_ROTATE_OWNER;
+exports.OP_SET_THRESHOLD = OP_SET_THRESHOLD;
+exports.ROLE_GUARDIAN = ROLE_GUARDIAN;
+exports.ROLE_OWNER = ROLE_OWNER;
+exports.TIMELOCK_SECONDS = TIMELOCK_SECONDS;
+exports.VIEW_SELECTORS = VIEW_SELECTORS;
 exports.X402Facilitator = X402Facilitator;
-exports.decryptPrivateKey = decryptPrivateKey;
-exports.encryptPrivateKey = encryptPrivateKey;
+exports.X402ShhhClient = X402ShhhClient;
+exports.assertValidV2Snip12Envelope = assertValidV2Snip12Envelope;
+exports.buildBootstrapSignedCall = buildBootstrapSignedCall;
+exports.buildCancelPendingOpCall = buildCancelPendingOpCall;
+exports.buildCancelRecoveryCall = buildCancelRecoveryCall;
+exports.buildEd25519Envelope = buildEd25519Envelope;
+exports.buildEd25519EnvelopeFromSignature = buildEd25519EnvelopeFromSignature;
+exports.buildEip191EnvelopeFromPrivateKey = buildEip191EnvelopeFromPrivateKey;
+exports.buildEip191EnvelopeFromSignature = buildEip191EnvelopeFromSignature;
+exports.buildExecuteAddOwnerCall = buildExecuteAddOwnerCall;
+exports.buildExecuteRemoveOwnerCall = buildExecuteRemoveOwnerCall;
+exports.buildExecuteRotateOwnerCall = buildExecuteRotateOwnerCall;
+exports.buildExecuteSetThresholdCall = buildExecuteSetThresholdCall;
+exports.buildFinalizeRecoveryCall = buildFinalizeRecoveryCall;
+exports.buildInitiateRecoveryCall = buildInitiateRecoveryCall;
+exports.buildJwtAppleSubEnvelopeFromTestKey = buildJwtAppleSubEnvelopeFromTestKey;
+exports.buildJwtAppleSubEnvelopeFromTokenResponse = buildJwtAppleSubEnvelopeFromTokenResponse;
+exports.buildMigrationCalls = buildMigrationCalls;
+exports.buildOutsideExecution = buildOutsideExecution;
+exports.buildProposeAddOwnerCall = buildProposeAddOwnerCall;
+exports.buildProposeRemoveOwnerCall = buildProposeRemoveOwnerCall;
+exports.buildProposeRotateOwnerCall = buildProposeRotateOwnerCall;
+exports.buildProposeSetThresholdCall = buildProposeSetThresholdCall;
+exports.buildStarkEnvelope = buildStarkEnvelope;
+exports.buildThresholdEnvelope = buildThresholdEnvelope;
+exports.buildWebAuthnEnvelopeFromAssertion = buildWebAuthnEnvelopeFromAssertion;
+exports.buildWebAuthnEnvelopeFromPrivateKey = buildWebAuthnEnvelopeFromPrivateKey;
+exports.byteArrayToFelts = byteArrayToFelts;
+exports.computeAddressSalt = computeAddressSalt;
+exports.computeBootstrapMessage = computeBootstrapMessage;
+exports.computeISignerId = computeISignerId;
+exports.computeOeHash = computeOeHash;
+exports.computeShhhAddress = computeShhhAddress;
+exports.computeSnip12Hash = computeSnip12Hash;
+exports.ed25519OwnerId = ed25519OwnerId;
+exports.ed25519PubkeyFelts = ed25519PubkeyFelts;
+exports.ed25519SignedBytes = ed25519SignedBytes;
+exports.eip191OwnerId = eip191OwnerId;
+exports.eip191PubkeyFelts = eip191PubkeyFelts;
+exports.estimateThresholdGasOverhead = estimateThresholdGasOverhead;
+exports.executeShhhSponsoredRaw = executeShhhSponsoredRaw;
+exports.hashCall = hashCall;
+exports.hashCalls = hashCalls;
+exports.hashOutsideExecutionStruct = hashOutsideExecutionStruct;
+exports.hashStarknetDomain = hashStarknetDomain;
+exports.isReadyToExecute = isReadyToExecute;
+exports.jwtAppleSubHash = jwtAppleSubHash;
+exports.jwtAppleSubOwnerId = jwtAppleSubOwnerId;
+exports.jwtAppleSubPubkeyFelts = jwtAppleSubPubkeyFelts;
+exports.labelToFelt = labelToFelt;
+exports.locateSubClaim = locateSubClaim;
+exports.messageHashToNonceB64url = messageHashToNonceB64url;
+exports.migrateChipiWalletToShhh = migrateChipiWalletToShhh;
+exports.ownerCommitment = ownerCommitment;
+exports.parseAppleIdToken = parseAppleIdToken;
+exports.parseDerEcdsaSignature = parseDerEcdsaSignature;
+exports.parseEip191Signature = parseEip191Signature;
+exports.parseThresholdEnvelope = parseThresholdEnvelope;
+exports.resolveShhhChainId = resolveShhhChainId;
+exports.secondsUntilExecutable = secondsUntilExecutable;
+exports.serializeExecuteFromOutsideV2Calldata = serializeExecuteFromOutsideV2Calldata;
+exports.signBootstrapMessage = signBootstrapMessage;
 exports.signTypedData = signTypedData;
+exports.snip12HashToHexAsciiBytes = snip12HashToHexAsciiBytes;
+exports.starkOwnerId = starkOwnerId;
+exports.starkPubkeyFelts = starkPubkeyFelts;
+exports.webauthnOwnerId = webauthnOwnerId;
+exports.webauthnPubkeyFelts = webauthnPubkeyFelts;
+exports.wrapV2Snip12Envelope = wrapV2Snip12Envelope;
+exports.wrapV2ThresholdEnvelope = wrapV2ThresholdEnvelope;
 exports.x402Middleware = x402Middleware;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map