@medialane/sdk 0.120.0 → 0.121.0

package/dist/wallet/index.js

@@ -1,786 +0,0 @@
-import { validateAndParseAddress, Account, typedData, hash, num, ec } from 'starknet';
-import { keccak_256 } from '@noble/hashes/sha3.js';
-import { base32, base58 } from '@scure/base';
-
-// src/wallet/store.ts
-function createOwnerStore(config) {
-  const { storeKey, changeEvent } = config;
-  const announce = () => {
-    if (typeof window === "undefined") return;
-    window.dispatchEvent(new Event(changeEvent));
-  };
-  return {
-    load() {
-      if (typeof window === "undefined") return null;
-      try {
-        const raw = localStorage.getItem(storeKey);
-        return raw ? JSON.parse(raw) : null;
-      } catch {
-        return null;
-      }
-    },
-    loadAddress() {
-      return this.load()?.address ?? null;
-    },
-    save(sealed) {
-      localStorage.setItem(storeKey, JSON.stringify(sealed));
-      announce();
-    },
-    clear() {
-      localStorage.removeItem(storeKey);
-      announce();
-    },
-    notifyChange: announce,
-    onChange(listener) {
-      window.addEventListener(changeEvent, listener);
-      return () => window.removeEventListener(changeEvent, listener);
-    }
-  };
-}
-
-// src/wallet/pairing.ts
-var SCHEME = "medialane-device";
-var VERSION = 1;
-var LABEL_MAX = 32;
-var STARK_PRIME = (1n << 251n) + 17n * (1n << 192n) + 1n;
-var InvalidPairingPayloadError = class extends Error {
-  constructor(message = "This code is not a Medialane device request.") {
-    super(message);
-    this.name = "InvalidPairingPayloadError";
-  }
-};
-function normalisePublicKey(input) {
-  if (typeof input !== "string" || !/^0x[0-9a-fA-F]+$/.test(input)) {
-    throw new InvalidPairingPayloadError("That device key is not valid.");
-  }
-  const value = BigInt(input);
-  if (value === 0n || value >= STARK_PRIME) {
-    throw new InvalidPairingPayloadError("That device key is not valid.");
-  }
-  return `0x${value.toString(16)}`;
-}
-function sanitiseLabel(input) {
-  const raw = typeof input === "string" ? input : "";
-  return raw.replace(/\s+/g, " ").trim().slice(0, LABEL_MAX);
-}
-function encodePairingPayload(payload) {
-  return JSON.stringify({
-    scheme: SCHEME,
-    version: VERSION,
-    publicKey: normalisePublicKey(payload.publicKey),
-    label: sanitiseLabel(payload.label)
-  });
-}
-function parsePairingPayload(encoded) {
-  let data;
-  try {
-    data = JSON.parse(encoded);
-  } catch {
-    throw new InvalidPairingPayloadError();
-  }
-  if (data === null || typeof data !== "object") throw new InvalidPairingPayloadError();
-  if (data.scheme !== SCHEME || data.version !== VERSION) throw new InvalidPairingPayloadError();
-  return {
-    publicKey: normalisePublicKey(data.publicKey),
-    label: sanitiseLabel(data.label)
-  };
-}
-function parseAccountAddress(input) {
-  const trimmed = typeof input === "string" ? input.trim() : "";
-  if (!/^0x[0-9a-fA-F]{50,64}$/.test(trimmed)) {
-    throw new InvalidPairingPayloadError("That does not look like an account address.");
-  }
-  if (BigInt(trimmed) === 0n) {
-    throw new InvalidPairingPayloadError("That does not look like an account address.");
-  }
-  return trimmed;
-}
-
-// src/chains.ts
-var COORDINATES = {
-  STARKNET: {
-    rpcUrl: "https://rpc.starknet.lava.build",
-    marketplace721: "0x03eda9a2b6ad90845a43591bac8083ebaf677d51fdf20f503b2c01889e3131fc",
-    marketplace721ClassHash: "0x0700d9230d07e5203e27778c0dc70f9134d2b25bf319f7cf8348dc66a6923e90",
-    marketplace721StartBlock: 11198146,
-    marketplace1155: "0x07c4ce1c19ea48cc11135ed22b19ff745f5aec508c3828593002e4f76fdb1b38",
-    marketplace1155ClassHash: "0x0242f5c388da7cee2d99e2a69453c8159bf927fbec4e797a3cfdcbbcb5b68328",
-    marketplace1155StartBlock: 11198267,
-    collection721: "0x0225c3ae09506b8d97adc39649ca740dad5aac195b7f5f0441cc1852947acaea",
-    collection721StartBlock: 11198496,
-    dataTokenization721: "0x07421b4442f7f2052c65408fb3561484154cf8175a0bbb41e3cd38d9087af6d2",
-    dataTokenization721StartBlock: 14670294,
-    ipNftClassHash: "0x012d3ae40ba35c7e2be0946532dac60e48932447912fdf96b674da67c029b9cc",
-    ipCollectionClassHash: "0x022155a1a130a40e57aac4b89c07fab3f616bc351b1270fc40f756b963afe8b4",
-    collection1155: "0x015368976d46fae5bfa1c58600f641d5aa5dbbf53ebc6b78aa3922194aad3551",
-    collection1155FactoryClassHash: "0x04eb6b419770f13bd191f120b9fc9ee624c0613ad4490062d293ca2016b3b1d2",
-    collection1155ClassHash: "0x06cf3f5a2322dac35e07a6064a5b8802f19fda8aa3f4726f0cb7bc05dea1bd78",
-    collection1155StartBlock: 11199527,
-    popFactory: "0x00b32c34b427d8f346b5843ada6a37bd3368d879fc752cd52b68a87287f60111",
-    popCollectionClassHash: "0x077c421686f10851872561953ea16898d933364b7f8937a5d7e2b1ba0a36263f",
-    dropFactory: "0x03587f42e29daee1b193f6cf83bf8627908ed6632d0d83fcb26225c50547d800",
-    dropCollectionClassHash: "0x00092e72cdb63067521e803aaf7d4101c3e3ce026ae6bc045ec4228027e58282",
-    nftComments: "0x02cdac70c94447189af0389dfea63f4d5e4154ea8a563de288a5ab1c39e37843",
-    creatorCoinFactory: "0x50fa807b5274079fb19374673d7bab6d2dc3af7e1032ea43eb6e44bcbde4c3c",
-    creatorCoinEkuboLauncher: "0x4f7fceb5ac10f12f9544a09580592e5bdf1b7f04f48765eecf12286d8ccb7b4",
-    creatorCoinClassHash: "0x743e4c8a5b96bb83bbf4af04edbbb482d5ece89eed9b729a79fb7df0cd0b6b6",
-    creatorCoinFactoryClassHash: "0x51765926b1344c9a20b8cd4b5abe7b7d47375ae97cf6804db3ea5d4b05a9b55",
-    creatorCoinStartBlock: 10474544,
-    ekuboCore: "0x00000005dd3d2f4429af886cd1a3b08289dbcea99a294197e9eb43b0e0325b4b",
-    ipTicketsFactory: "0x0767bf5b57e1f812463159b5ed683183e1b0c3f942b74871b5c6cd6a93c15e99",
-    ipTicketCollectionClassHash: "0x0449e8eb7c117740d07cb8e0157d32c8ba3d19d1cfd2784ed5e139f5a1e04acc",
-    ipTicketsFactoryClassHash: "0x04a739ac3a673ebd0db96bb24475600797c3ed34827e79517f9b2b1640276e6a",
-    ipTicketsStartBlock: 11933694,
-    ipClubFactory: "0x06a0b0be16d70c78f2e18119dbf90e5911cbfd5d8d484bc555dc61d96f56a2b9",
-    ipClubFactoryClassHash: "0x05d9d431bd3532b1fa4d5bab572f49c5ad8034ee3cc83951aa41ae82c9cad266",
-    ipClubCollectionClassHash: "0x05b8477c72e6bf0cf64967d71155021fd4d77d9a57e8805c6b40709121c002c5",
-    ipClubFactoryStartBlock: 11928775,
-    ipSponsorship: "0x03729ebe0fedf29ec97fca34db09174772af7f870af26a26e024a61040143e5c",
-    ipSponsorshipClassHash: "0x0626daac2ed7e2bf630ef5b10104b3202db1559216c0c1a504c0e99be2fbfec3",
-    ipSponsorshipStartBlock: 11896456,
-    mediaWalletClassHash: "0x014b210c7d47392691144bafecdca3c6c7791cc295ea305988da0a724c05ac31",
-    genesisMintLaunch: "0x06ed61abba98a44d45bed2c4b1a456df15053c3321cfd6e007afb33b7226c9f0",
-    genesisMintBR: "0x01f8b92e3b9e963b8eacb075207e2cc89d4614ff2ac6c2702c7ae10ad19a9db8",
-    genesisMintGlobal: "0x06ad4d55ed2d12ad5d6d55587d800874ef807b051bfefe13497e60ec5b019369"
-  }
-};
-function getCoordinates(chain) {
-  const c = COORDINATES[chain];
-  if (!c) throw new Error(`No coordinates configured for chain "${chain}"`);
-  return c;
-}
-
-// src/constants.ts
-var SN = getCoordinates("STARKNET");
-var STARKNET_MEDIAWALLET_CLASS_HASH = SN.mediaWalletClassHash;
-
-// src/starknet/business-provisioning/account.ts
-function ownerConstructorCalldata(ownerPubkey) {
-  return ["0x0", num.toHex(ownerPubkey), "0x1"];
-}
-function computeAccountAddress(ownerPubkey, salt = 0) {
-  return hash.calculateContractAddressFromHash(
-    num.toHex(salt),
-    STARKNET_MEDIAWALLET_CLASS_HASH,
-    ownerConstructorCalldata(ownerPubkey),
-    0
-  );
-}
-
-// src/wallet/recovery-key.ts
-function isRecoveryKeyForWallet(sealed) {
-  try {
-    return BigInt(computeAccountAddress(sealed.ownerPubKey, 0)) === BigInt(sealed.address);
-  } catch {
-    return false;
-  }
-}
-
-// src/wallet/guardian-status.ts
-function describeGuardianStatus(guardians) {
-  if (guardians.length === 0) return { kind: "none" };
-  return { kind: "active", guardian: guardians[0] };
-}
-function describeRecoveryAction(escape) {
-  if (escape.escapeType !== "Owner") return "none";
-  if (escape.status === "Ready") return "complete";
-  if (escape.status === "Expired") return "start";
-  return "none";
-}
-function normalizeAddress(chain, address) {
-  switch (chain) {
-    case "STARKNET":
-      return normalizeStarknet(address);
-    case "ETHEREUM":
-    case "BASE":
-      return normalizeEvm(address);
-    case "SOLANA":
-      return normalizeSolana(address);
-    case "STELLAR":
-      return normalizeStellar(address);
-    case "BITCOIN":
-      throw new Error("BITCOIN address normalization not implemented");
-  }
-}
-function normalizeStarknet(address) {
-  try {
-    const hex = BigInt(address).toString(16);
-    return "0x" + hex.padStart(64, "0").toLowerCase();
-  } catch {
-    throw new Error(`Invalid STARKNET address: "${address}"`);
-  }
-}
-function normalizeEvm(address) {
-  const m = /^0x([0-9a-fA-F]{40})$/.exec(address);
-  if (!m) throw new Error(`Invalid ETHEREUM/BASE address: "${address}"`);
-  const lower = m[1].toLowerCase();
-  const hash3 = keccak_256(new TextEncoder().encode(lower));
-  let out = "0x";
-  for (let i = 0; i < 40; i++) {
-    const nibble = hash3[i >> 1] >> (i % 2 === 0 ? 4 : 0) & 15;
-    out += nibble >= 8 ? lower[i].toUpperCase() : lower[i];
-  }
-  return out;
-}
-function normalizeSolana(address) {
-  try {
-    const bytes = base58.decode(address);
-    if (bytes.length !== 32) throw new Error("not a 32-byte key");
-    return address;
-  } catch {
-    throw new Error(`Invalid SOLANA address: "${address}"`);
-  }
-}
-var STELLAR_VERSION_BYTES = /* @__PURE__ */ new Set([6 << 3, 2 << 3]);
-function normalizeStellar(address) {
-  const upper = address.toUpperCase();
-  if (!/^[GC][A-Z2-7]{55}$/.test(upper)) {
-    throw new Error(`Invalid STELLAR address: "${address}"`);
-  }
-  let decoded;
-  try {
-    decoded = base32.decode(upper);
-  } catch {
-    throw new Error(`Invalid STELLAR address: "${address}"`);
-  }
-  if (decoded.length !== 35 || !STELLAR_VERSION_BYTES.has(decoded[0])) {
-    throw new Error(`Invalid STELLAR address: "${address}"`);
-  }
-  const payload = decoded.subarray(0, 33);
-  const checksum = decoded[33] | decoded[34] << 8;
-  if (crc16xmodem(payload) !== checksum) {
-    throw new Error(`Invalid STELLAR address: "${address}"`);
-  }
-  return upper;
-}
-function crc16xmodem(bytes) {
-  let crc = 0;
-  for (const byte of bytes) {
-    crc ^= byte << 8;
-    for (let i = 0; i < 8; i++) {
-      crc = crc & 32768 ? (crc << 1 ^ 4129) & 65535 : crc << 1 & 65535;
-    }
-  }
-  return crc;
-}
-
-// src/wallet/addresses.ts
-function normalizeWalletAddress(address) {
-  return normalizeAddress("STARKNET", address);
-}
-function isValidStarknetAddress(address) {
-  try {
-    validateAndParseAddress(address.trim());
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isDeployed(provider, address) {
-  try {
-    await provider.getClassHashAt(normalizeWalletAddress(address));
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/wallet/self-fund-consent.ts
-function createSelfFundConsent(estimateFee) {
-  let handler = null;
-  return {
-    registerHandler(next) {
-      handler = next;
-    },
-    async request({ address, calls }) {
-      if (!handler) return false;
-      const feeEstimate = address && calls ? estimateFee(address, calls).catch(() => null) : Promise.resolve(null);
-      return handler(feeEstimate);
-    }
-  };
-}
-async function deriveAesKey(prfSecret, hkdfInfo) {
-  const hkdf = await crypto.subtle.importKey("raw", prfSecret, "HKDF", false, ["deriveKey"]);
-  return crypto.subtle.deriveKey(
-    { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: hkdfInfo },
-    hkdf,
-    { name: "AES-GCM", length: 256 },
-    false,
-    ["encrypt", "decrypt"]
-  );
-}
-function generateStarkKeyPair() {
-  const privateKeyHex = "0x" + Array.from(ec.starkCurve.utils.randomPrivateKey()).map((b) => b.toString(16).padStart(2, "0")).join("");
-  return { privateKeyHex, publicKeyHex: ec.starkCurve.getStarkKey(privateKeyHex) };
-}
-var InvalidStarkPrivateKeyError = class extends Error {
-  constructor(reason) {
-    super(`Not a valid Starknet private key: ${reason}`);
-    this.name = "InvalidStarkPrivateKeyError";
-  }
-};
-function starkKeyPairFromPrivateKey(input) {
-  const trimmed = input.trim().replace(/\s+/g, "");
-  const body = trimmed.startsWith("0x") || trimmed.startsWith("0X") ? trimmed.slice(2) : trimmed;
-  if (body.length === 0) throw new InvalidStarkPrivateKeyError("it is empty");
-  if (!/^[0-9a-fA-F]+$/.test(body)) throw new InvalidStarkPrivateKeyError("it is not hexadecimal");
-  if (body.length > 64) throw new InvalidStarkPrivateKeyError("it is too long");
-  const value = BigInt("0x" + body);
-  if (value === 0n) throw new InvalidStarkPrivateKeyError("it is zero");
-  if (value >= ec.starkCurve.CURVE.n) throw new InvalidStarkPrivateKeyError("it is outside the curve order");
-  const privateKeyHex = "0x" + value.toString(16).padStart(64, "0");
-  return { privateKeyHex, publicKeyHex: ec.starkCurve.getStarkKey(privateKeyHex) };
-}
-async function sealPrivateKey(aesKey, iv, privateKeyHex) {
-  return crypto.subtle.encrypt(
-    { name: "AES-GCM", iv },
-    aesKey,
-    new TextEncoder().encode(privateKeyHex)
-  );
-}
-async function unsealPrivateKey(aesKey, iv, ciphertext) {
-  const buf = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, aesKey, ciphertext);
-  return new TextDecoder().decode(buf);
-}
-function signWithPrivateKey(privateKeyHex, msgHash) {
-  const sig = ec.starkCurve.sign(msgHash, privateKeyHex);
-  return [num.toHex(sig.r), num.toHex(sig.s)];
-}
-
-// src/wallet/passkey.ts
-var PasskeyCancelledError = class extends Error {
-  constructor(message = "Passkey prompt was cancelled.") {
-    super(message);
-    this.name = "PasskeyCancelledError";
-  }
-};
-var encodeBase64 = (buf) => {
-  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
-  let binary = "";
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary);
-};
-var decodeBase64 = (value) => {
-  const binary = atob(value);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-  return bytes;
-};
-function isPasskeyCancellation(err) {
-  const name = err?.name;
-  return name === "NotAllowedError" || name === "AbortError";
-}
-function createPasskeyOwner(config) {
-  const randomBytes = config.randomBytes ?? ((length) => crypto.getRandomValues(new Uint8Array(length)));
-  const credentialsApi = () => {
-    const api = config.credentials ?? (typeof navigator === "undefined" ? void 0 : navigator.credentials);
-    if (!api) throw new Error("Passkeys are only available in a browser.");
-    return api;
-  };
-  const prfUnsupportedMessage = () => {
-    const isBrave = typeof navigator !== "undefined" && "brave" in navigator;
-    const cause = isBrave ? "Brave doesn't currently support the WebAuthn PRF extension." : "This browser didn't return a passkey PRF secret.";
-    return `${cause} ${config.appName} needs it to seal your key. Your device passkey (Touch ID) is fine, the limitation is the browser. Please open this in Safari or Chrome on an up-to-date OS.`;
-  };
-  async function registerPasskey() {
-    let credential;
-    try {
-      credential = await credentialsApi().create({
-        publicKey: {
-          challenge: randomBytes(32),
-          rp: { name: config.relyingPartyName, id: config.relyingPartyId() },
-          user: await config.passkeyUser(),
-          excludeCredentials: config.knownCredentials(),
-          pubKeyCredParams: [
-            { type: "public-key", alg: -7 },
-            { type: "public-key", alg: -257 }
-          ],
-          authenticatorSelection: {
-            residentKey: "required",
-            userVerification: "required",
-            authenticatorAttachment: "platform"
-          },
-          extensions: { prf: { eval: { first: config.prfSalt } } }
-        }
-      });
-    } catch (err) {
-      if (isPasskeyCancellation(err)) throw new PasskeyCancelledError();
-      throw err;
-    }
-    const prf = credential.getClientExtensionResults().prf;
-    return { credentialId: encodeBase64(credential.rawId), prfFirst: prf?.results?.first ?? null };
-  }
-  async function prfSecret(credentialId) {
-    let assertion;
-    try {
-      assertion = await credentialsApi().get({
-        publicKey: {
-          challenge: randomBytes(32),
-          rpId: config.relyingPartyId(),
-          allowCredentials: [{ type: "public-key", id: decodeBase64(credentialId) }],
-          userVerification: "required",
-          extensions: { prf: { eval: { first: config.prfSalt } } }
-        }
-      });
-    } catch (err) {
-      if (isPasskeyCancellation(err)) throw new PasskeyCancelledError();
-      throw err;
-    }
-    const result = assertion.getClientExtensionResults().prf?.results?.first;
-    if (!result) throw new Error("Passkey PRF unavailable on this device/browser.");
-    return new Uint8Array(result);
-  }
-  async function secretFromRegistration(registration) {
-    if (registration.prfFirst) return new Uint8Array(registration.prfFirst);
-    try {
-      return await prfSecret(registration.credentialId);
-    } catch {
-      throw new Error(prfUnsupportedMessage());
-    }
-  }
-  async function seal(secret, privateKeyHex) {
-    const aes = await deriveAesKey(secret, config.hkdfInfo);
-    const iv = randomBytes(12);
-    const ciphertext = await sealPrivateKey(aes, iv, privateKeyHex);
-    return { iv: encodeBase64(iv), ciphertext: encodeBase64(ciphertext) };
-  }
-  return {
-    async createOwnerKey() {
-      const registration = await registerPasskey();
-      const secret = await secretFromRegistration(registration);
-      const { privateKeyHex, publicKeyHex } = generateStarkKeyPair();
-      const { iv, ciphertext } = await seal(secret, privateKeyHex);
-      return {
-        sealed: {
-          credentialId: registration.credentialId,
-          ownerPubKey: publicKeyHex,
-          address: computeAccountAddress(publicKeyHex, 0),
-          iv,
-          ciphertext
-        },
-        privateKeyHex
-      };
-    },
-    async unlockOwnerKey(sealed) {
-      const secret = await prfSecret(sealed.credentialId);
-      const aes = await deriveAesKey(secret, config.hkdfInfo);
-      return unsealPrivateKey(aes, decodeBase64(sealed.iv), decodeBase64(sealed.ciphertext));
-    },
-    async sealImportedOwnerKey(privateKeyInput) {
-      const { privateKeyHex, publicKeyHex } = starkKeyPairFromPrivateKey(privateKeyInput);
-      const registration = await registerPasskey();
-      const secret = await secretFromRegistration(registration);
-      const { iv, ciphertext } = await seal(secret, privateKeyHex);
-      return {
-        credentialId: registration.credentialId,
-        ownerPubKey: publicKeyHex,
-        address: computeAccountAddress(publicKeyHex, 0),
-        iv,
-        ciphertext
-      };
-    },
-    walletAddressForPrivateKey(privateKeyInput) {
-      return computeAccountAddress(starkKeyPairFromPrivateKey(privateKeyInput).publicKeyHex, 0);
-    }
-  };
-}
-
-// src/starknet/services/sponsoredExecutor.ts
-var SponsoredCallRejectedError = class extends Error {
-};
-var USER_MAY_PAY = /* @__PURE__ */ new Set(["sponsor_unavailable", "credits_exhausted"]);
-function userMayPayInstead(code, status, stage) {
-  if (code) return USER_MAY_PAY.has(code);
-  return stage === "build" ? status >= 500 : status === 503;
-}
-async function failureOf(res, fallback) {
-  const body = await res.json().catch(() => null);
-  return { reason: body?.error || fallback, code: typeof body?.code === "string" ? body.code : void 0 };
-}
-async function executeSponsored(config, signer, calls) {
-  const doFetch = config.fetchImpl ?? fetch;
-  const base = config.proxyUrl.replace(/\/$/, "");
-  const buildRes = await doFetch(`${base}/build`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ userAddress: signer.address, calls })
-  });
-  if (!buildRes.ok) {
-    const { reason, code } = await failureOf(buildRes, "We couldn't prepare this transaction.");
-    if (userMayPayInstead(code, buildRes.status, "build")) return { status: "unavailable", reason };
-    throw new SponsoredCallRejectedError(reason);
-  }
-  const { typedData } = await buildRes.json();
-  const signature = await signer.signTypedData(typedData);
-  const executeRes = await doFetch(`${base}/execute`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ userAddress: signer.address, typedData, signature, calls })
-  });
-  if (!executeRes.ok) {
-    const { reason, code } = await failureOf(executeRes, "We couldn't submit this transaction.");
-    if (userMayPayInstead(code, executeRes.status, "execute")) {
-      return { status: "unavailable", reason };
-    }
-    throw new SponsoredCallRejectedError(reason);
-  }
-  const { transactionHash } = await executeRes.json();
-  return { status: "sponsored", transactionHash };
-}
-
-// src/wallet/executors.ts
-function accountFor(provider, address, privateKeyHex) {
-  return new Account({ provider, address, signer: privateKeyHex, cairoVersion: "1" });
-}
-async function estimateSelfFundedFee(provider, address, calls) {
-  const account = new Account({ provider, address, signer: "0x1", cairoVersion: "1" });
-  const estimate = await account.estimateInvokeFee(calls);
-  return { feeRaw: estimate.overall_fee, unit: estimate.unit };
-}
-function selfFundedExecutor(deps) {
-  return {
-    async execute({ userAddress, privateKeyHex, calls }) {
-      const account = accountFor(deps.provider(), userAddress, privateKeyHex);
-      const { transaction_hash } = await account.execute(calls);
-      return { transactionHash: transaction_hash };
-    }
-  };
-}
-function sponsoredExecutor(deps) {
-  const fallback = deps.fallback ?? selfFundedExecutor(deps);
-  return {
-    async execute(input) {
-      const { userAddress, privateKeyHex, calls } = input;
-      const result = await executeSponsored(
-        { proxyUrl: deps.proxyUrl, fetchImpl: deps.fetchImpl },
-        {
-          address: userAddress,
-          signTypedData: async (data) => signWithPrivateKey(privateKeyHex, typedData.getMessageHash(data, userAddress))
-        },
-        calls
-      );
-      if (result.status === "sponsored") return { transactionHash: result.transactionHash };
-      const consented = await deps.consent.request({ address: userAddress, calls });
-      if (!consented) throw new SponsoredCallRejectedError(result.reason);
-      return fallback.execute(input);
-    }
-  };
-}
-var norm = (address) => normalizeAddress("STARKNET", address);
-var SIGNER_TYPE_NAMES = ["Starknet", "Secp256k1", "Secp256r1"];
-function encodeFeltArray(items) {
-  return [num.toHex(items.length), ...items];
-}
-function encodeStarknetSigner(pubkey) {
-  return ["0x0", num.toHex(pubkey)];
-}
-function encodeStarknetSignerArray(pubkeys) {
-  return [num.toHex(pubkeys.length), ...pubkeys.flatMap(encodeStarknetSigner)];
-}
-function buildSetFirstGuardianCall(address, guardianPubkey) {
-  return {
-    contractAddress: norm(address),
-    entrypoint: "change_guardians",
-    calldata: [...encodeFeltArray([]), ...encodeStarknetSignerArray([guardianPubkey])]
-  };
-}
-function buildTriggerEscapeOwnerCall(targetAddress, newOwnerPubkey) {
-  return {
-    contractAddress: norm(targetAddress),
-    entrypoint: "trigger_escape_owner",
-    calldata: encodeStarknetSigner(newOwnerPubkey)
-  };
-}
-function buildCompleteEscapeOwnerCall(targetAddress) {
-  return { contractAddress: norm(targetAddress), entrypoint: "escape_owner", calldata: [] };
-}
-function buildCancelEscapeCall(address) {
-  return { contractAddress: norm(address), entrypoint: "cancel_escape", calldata: [] };
-}
-function decodeGuardiansInfo(res) {
-  const len = Number(res[0]);
-  const out = [];
-  for (let i = 0; i < len; i++) {
-    const base = 1 + i * 3;
-    out.push({
-      type: SIGNER_TYPE_NAMES[Number(res[base])] ?? "Starknet",
-      guid: res[base + 1],
-      storedValue: res[base + 2]
-    });
-  }
-  return out;
-}
-var ESCAPE_TYPE_NAMES = ["None", "Guardian", "Owner"];
-var ESCAPE_STATUS_NAMES = ["None", "NotReady", "Ready", "Expired"];
-function decodeEscapeAndStatus(res) {
-  const readyAt = Number(res[0]);
-  const escapeType = ESCAPE_TYPE_NAMES[Number(res[1])] ?? "None";
-  const optionTag = Number(res[2]);
-  const statusIndex = optionTag === 0 ? 5 : 3;
-  const status = ESCAPE_STATUS_NAMES[Number(res[statusIndex])] ?? "None";
-  return { readyAt, escapeType, status };
-}
-async function getGuardians(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_guardians_info",
-    calldata: []
-  });
-  return decodeGuardiansInfo(res);
-}
-async function getOwners(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_owners_info",
-    calldata: []
-  });
-  return decodeGuardiansInfo(res);
-}
-async function getEscape(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_escape_and_status",
-    calldata: []
-  });
-  return decodeEscapeAndStatus(res);
-}
-async function getEscapeSecurityPeriod(provider, address) {
-  const res = await provider.callContract({
-    contractAddress: norm(address),
-    entrypoint: "get_escape_security_period",
-    calldata: []
-  });
-  return Number(res[0]);
-}
-var STARKNET_SIGNER_TYPE = "0x537461726b6e6574205369676e6572";
-var OPTION_NONE = "0x1";
-var SIGNER_STARKNET = "0x0";
-function computeOwnerGuid(ownerPubkey) {
-  return hash.computePoseidonHash(STARKNET_SIGNER_TYPE, num.toHex(ownerPubkey));
-}
-function changeOwners(accountAddress, guidsToRemove, pubkeysToAdd, ownerAlive) {
-  return {
-    contractAddress: accountAddress,
-    entrypoint: "change_owners",
-    calldata: [
-      num.toHex(guidsToRemove.length),
-      ...guidsToRemove,
-      num.toHex(pubkeysToAdd.length),
-      ...pubkeysToAdd.flatMap((p) => [SIGNER_STARKNET, num.toHex(p)]),
-      ...[OPTION_NONE]
-    ]
-  };
-}
-function buildAddOwnerCall(accountAddress, addOwnerPubkey) {
-  return changeOwners(accountAddress, [], [addOwnerPubkey]);
-}
-function buildRemoveOwnerByGuidCall(accountAddress, ownerGuid) {
-  return changeOwners(accountAddress, [num.toHex(ownerGuid)], []);
-}
-
-// src/wallet/client.ts
-function describeDevices(owners, thisDevicePubkey) {
-  const mine = computeOwnerGuid(thisDevicePubkey);
-  return owners.map((owner) => ({
-    guid: owner.guid,
-    type: owner.type,
-    isThisDevice: BigInt(owner.guid) === BigInt(mine)
-  }));
-}
-function canRemoveDevice(devices, guid) {
-  if (devices.length <= 1) return false;
-  return devices.some((device) => BigInt(device.guid) === BigInt(guid));
-}
-function createMediaWallet(config) {
-  const ttl = config.unlockTtlMs ?? 2e4;
-  const unlockCache = /* @__PURE__ */ new Map();
-  const lock = (address) => {
-    const entry = unlockCache.get(address);
-    if (!entry) return;
-    clearTimeout(entry.timer);
-    unlockCache.delete(address);
-  };
-  const unlockOnce = (sealed) => {
-    const existing = unlockCache.get(sealed.address);
-    if (existing) return existing.promise;
-    const promise = config.passkey.unlockOwnerKey(sealed).catch((err) => {
-      lock(sealed.address);
-      throw err;
-    });
-    const timer = setTimeout(() => lock(sealed.address), ttl);
-    unlockCache.set(sealed.address, { promise, timer });
-    return promise;
-  };
-  const run = async (sealed, calls, userAddress) => {
-    const privateKeyHex = await unlockOnce(sealed);
-    return config.executor.execute({
-      userAddress: userAddress ?? sealed.address,
-      privateKeyHex,
-      calls
-    });
-  };
-  return {
-    store: config.store,
-    passkey: config.passkey,
-    lock,
-    signerFor(sealed) {
-      return {
-        address: sealed.address,
-        signTypedData: async (data) => {
-          const privateKeyHex = await unlockOnce(sealed);
-          return signWithPrivateKey(privateKeyHex, typedData.getMessageHash(data, sealed.address));
-        },
-        execute: async (calls) => {
-          const { transactionHash } = await run(sealed, calls);
-          return { txHash: transactionHash };
-        }
-      };
-    },
-    run,
-    getGuardians: (address) => getGuardians(config.provider(), address),
-    getEscape: (address) => getEscape(config.provider(), address),
-    getEscapeSecurityPeriod: (address) => getEscapeSecurityPeriod(config.provider(), address),
-    getOwners: (address) => getOwners(config.provider(), address),
-    async isOwnerOf(accountAddress, devicePubkey) {
-      const owners = await getOwners(config.provider(), accountAddress);
-      const guid = BigInt(computeOwnerGuid(devicePubkey));
-      return owners.some((owner) => BigInt(owner.guid) === guid);
-    },
-    async setFirstGuardian(sealed, guardianPubkey) {
-      const { transactionHash } = await run(sealed, [buildSetFirstGuardianCall(sealed.address, guardianPubkey)]);
-      return transactionHash;
-    },
-    async triggerEscapeOwner(guardianSealed, targetAddress, newOwnerPubkey) {
-      const { transactionHash } = await run(
-        guardianSealed,
-        [buildTriggerEscapeOwnerCall(targetAddress, newOwnerPubkey)],
-        normalizeWalletAddress(targetAddress)
-      );
-      return transactionHash;
-    },
-    async completeEscapeOwner(guardianSealed, targetAddress) {
-      const { transactionHash } = await run(
-        guardianSealed,
-        [buildCompleteEscapeOwnerCall(targetAddress)],
-        normalizeWalletAddress(targetAddress)
-      );
-      return transactionHash;
-    },
-    async cancelEscape(sealed) {
-      const { transactionHash } = await run(sealed, [buildCancelEscapeCall(sealed.address)]);
-      return transactionHash;
-    },
-    async addDevice(sealed, devicePubkey) {
-      const { transactionHash } = await run(sealed, [buildAddOwnerCall(sealed.address, devicePubkey)]);
-      return transactionHash;
-    },
-    async removeDevice(sealed, ownerGuid) {
-      const { transactionHash } = await run(sealed, [buildRemoveOwnerByGuidCall(sealed.address, ownerGuid)]);
-      return transactionHash;
-    }
-  };
-}
-
-export { InvalidPairingPayloadError, PasskeyCancelledError, accountFor, canRemoveDevice, createMediaWallet, createOwnerStore, createPasskeyOwner, createSelfFundConsent, describeDevices, describeGuardianStatus, describeRecoveryAction, encodePairingPayload, estimateSelfFundedFee, isDeployed, isRecoveryKeyForWallet, isValidStarknetAddress, normalizeWalletAddress, parseAccountAddress, parsePairingPayload, selfFundedExecutor, sponsoredExecutor };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map