@medialane/sdk 0.154.0 → 0.156.0

package/dist/starknet/index.cjs

@@ -1,1164 +1,11 @@
 'use strict';
 
-var zod = require('zod');
-var sha3_js = require('@noble/hashes/sha3.js');
-var base = require('@scure/base');
+var chunkZFRHADHR_cjs = require('../chunk-ZFRHADHR.cjs');
+var chunkOUPVVMLK_cjs = require('../chunk-OUPVVMLK.cjs');
 var starknet = require('starknet');
 var hkdf_js = require('@noble/hashes/hkdf.js');
 var sha2_js = require('@noble/hashes/sha2.js');
 
-// src/config.ts
-
-// src/chains.ts
-var CHAINS = ["STARKNET", "ETHEREUM", "SOLANA", "BASE", "STELLAR", "BITCOIN"];
-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",
-    genesisMint: "0x06ed61abba98a44d45bed2c4b1a456df15053c3321cfd6e007afb33b7226c9f0"
-  }
-};
-function getCoordinates(chain) {
-  const c = COORDINATES[chain];
-  if (!c) throw new Error(`No coordinates configured for chain "${chain}"`);
-  return c;
-}
-var DEFAULT_CHAIN = "STARKNET";
-function getStarknetCoordinates(chain) {
-  if (chain !== "STARKNET") {
-    throw new Error(`This module is Starknet-only (client chain: "${chain}")`);
-  }
-  return getCoordinates("STARKNET");
-}
-var FeeConfigSchema = zod.z.object({
-  enabled: zod.z.boolean().default(true),
-  fundAddress: zod.z.string().min(1).optional(),
-  marketplaceBps: zod.z.number().int().min(0).max(1e4).default(100),
-  launchpadBps: zod.z.number().int().min(0).max(1e4).default(100),
-  sponsorshipBps: zod.z.number().int().min(0).max(1e4).default(100)
-});
-function resolveFeeConfig(raw) {
-  const p = FeeConfigSchema.parse(raw ?? {});
-  return {
-    enabled: p.enabled,
-    fundAddress: p.fundAddress,
-    marketplaceBps: p.marketplaceBps,
-    launchpadBps: p.launchpadBps,
-    sponsorshipBps: p.sponsorshipBps
-  };
-}
-
-// src/config.ts
-var MedialaneConfigSchema = zod.z.object({
-  chain: zod.z.enum(CHAINS).default(DEFAULT_CHAIN),
-  rpcUrl: zod.z.string().url().optional(),
-  backendUrl: zod.z.string().url().optional(),
-  apiKey: zod.z.string().optional(),
-  marketplace721Contract: zod.z.string().optional(),
-  marketplaceContract: zod.z.string().optional(),
-  marketplace1155Contract: zod.z.string().optional(),
-  collection721Contract: zod.z.string().optional(),
-  collectionContract: zod.z.string().optional(),
-  collection1155Contract: zod.z.string().optional(),
-  retryOptions: zod.z.object({
-    maxAttempts: zod.z.number().int().min(1).max(10).optional(),
-    baseDelayMs: zod.z.number().int().min(0).optional(),
-    maxDelayMs: zod.z.number().int().min(0).optional()
-  }).optional(),
-  feeConfig: FeeConfigSchema.optional()
-});
-function resolveConfig(raw) {
-  const parsed = MedialaneConfigSchema.parse(raw);
-  const coords = getCoordinates(parsed.chain);
-  const sn = parsed.chain === "STARKNET" ? coords : {};
-  const marketplace721Contract = parsed.marketplace721Contract ?? parsed.marketplaceContract ?? sn.marketplace721;
-  const collection721Contract = parsed.collection721Contract ?? parsed.collectionContract ?? sn.collection721;
-  return {
-    chain: parsed.chain,
-    rpcUrl: parsed.rpcUrl ?? coords.rpcUrl,
-    backendUrl: parsed.backendUrl,
-    apiKey: parsed.apiKey,
-    marketplace721Contract,
-    marketplaceContract: marketplace721Contract,
-    marketplace1155Contract: parsed.marketplace1155Contract ?? sn.marketplace1155,
-    collection721Contract,
-    collectionContract: collection721Contract,
-    collection1155Contract: parsed.collection1155Contract ?? sn.collection1155,
-    retryOptions: parsed.retryOptions,
-    feeConfig: resolveFeeConfig(parsed.feeConfig)
-  };
-}
-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 hash8 = sha3_js.keccak_256(new TextEncoder().encode(lower));
-  let out = "0x";
-  for (let i = 0; i < 40; i++) {
-    const nibble = hash8[i >> 1] >> (i % 2 === 0 ? 4 : 0) & 15;
-    out += nibble >= 8 ? lower[i].toUpperCase() : lower[i];
-  }
-  return out;
-}
-function normalizeSolana(address) {
-  try {
-    const bytes = base.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 = base.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/utils/retry.ts
-var DEFAULT_MAX_ATTEMPTS = 3;
-var DEFAULT_BASE_DELAY_MS = 300;
-var DEFAULT_MAX_DELAY_MS = 5e3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isRetryableFor(method, err) {
-  if (err instanceof MedialaneApiError && err.status === 429) return true;
-  const isRead = method === "GET" || method === "HEAD";
-  if (!isRead) return false;
-  return err instanceof MedialaneApiError && err.status >= 500 || err instanceof TypeError;
-}
-async function withRetry(fn, opts, method = "GET") {
-  const maxAttempts = opts?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-  const baseDelayMs = opts?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
-  const maxDelayMs = opts?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  let lastError;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      if (!isRetryableFor(method, err) || attempt === maxAttempts - 1) {
-        throw err;
-      }
-      const retryAfterMs = err instanceof MedialaneApiError ? err.retryAfterMs : void 0;
-      const backoff = baseDelayMs * Math.pow(2, attempt) + Math.random() * baseDelayMs;
-      const delay = Math.min(retryAfterMs ?? backoff, maxDelayMs);
-      await sleep(delay);
-    }
-  }
-  throw lastError;
-}
-
-// src/api/client.ts
-function deriveErrorCode(status) {
-  if (status === 404) return "TOKEN_NOT_FOUND";
-  if (status === 429) return "RATE_LIMITED";
-  if (status === 410) return "INTENT_EXPIRED";
-  if (status === 401 || status === 403) return "UNAUTHORIZED";
-  if (status === 400) return "INVALID_PARAMS";
-  return "UNKNOWN";
-}
-var MedialaneApiError = class extends Error {
-  constructor(status, message, retryAfterMs, details) {
-    super(message);
-    this.status = status;
-    this.retryAfterMs = retryAfterMs;
-    this.details = details;
-    this.name = "MedialaneApiError";
-    this.code = deriveErrorCode(status);
-  }
-};
-function parseRetryAfter(value) {
-  if (!value) return void 0;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
-  const date = Date.parse(value);
-  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
-  return void 0;
-}
-var ApiClient = class {
-  constructor(baseUrl, apiKey, retryOptions, chain = "STARKNET") {
-    this.baseUrl = baseUrl;
-    this.chain = chain;
-    this.baseHeaders = apiKey ? { "x-api-key": apiKey } : {};
-    this.retryOptions = retryOptions;
-  }
-  addr(a) {
-    return normalizeAddress(this.chain, a);
-  }
-  async request(path, init, opts) {
-    const url = `${this.baseUrl.replace(/\/$/, "")}${path}`;
-    const headers = { ...this.baseHeaders };
-    if (!(init?.body instanceof FormData)) {
-      headers["Content-Type"] = "application/json";
-    }
-    const allowed = (status) => opts?.allow404 === true && status === 404 || opts?.allow403 === true && status === 403;
-    const res = await withRetry(async () => {
-      const response = await fetch(url, {
-        ...init,
-        headers: { ...headers, ...init?.headers }
-      });
-      if (!response.ok && !allowed(response.status)) {
-        const text = await response.text().catch(() => response.statusText);
-        let message = `Request failed with status ${response.status}`;
-        let details = text;
-        try {
-          const body = JSON.parse(text);
-          if (typeof body.error === "string" && body.error.trim() !== "") {
-            message = body.error;
-          }
-          details = body;
-        } catch {
-        }
-        throw new MedialaneApiError(
-          response.status,
-          message,
-          parseRetryAfter(response.headers.get("retry-after")),
-          details
-        );
-      }
-      return response;
-    }, this.retryOptions, (init?.method ?? "GET").toUpperCase());
-    if (allowed(res.status)) return null;
-    return res.json();
-  }
-  get(path) {
-    return this.request(path, { method: "GET" });
-  }
-  post(path, body) {
-    return this.request(path, { method: "POST", body: JSON.stringify(body) });
-  }
-  patch(path, body) {
-    return this.request(path, { method: "PATCH", body: JSON.stringify(body) });
-  }
-  del(path) {
-    return this.request(path, { method: "DELETE" });
-  }
-  bearer(siwsToken) {
-    return { Authorization: `Bearer ${siwsToken}` };
-  }
-  asSubject(siwsToken) {
-    return siwsToken ? this.bearer(siwsToken) : void 0;
-  }
-  getOrders(query = {}) {
-    const params = new URLSearchParams();
-    if (query.status) params.set("status", query.status);
-    if (query.collection) params.set("collection", query.collection);
-    if (query.currency) params.set("currency", query.currency);
-    if (query.sort) params.set("sort", query.sort);
-    if (query.page !== void 0) params.set("page", String(query.page));
-    if (query.limit !== void 0) params.set("limit", String(query.limit));
-    if (query.offerer) params.set("offerer", this.addr(query.offerer));
-    if (query.minPrice) params.set("minPrice", query.minPrice);
-    if (query.maxPrice) params.set("maxPrice", query.maxPrice);
-    if (query.chain) params.set("chain", query.chain);
-    const qs = params.toString();
-    return this.get(`/v1/orders${qs ? `?${qs}` : ""}`);
-  }
-  getOrder(orderHash) {
-    return this.get(`/v1/orders/${orderHash}`);
-  }
-  getActiveOrdersForToken(contract, tokenId) {
-    return this.get(`/v1/orders/token/${this.addr(contract)}/${tokenId}`);
-  }
-  getReceivedOffers(address, opts = {}) {
-    const params = new URLSearchParams({ page: String(opts.page ?? 1), limit: String(opts.limit ?? 50) });
-    return this.get(`/v1/orders/received/${this.addr(address)}?${params}`);
-  }
-  getOrdersByUser(address, page = 1, limit = 20) {
-    return this.get(
-      `/v1/orders/user/${this.addr(address)}?page=${page}&limit=${limit}`
-    );
-  }
-  getToken(contract, tokenId, wait = false) {
-    return this.get(
-      `/v1/tokens/${contract}/${tokenId}${wait ? "?wait=true" : ""}`
-    );
-  }
-  getTokensByOwner(address, page = 1, limit = 20) {
-    return this.get(
-      `/v1/tokens/owned/${this.addr(address)}?page=${page}&limit=${limit}`
-    );
-  }
-  getTokenHistory(contract, tokenId, page = 1, limit = 20) {
-    return this.get(
-      `/v1/tokens/${contract}/${tokenId}/history?page=${page}&limit=${limit}`
-    );
-  }
-  getCollection(contract) {
-    return this.get(`/v1/collections/${this.addr(contract)}`);
-  }
-  getCollectionTokens(contract, page = 1, limit = 20, sort = "recent") {
-    return this.get(
-      `/v1/collections/${this.addr(contract)}/tokens?page=${page}&limit=${limit}&sort=${sort}`
-    );
-  }
-  getActivities(query = {}) {
-    const params = new URLSearchParams();
-    if (query.type) params.set("type", query.type);
-    if (query.contract) params.set("contract", query.contract);
-    if (query.page !== void 0) params.set("page", String(query.page));
-    if (query.limit !== void 0) params.set("limit", String(query.limit));
-    if (query.chain) params.set("chain", query.chain);
-    const qs = params.toString();
-    return this.get(`/v1/activities${qs ? `?${qs}` : ""}`);
-  }
-  getActivitiesByAddress(address, page = 1, limit = 20) {
-    return this.get(
-      `/v1/activities/${this.addr(address)}?page=${page}&limit=${limit}`
-    );
-  }
-  getTokenComments(contract, tokenId, opts = {}) {
-    const params = new URLSearchParams();
-    if (opts.page !== void 0) params.set("page", String(opts.page));
-    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
-    const qs = params.toString();
-    return this.get(
-      `/v1/tokens/${this.addr(contract)}/${tokenId}/comments${qs ? `?${qs}` : ""}`
-    );
-  }
-  search(q, limit = 10, chain) {
-    const params = new URLSearchParams({ q, limit: String(limit) });
-    if (chain) params.set("chain", chain);
-    return this.get(
-      `/v1/search?${params.toString()}`
-    );
-  }
-  createListingIntent(params) {
-    return this.post("/v1/intents/listing", params);
-  }
-  createOfferIntent(params) {
-    return this.post("/v1/intents/offer", params);
-  }
-  createFulfillIntent(params) {
-    return this.post("/v1/intents/fulfill", params);
-  }
-  createCancelIntent(params) {
-    return this.post("/v1/intents/cancel", params);
-  }
-  createCheckoutIntent(params) {
-    return this.post("/v1/intents/checkout", params);
-  }
-  getIntent(id) {
-    return this.get(`/v1/intents/${id}`);
-  }
-  submitIntentSignature(id, signature) {
-    return this.patch(`/v1/intents/${id}/signature`, { signature });
-  }
-  confirmIntent(id, txHash) {
-    return this.patch(`/v1/intents/${id}/confirm`, { txHash });
-  }
-  syncTransaction(txHash) {
-    return this.post("/v1/tx/sync", { txHash });
-  }
-  createMintIntent(params) {
-    return this.post("/v1/intents/mint", params);
-  }
-  createCollectionIntent(params) {
-    return this.post("/v1/intents/create-collection", params);
-  }
-  createTierIntent(params) {
-    return this.post("/v1/intents/create-tier", params);
-  }
-  emitToRecipients(params) {
-    return this.post("/v1/business/issuance/emission", params);
-  }
-  createCoinIntent(params) {
-    return this.post("/v1/intents/create-coin", params);
-  }
-  launchCoinIntent(params) {
-    return this.post("/v1/intents/launch-coin", params);
-  }
-  createSponsorshipOfferIntent(params) {
-    return this.post("/v1/intents/sponsorship-offer", params);
-  }
-  setSponsorshipOfferOpenIntent(params) {
-    return this.post("/v1/intents/sponsorship-offer-open", params);
-  }
-  placeSponsorshipBidIntent(params) {
-    return this.post("/v1/intents/sponsorship-bid", params);
-  }
-  retractSponsorshipBidIntent(params) {
-    return this.post("/v1/intents/sponsorship-bid-retract", params);
-  }
-  acceptSponsorshipBidIntent(params) {
-    return this.post("/v1/intents/sponsorship-bid-accept", params);
-  }
-  createSponsorshipProposalIntent(params) {
-    return this.post("/v1/intents/sponsorship-proposal", params);
-  }
-  withdrawSponsorshipProposalIntent(params) {
-    return this.post("/v1/intents/sponsorship-proposal-withdraw", params);
-  }
-  acceptSponsorshipProposalIntent(params) {
-    return this.post("/v1/intents/sponsorship-proposal-accept", params);
-  }
-  rejectSponsorshipProposalIntent(params) {
-    return this.post("/v1/intents/sponsorship-proposal-reject", params);
-  }
-  createCounterOfferIntent(params, siwsToken) {
-    const extraHeaders = siwsToken ? { "Authorization": `Bearer ${siwsToken}` } : {};
-    return this.request("/v1/intents/counter-offer", {
-      method: "POST",
-      body: JSON.stringify(params),
-      headers: extraHeaders
-    });
-  }
-  getCounterOffers(query) {
-    const params = new URLSearchParams();
-    if (query.originalOrderHash) params.set("originalOrderHash", query.originalOrderHash);
-    if (query.sellerAddress) params.set("sellerAddress", query.sellerAddress);
-    if (query.page !== void 0) params.set("page", String(query.page));
-    if (query.limit !== void 0) params.set("limit", String(query.limit));
-    return this.get(`/v1/orders/counter-offers?${params}`);
-  }
-  getMetadataSignedUrl(kind) {
-    const params = kind ? `?kind=${kind}` : "";
-    return this.get(`/v1/metadata/signed-url${params}`);
-  }
-  uploadMetadata(metadata) {
-    return this.post("/v1/metadata/upload", metadata);
-  }
-  async uploadMetadataDirectory(files) {
-    const res = await this.post("/v1/metadata/upload-directory", { files });
-    return res.data;
-  }
-  resolveMetadata(uri) {
-    const params = new URLSearchParams({ uri });
-    return this.get(`/v1/metadata/resolve?${params.toString()}`);
-  }
-  uploadFile(file) {
-    const formData = new FormData();
-    formData.append("file", file);
-    return this.request("/v1/metadata/upload-file", {
-      method: "POST",
-      body: formData
-    });
-  }
-  getMe(siwsToken) {
-    return this.request("/v1/portal/me", {
-      method: "GET",
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  getApiKeys(siwsToken) {
-    return this.request("/v1/portal/keys", {
-      method: "GET",
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  createApiKey(input, siwsToken) {
-    return this.request("/v1/portal/keys", {
-      method: "POST",
-      body: JSON.stringify(input ?? {}),
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  deleteApiKey(id, siwsToken) {
-    return this.request(`/v1/portal/keys/${id}`, {
-      method: "DELETE",
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  getCreditHistory(siwsToken) {
-    return this.request("/v1/portal/credits/history", {
-      method: "GET",
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  getSpend(siwsToken) {
-    return this.request("/v1/portal/credits/spend", {
-      method: "GET",
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  checkDeposit(txHash, siwsToken) {
-    return this.request("/v1/portal/credits/check", {
-      method: "POST",
-      body: JSON.stringify({ txHash }),
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  getFundingMethods(siwsToken) {
-    return this.request("/v1/portal/funding/methods", {
-      method: "GET",
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  createFunding(input, siwsToken) {
-    return this.request("/v1/portal/funding", {
-      method: "POST",
-      body: JSON.stringify({ method: input.method, params: input.params }),
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  getFunding(id, siwsToken) {
-    return this.request(`/v1/portal/funding/${encodeURIComponent(id)}`, {
-      method: "GET",
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  getFundingChallenge(id, payer, siwsToken) {
-    return this.request(`/v1/portal/funding/${encodeURIComponent(id)}/challenge`, {
-      method: "POST",
-      body: JSON.stringify({ payer }),
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  authorizeFunding(id, input, siwsToken) {
-    return this.request(
-      `/v1/portal/funding/${encodeURIComponent(id)}/authorize`,
-      { method: "POST", body: JSON.stringify({ payer: input.payer, signature: input.signature }), headers: this.asSubject(siwsToken) }
-    );
-  }
-  submitFunding(id, txHash, siwsToken) {
-    return this.request(`/v1/portal/funding/${encodeURIComponent(id)}/submit`, {
-      method: "POST",
-      body: JSON.stringify({ txHash }),
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  cancelFunding(id, siwsToken) {
-    return this.request(`/v1/portal/funding/${encodeURIComponent(id)}/cancel`, {
-      method: "POST",
-      body: JSON.stringify({}),
-      headers: this.asSubject(siwsToken)
-    });
-  }
-  getWebhooks() {
-    return this.get("/v1/portal/webhooks");
-  }
-  createWebhook(params) {
-    return this.post("/v1/portal/webhooks", params);
-  }
-  deleteWebhook(id) {
-    return this.del(
-      `/v1/portal/webhooks/${id}`
-    );
-  }
-  async claimCollection(contractAddress, walletAddress, siwsToken) {
-    return this.request("/v1/collections/claim", {
-      method: "POST",
-      body: JSON.stringify({ contractAddress, walletAddress }),
-      headers: this.bearer(siwsToken)
-    });
-  }
-  requestCollectionClaim(params) {
-    return this.request("/v1/collections/claim/request", {
-      method: "POST",
-      body: JSON.stringify(params)
-    });
-  }
-  registerBusinessProvisioning(params) {
-    return this.post(
-      "/v1/business/provisioning",
-      { chain: params.chain ?? "STARKNET", email: params.email }
-    );
-  }
-  getCollectionProfile(contractAddress) {
-    return this.request(
-      `/v1/collections/${this.addr(contractAddress)}/profile`,
-      { method: "GET" },
-      { allow404: true }
-    );
-  }
-  updateCollectionProfile(contractAddress, data, siwsToken) {
-    return this.request(
-      `/v1/collections/${this.addr(contractAddress)}/profile`,
-      { method: "PATCH", body: JSON.stringify(data), headers: this.bearer(siwsToken) }
-    );
-  }
-  getWalletActivity(address, chain = "STARKNET") {
-    return this.get(
-      `/v1/wallet-activity?address=${this.addr(address)}&chain=${chain}`
-    );
-  }
-  getGatedContent(contractAddress, siwsToken) {
-    return this.request(
-      `/v1/collections/${this.addr(contractAddress)}/gated-content`,
-      { method: "GET", headers: this.bearer(siwsToken) },
-      { allow404: true, allow403: true }
-    );
-  }
-  getCreators(opts = {}) {
-    const params = new URLSearchParams();
-    if (opts.search) params.set("search", opts.search);
-    if (opts.page) params.set("page", String(opts.page));
-    if (opts.limit) params.set("limit", String(opts.limit));
-    const qs = params.toString();
-    return this.get(`/v1/creators${qs ? `?${qs}` : ""}`);
-  }
-  getCreatorProfile(walletAddress) {
-    return this.request(
-      `/v1/creators/${this.addr(walletAddress)}/profile`,
-      { method: "GET" },
-      { allow404: true }
-    );
-  }
-  getCreatorByUsername(username) {
-    return this.request(
-      `/v1/creators/by-username/${encodeURIComponent(username.toLowerCase().trim())}`,
-      { method: "GET" },
-      { allow404: true }
-    );
-  }
-  updateCreatorProfile(walletAddress, data, siwsToken) {
-    return this.request(
-      `/v1/creators/${this.addr(walletAddress)}/profile`,
-      { method: "PATCH", body: JSON.stringify(data), headers: this.bearer(siwsToken) }
-    );
-  }
-  checkCollectionSlugAvailability(slug) {
-    return this.get(
-      `/v1/collection-slug-claims/check/${encodeURIComponent(slug.toLowerCase().trim())}`
-    );
-  }
-  submitCollectionSlugClaim(contractAddress, slug, siwsToken, notifyEmail) {
-    return this.request("/v1/collection-slug-claims", {
-      method: "POST",
-      body: JSON.stringify({ contractAddress, slug, notifyEmail }),
-      headers: this.bearer(siwsToken)
-    });
-  }
-  getMyCollectionSlugClaims(siwsToken) {
-    return this.request("/v1/collection-slug-claims/me", {
-      method: "GET",
-      headers: this.bearer(siwsToken)
-    });
-  }
-  async getCollectionBySlug(slug) {
-    const res = await this.request(
-      `/v1/collections/by-slug/${encodeURIComponent(slug.toLowerCase().trim())}`,
-      { method: "GET" },
-      { allow404: true }
-    );
-    return res?.data ?? null;
-  }
-  async registerUser(params) {
-    return this.post("/v1/users/register", params);
-  }
-  async upsertMyWallet(siwsToken, options = {}) {
-    const body = {
-      walletType: options.walletType ?? "UNKNOWN"
-    };
-    if (options.chain) body.chain = options.chain;
-    if (options.email) body.email = options.email;
-    if (options.accountToken) body.accountToken = options.accountToken;
-    return this.request("/v1/users/me", {
-      method: "POST",
-      body: JSON.stringify(body),
-      headers: this.bearer(siwsToken)
-    });
-  }
-  async checkEmail(email) {
-    const body = await this.get(`/v1/auth/email/exists?email=${encodeURIComponent(email)}`);
-    return { exists: body.exists };
-  }
-  async requestEmailCode(email) {
-    await this.post("/v1/auth/email/request-code", { email });
-  }
-  async registerEmailAccount(email) {
-    await this.post("/v1/auth/email/register-account", { email });
-  }
-  async verifyEmailCode(email, code) {
-    await this.post("/v1/auth/email/verify-code", { email, code });
-  }
-  async confirmEmail(token) {
-    const body = await this.post("/v1/auth/email/confirm", { token });
-    return { email: body.email };
-  }
-  setupWalletKey(params) {
-    return this.post("/v1/users/me/wallet/key", params);
-  }
-  async getSessionWallet() {
-    const body = await this.post("/v1/users/me/wallet", {});
-    return body.walletAddress ? { walletAddress: body.walletAddress, needsKeySetup: body.needsKeySetup === true } : null;
-  }
-  getMyWallet(siwsToken) {
-    return this.request(
-      "/v1/users/me",
-      { method: "GET", headers: this.bearer(siwsToken) },
-      { allow404: true }
-    );
-  }
-  changeMyEmail(email, siwsToken) {
-    return this.request("/v1/users/me/email", {
-      method: "POST",
-      headers: this.bearer(siwsToken),
-      body: JSON.stringify({ email })
-    });
-  }
-  getTokenRemixes(contract, tokenId, opts = {}) {
-    const params = new URLSearchParams();
-    if (opts.page !== void 0) params.set("page", String(opts.page));
-    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
-    const qs = params.toString();
-    return this.get(
-      `/v1/tokens/${this.addr(contract)}/${tokenId}/remixes${qs ? `?${qs}` : ""}`
-    );
-  }
-  submitRemixOffer(params, siwsToken) {
-    return this.request("/v1/remix-offers", {
-      method: "POST",
-      body: JSON.stringify(params),
-      headers: { "Authorization": `Bearer ${siwsToken}` }
-    });
-  }
-  submitAutoRemixOffer(params, siwsToken) {
-    return this.request("/v1/remix-offers/auto", {
-      method: "POST",
-      body: JSON.stringify(params),
-      headers: { "Authorization": `Bearer ${siwsToken}` }
-    });
-  }
-  confirmSelfRemix(params, siwsToken) {
-    return this.request("/v1/remix-offers/self/confirm", {
-      method: "POST",
-      body: JSON.stringify(params),
-      headers: { "Authorization": `Bearer ${siwsToken}` }
-    });
-  }
-  getRemixOffers(query, siwsToken) {
-    const params = new URLSearchParams({ role: query.role });
-    if (query.status) params.set("status", query.status);
-    if (query.page !== void 0) params.set("page", String(query.page));
-    if (query.limit !== void 0) params.set("limit", String(query.limit));
-    return this.request(`/v1/remix-offers?${params}`, {
-      method: "GET",
-      headers: this.bearer(siwsToken)
-    });
-  }
-  getRemixOffer(id, siwsToken) {
-    return this.request(`/v1/remix-offers/${id}`, {
-      method: "GET",
-      headers: siwsToken ? this.bearer(siwsToken) : void 0
-    });
-  }
-  confirmRemixOffer(id, params, siwsToken) {
-    return this.request(`/v1/remix-offers/${id}/confirm`, {
-      method: "POST",
-      body: JSON.stringify(params),
-      headers: { "Authorization": `Bearer ${siwsToken}` }
-    });
-  }
-  rejectRemixOffer(id, siwsToken) {
-    return this.request(`/v1/remix-offers/${id}/reject`, {
-      method: "POST",
-      body: JSON.stringify({}),
-      headers: { "Authorization": `Bearer ${siwsToken}` }
-    });
-  }
-  extendRemixOffer(id, days, siwsToken) {
-    return this.request(`/v1/remix-offers/${id}/extend`, {
-      method: "POST",
-      body: JSON.stringify({ days }),
-      headers: { "Authorization": `Bearer ${siwsToken}` }
-    });
-  }
-  async getPopEligibility(collection, wallet) {
-    const res = await this.get(
-      `/v1/pop/eligibility/${this.addr(collection)}/${this.addr(wallet)}`
-    );
-    return res.data;
-  }
-  async getPopEligibilityBatch(collection, wallets) {
-    const params = new URLSearchParams({ wallets: wallets.map((w) => this.addr(w)).join(",") });
-    const res = await this.get(
-      `/v1/pop/eligibility/${this.addr(collection)}?${params}`
-    );
-    return res.data;
-  }
-  getCoins(opts = {}) {
-    const params = new URLSearchParams();
-    if (opts.page) params.set("page", String(opts.page));
-    if (opts.limit) params.set("limit", String(opts.limit));
-    if (opts.service) params.set("service", opts.service);
-    if (opts.sort) params.set("sort", opts.sort);
-    if (opts.creator) params.set("creator", this.addr(opts.creator));
-    if (opts.chain) params.set("chain", opts.chain);
-    const qs = params.toString();
-    return this.get(`/v1/coins${qs ? `?${qs}` : ""}`);
-  }
-  getCoin(contract) {
-    return this.get(`/v1/coins/${this.addr(contract)}`);
-  }
-  getCoinPrices() {
-    return this.get("/v1/coins/prices");
-  }
-  claimCoin(coinAddress, siwsToken) {
-    return this.request("/v1/coins/claim", {
-      method: "POST",
-      headers: { Authorization: `Bearer ${siwsToken}` },
-      body: JSON.stringify({ coinAddress })
-    });
-  }
-  getCoinClaims(status = "PENDING") {
-    return this.get(
-      `/v1/coins/claims?status=${encodeURIComponent(status)}`
-    );
-  }
-  updateCoinProfile(contract, data, siwsToken) {
-    return this.request(`/v1/coins/${this.addr(contract)}`, {
-      method: "PATCH",
-      body: JSON.stringify(data),
-      headers: this.bearer(siwsToken)
-    });
-  }
-  async getDropMintStatus(collection, wallet) {
-    const res = await this.get(
-      `/v1/drop/mint-status/${this.addr(collection)}/${this.addr(wallet)}`
-    );
-    return res.data;
-  }
-  async getDropInfo(contract) {
-    const res = await this.request(
-      `/v1/drop/${this.addr(contract)}/info`,
-      { method: "GET" },
-      { allow404: true }
-    );
-    return res?.data ?? null;
-  }
-  async getDropState(contract) {
-    const res = await this.get(`/v1/drop/${this.addr(contract)}/state`);
-    return res.data;
-  }
-  async getTicket(contract, tokenId) {
-    const res = await this.get(`/v1/tickets/${this.addr(contract)}/${tokenId}`);
-    return res.data;
-  }
-  async getTicketCount(contract) {
-    const res = await this.get(`/v1/tickets/${this.addr(contract)}/count`);
-    return res.data.count;
-  }
-  async getClubMembershipCount(contract) {
-    const res = await this.get(`/v1/club/${this.addr(contract)}/count`);
-    return res.data.count;
-  }
-  async getClubMembership(contract, tokenId) {
-    const res = await this.get(`/v1/club/${this.addr(contract)}/${tokenId}`);
-    return res.data;
-  }
-  async isClubMember(contract, tokenId, wallet) {
-    const res = await this.get(
-      `/v1/club/${this.addr(contract)}/${tokenId}/member/${this.addr(wallet)}`
-    );
-    return res.data.isMember;
-  }
-  async getIpNftTokenData(contract, tokenId) {
-    const res = await this.get(`/v1/ipnft/${this.addr(contract)}/${tokenId}`);
-    return res.data;
-  }
-  async getPlatformStats() {
-    const res = await this.get("/v1/stats");
-    return res.data;
-  }
-  getTokens(query = {}) {
-    const params = new URLSearchParams();
-    if (query.page !== void 0) params.set("page", String(query.page));
-    if (query.limit !== void 0) params.set("limit", String(query.limit));
-    if (query.sort) params.set("sort", query.sort);
-    if (query.ipType) params.set("ipType", query.ipType);
-    if (query.derivatives) params.set("derivatives", query.derivatives);
-    const qs = params.toString();
-    return this.get(`/v1/tokens${qs ? `?${qs}` : ""}`);
-  }
-  async isCreatorHidden(wallet) {
-    const res = await this.get(`/v1/creators/${this.addr(wallet)}/hidden`);
-    return res.isHidden;
-  }
-  getMyUsernameClaim(siwsToken) {
-    return this.request("/v1/username-claims/me", {
-      method: "GET",
-      headers: this.bearer(siwsToken)
-    });
-  }
-  checkUsernameAvailability(username) {
-    return this.get(
-      `/v1/username-claims/check/${encodeURIComponent(username)}`
-    );
-  }
-  async submitUsernameClaim(username, siwsToken, notifyEmail) {
-    const res = await this.request("/v1/username-claims", {
-      method: "POST",
-      headers: this.bearer(siwsToken),
-      body: JSON.stringify({ username, ...notifyEmail ? { notifyEmail } : {} })
-    });
-    return res.claim;
-  }
-  async submitReport(report, siwsToken) {
-    const targetContract = report.targetContract ? this.addr(report.targetContract) : void 0;
-    const targetAddress = report.targetAddress ? this.addr(report.targetAddress) : void 0;
-    let targetKey = null;
-    if (report.targetType === "TOKEN" && targetContract && report.targetTokenId) {
-      targetKey = `TOKEN:${targetContract}:${report.targetTokenId}`;
-    } else if (report.targetType === "COLLECTION" && targetContract) {
-      targetKey = `COLLECTION:${targetContract}`;
-    } else if (report.targetType === "CREATOR" && targetAddress) {
-      targetKey = `CREATOR:${targetAddress}`;
-    } else if (report.targetType === "COMMENT" && report.targetId) {
-      targetKey = `COMMENT::${report.targetId}`;
-    }
-    if (!targetKey) throw new Error(`A ${report.targetType} report needs its target`);
-    await this.request("/v1/reports", {
-      method: "POST",
-      headers: this.bearer(siwsToken),
-      body: JSON.stringify({ ...report, targetKey, targetContract, targetAddress })
-    });
-  }
-  getPricing() {
-    return this.get("/v1/pricing");
-  }
-  listCollections(query = {}) {
-    const params = new URLSearchParams();
-    if (query.page !== void 0) params.set("page", String(query.page));
-    if (query.limit !== void 0) params.set("limit", String(query.limit));
-    if (query.owner) params.set("owner", this.addr(query.owner));
-    if (query.service) params.set("service", query.service);
-    if (query.sort) params.set("sort", query.sort);
-    if (query.isFeatured !== void 0) params.set("isFeatured", String(query.isFeatured));
-    if (query.hideEmpty !== void 0) params.set("hideEmpty", String(query.hideEmpty));
-    if (query.standard) params.set("standard", query.standard);
-    if (query.chain) params.set("chain", query.chain);
-    const qs = params.toString();
-    return this.get(`/v1/collections${qs ? `?${qs}` : ""}`);
-  }
-  generateWallet(newWalletSiwsToken, siwsToken) {
-    return this.request("/v1/users/me/generate-wallet", {
-      method: "POST",
-      headers: this.bearer(siwsToken),
-      body: JSON.stringify({ newWalletSiwsToken })
-    });
-  }
-  syncCoin(coinAddress, owner) {
-    return this.post("/v1/coins/sync", { coinAddress, ...owner ? { owner } : {} });
-  }
-  registerCollection(contractAddress) {
-    return this.post("/v1/collections/register", { contractAddress });
-  }
-  getSponsorshipOffers(query = {}) {
-    const params = new URLSearchParams({ limit: String(query.limit ?? 50) });
-    if (query.nftContract) params.set("nftContract", query.nftContract);
-    if (query.author) params.set("author", query.author);
-    if (query.owner) params.set("owner", query.owner);
-    if (query.open !== void 0) params.set("open", String(query.open));
-    return this.get(`/v1/sponsorship/offers?${params}`);
-  }
-  async getSponsorshipOffer(offerId) {
-    const res = await this.request(
-      `/v1/sponsorship/offers/${encodeURIComponent(offerId)}`,
-      { method: "GET" },
-      { allow404: true }
-    );
-    return res?.data ?? null;
-  }
-  async getSponsorshipProposal(proposalId) {
-    const res = await this.request(
-      `/v1/sponsorship/proposals/${encodeURIComponent(proposalId)}`,
-      { method: "GET" },
-      { allow404: true }
-    );
-    return res?.data ?? null;
-  }
-  async getSponsorshipBids(offerId) {
-    const res = await this.get(`/v1/sponsorship/offers/${encodeURIComponent(offerId)}/bids`);
-    return res.data;
-  }
-  getSponsorshipProposals(query = {}) {
-    const params = new URLSearchParams({ limit: String(query.limit ?? 50) });
-    if (query.nftContract) params.set("nftContract", query.nftContract);
-    if (query.proposer) params.set("proposer", query.proposer);
-    if (query.owner) params.set("owner", query.owner);
-    if (query.open !== void 0) params.set("open", String(query.open));
-    return this.get(`/v1/sponsorship/proposals?${params}`);
-  }
-  getSponsorshipLicenses(query = {}) {
-    const params = new URLSearchParams({ limit: String(query.limit ?? 50) });
-    if (query.holder) params.set("holder", query.holder);
-    if (query.author) params.set("author", query.author);
-    return this.get(`/v1/sponsorship/licenses?${params}`);
-  }
-  async getRewards(address) {
-    const res = await this.get(`/v1/rewards/${this.addr(address)}`);
-    return res.data;
-  }
-  getRewardsLeaderboard(page = 1, limit = 50) {
-    return this.get(`/v1/rewards?page=${page}&limit=${limit}`);
-  }
-  getRewardsEvents(address, page = 1, limit = 20) {
-    return this.get(
-      `/v1/rewards/${this.addr(address)}/events?page=${page}&limit=${limit}`
-    );
-  }
-  async getRewardsConfig() {
-    const res = await this.get(`/v1/rewards/config`);
-    return res.data;
-  }
-  async getRewardsBatch(addresses) {
-    if (addresses.length === 0) return [];
-    const params = new URLSearchParams({ addresses: addresses.map((a) => this.addr(a)).join(",") });
-    const res = await this.get(`/v1/rewards/batch?${params}`);
-    return res.data;
-  }
-};
-
-// src/constants.ts
-var SN = getCoordinates("STARKNET");
-SN.marketplace721;
-SN.marketplace721ClassHash;
-SN.marketplace721StartBlock;
-SN.marketplace1155;
-SN.marketplace1155ClassHash;
-SN.marketplace1155StartBlock;
-SN.collection721;
-SN.dataTokenization721;
-SN.collection721StartBlock;
-SN.ipNftClassHash;
-SN.ipCollectionClassHash;
-SN.collection1155;
-SN.collection1155FactoryClassHash;
-SN.collection1155ClassHash;
-SN.collection1155StartBlock;
-SN.popFactory;
-SN.popCollectionClassHash;
-SN.dropFactory;
-SN.dropCollectionClassHash;
-SN.nftComments;
-SN.ipTicketsFactory;
-SN.ipTicketCollectionClassHash;
-SN.ipClubFactory;
-SN.ipClubCollectionClassHash;
-SN.ipSponsorship;
-SN.ipSponsorshipClassHash;
-var STARKNET_MEDIAWALLET_CLASS_HASH = SN.mediaWalletClassHash;
-SN.creatorCoinFactory;
-SN.creatorCoinEkuboLauncher;
-SN.creatorCoinClassHash;
-SN.creatorCoinFactoryClassHash;
-SN.creatorCoinStartBlock;
-SN.genesisMint;
-SN.ekuboCore;
-var SUPPORTED_TOKENS = [
-  {
-    symbol: "USDC",
-    address: "0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb",
-    decimals: 6,
-    listable: true
-  },
-  {
-    symbol: "USDT",
-    address: "0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8",
-    decimals: 6,
-    listable: true
-  },
-  {
-    symbol: "ETH",
-    address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
-    decimals: 18,
-    listable: true
-  },
-  {
-    symbol: "STRK",
-    address: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
-    decimals: 18,
-    listable: true
-  },
-  {
-    symbol: "WBTC",
-    address: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
-    decimals: 8,
-    listable: true
-  }
-];
-
 // src/starknet/marketplace/errors.ts
 var MedialaneError = class extends Error {
   constructor(message, code = "UNKNOWN", cause) {
@@ -1169,71 +16,6 @@ var MedialaneError = class extends Error {
   }
 };
 
-// src/utils/rpc.ts
-var TRANSIENT_BODY_RE = /"code"\s*:\s*-32001|"code"\s*:\s*-32603|unable to complete|rate.?limit|too many|throttl|exceed.*quota|temporarily unavailable|service unavailable|overload|gateway.*time|upstream.*time|backend.*error/i;
-var POLICY_REFUSAL_CODES = [-32003, -32005, -32600];
-function isPolicyRefusal(input) {
-  let body = input.body;
-  if (typeof body === "string") {
-    try {
-      body = JSON.parse(body);
-    } catch {
-      return false;
-    }
-  }
-  const err = body?.error;
-  const code = err && typeof err === "object" ? err.code : void 0;
-  return typeof code === "number" && POLICY_REFUSAL_CODES.includes(code);
-}
-function isTransientRpcError(input) {
-  const { status, body } = input;
-  if (isPolicyRefusal({ body })) return false;
-  if (typeof status === "number" && (status === 429 || status >= 500)) return true;
-  if (body == null) return false;
-  if (typeof body === "object") {
-    const err = body.error;
-    if (!err || typeof err !== "object") return false;
-    const code = err.code;
-    if (typeof code === "number") {
-      if (code === 429) return true;
-      if (code >= -32099 && code <= -32e3) return true;
-      if (code === -32603) return true;
-    }
-    const message = err.message;
-    return typeof message === "string" ? TRANSIENT_BODY_RE.test(message) : false;
-  }
-  return TRANSIENT_BODY_RE.test(String(body));
-}
-function createFailoverFetch(urls, options = {}) {
-  const endpoints = urls.filter((u) => Boolean(u));
-  if (endpoints.length === 0) {
-    throw new Error("createFailoverFetch: at least one RPC URL is required");
-  }
-  const doFetch = options.baseFetch ?? fetch;
-  const failover = async (_input, init) => {
-    let lastError;
-    for (let i = 0; i < endpoints.length; i++) {
-      const url = endpoints[i];
-      const isLast = i === endpoints.length - 1;
-      try {
-        const res = await doFetch(url, init);
-        const text = await res.text();
-        const rebuilt = () => new Response(text, { status: res.status, statusText: res.statusText, headers: res.headers });
-        if (isLast || !isTransientRpcError({ status: res.status, body: text })) {
-          return rebuilt();
-        }
-        options.onFailover?.({ url, status: res.status });
-      } catch (err) {
-        lastError = err;
-        if (isLast) throw err;
-        options.onFailover?.({ url, error: err });
-      }
-    }
-    throw lastError ?? new Error("createFailoverFetch: all endpoints failed");
-  };
-  return failover;
-}
-
 // src/starknet/marketplace/utils.ts
 var START_TIME_BUFFER_SECS = 30;
 function newContract(abi, address, providerOrAccount) {
@@ -1251,7 +33,7 @@ function getChainId(config) {
   return starknet.constants.StarknetChainId.SN_MAIN;
 }
 function resolveToken(currency) {
-  const token = SUPPORTED_TOKENS.find(
+  const token = chunkZFRHADHR_cjs.SUPPORTED_TOKENS.find(
     (t) => t.symbol === currency.toUpperCase() || t.address.toLowerCase() === currency.toLowerCase()
   );
   if (!token) throw new MedialaneError(`Unsupported currency: ${currency}`, "INVALID_PARAMS");
@@ -1262,7 +44,7 @@ function getProvider(config) {
   let p = _providerCache.get(config);
   if (!p) {
     const urls = [config.rpcUrl];
-    p = new starknet.RpcProvider({ nodeUrl: urls[0], baseFetch: createFailoverFetch(urls) });
+    p = new starknet.RpcProvider({ nodeUrl: urls[0], baseFetch: chunkZFRHADHR_cjs.createFailoverFetch(urls) });
     _providerCache.set(config, p);
   }
   return p;
@@ -10298,10 +9080,10 @@ var IPGenesisABI = [
 // src/starknet/services/pop.ts
 var PopService = class {
   constructor(config) {
-    this.factoryAddress = getStarknetCoordinates(config.chain).popFactory;
+    this.factoryAddress = chunkOUPVVMLK_cjs.getStarknetCoordinates(config.chain).popFactory;
   }
   _collection(address, account) {
-    return newContract(POPCollectionABI, normalizeAddress("STARKNET", address), account);
+    return newContract(POPCollectionABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address), account);
   }
   async claim(account, collectionAddress) {
     const call = this._collection(collectionAddress, account).populate("claim", []);
@@ -10388,11 +9170,11 @@ function toContractConditions(c) {
 }
 var DropService = class {
   constructor(config) {
-    this.factoryAddress = getStarknetCoordinates(config.chain).dropFactory;
+    this.factoryAddress = chunkOUPVVMLK_cjs.getStarknetCoordinates(config.chain).dropFactory;
     this.config = config;
   }
   _collection(address, account) {
-    return newContract(DropCollectionABI, normalizeAddress("STARKNET", address), account);
+    return newContract(DropCollectionABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address), account);
   }
   async claim(account, collectionAddress, quantity = 1) {
     const collection = this._collection(collectionAddress, account);
@@ -10472,19 +9254,19 @@ var DropService = class {
 // src/starknet/services/erc1155collection.ts
 var ERC1155CollectionService = class {
   constructor(config) {
-    this.factoryAddress = config.collection1155Contract ?? getStarknetCoordinates(config.chain).collection1155;
+    this.factoryAddress = config.collection1155Contract ?? chunkOUPVVMLK_cjs.getStarknetCoordinates(config.chain).collection1155;
   }
   _factory(account) {
     return newContract(
       IPCollection1155FactoryABI,
-      normalizeAddress("STARKNET", this.factoryAddress),
+      chunkZFRHADHR_cjs.normalizeAddress("STARKNET", this.factoryAddress),
       account
     );
   }
   _collection(address, account) {
     return newContract(
       IPCollection1155ABI,
-      normalizeAddress("STARKNET", address),
+      chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address),
       account
     );
   }
@@ -10667,7 +9449,7 @@ function factoryContract() {
   if (!_factoryContract) {
     _factoryContract = newContract(
       CreatorCoinFactoryABI,
-      getStarknetCoordinates("STARKNET").creatorCoinFactory
+      chunkOUPVVMLK_cjs.getStarknetCoordinates("STARKNET").creatorCoinFactory
     );
   }
   return _factoryContract;
@@ -10704,7 +9486,7 @@ function buildLaunchOnEkuboCalls(params) {
     calls.push({
       contractAddress: params.quoteToken,
       entrypoint: "transfer",
-      calldata: [getStarknetCoordinates("STARKNET").creatorCoinFactory, amt.low, amt.high]
+      calldata: [chunkOUPVVMLK_cjs.getStarknetCoordinates("STARKNET").creatorCoinFactory, amt.low, amt.high]
     });
   }
   calls.push(factoryContract().populate("launch_on_ekubo", [launchParameters, ekuboParameters]));
@@ -10712,26 +9494,26 @@ function buildLaunchOnEkuboCalls(params) {
 }
 var CREATOR_COIN_CREATED_SELECTOR = starknet.hash.getSelectorFromName("CreatorCoinCreated");
 function parseCreatorCoinCreated(receipt) {
-  const factory = normalizeAddress("STARKNET", getStarknetCoordinates("STARKNET").creatorCoinFactory);
+  const factory = chunkZFRHADHR_cjs.normalizeAddress("STARKNET", chunkOUPVVMLK_cjs.getStarknetCoordinates("STARKNET").creatorCoinFactory);
   for (const ev of receipt?.events ?? []) {
     let from;
     try {
-      from = normalizeAddress("STARKNET", ev.from_address ?? "");
+      from = chunkZFRHADHR_cjs.normalizeAddress("STARKNET", ev.from_address ?? "");
     } catch {
       continue;
     }
     if (from !== factory) continue;
     const k0 = ev.keys?.[0];
-    if (!k0 || normalizeAddress("STARKNET", k0) !== normalizeAddress("STARKNET", CREATOR_COIN_CREATED_SELECTOR)) continue;
+    if (!k0 || chunkZFRHADHR_cjs.normalizeAddress("STARKNET", k0) !== chunkZFRHADHR_cjs.normalizeAddress("STARKNET", CREATOR_COIN_CREATED_SELECTOR)) continue;
     const data = ev.data ?? [];
     if (data.length < 1) continue;
-    return normalizeAddress("STARKNET", data[data.length - 1]);
+    return chunkZFRHADHR_cjs.normalizeAddress("STARKNET", data[data.length - 1]);
   }
   throw new Error("Coin deployed but the coin address could not be read from the receipt");
 }
 var CreatorCoinService = class {
   constructor(config) {
-    this.factoryAddress = getStarknetCoordinates(config.chain).creatorCoinFactory;
+    this.factoryAddress = chunkOUPVVMLK_cjs.getStarknetCoordinates(config.chain).creatorCoinFactory;
     this.config = config;
   }
   _factory(account) {
@@ -10756,19 +9538,19 @@ var CreatorCoinService = class {
 var TicketService = class {
   constructor(config) {
     this.config = config;
-    this.factoryAddress = getStarknetCoordinates(config.chain).ipTicketsFactory;
+    this.factoryAddress = chunkOUPVVMLK_cjs.getStarknetCoordinates(config.chain).ipTicketsFactory;
   }
   _factory(account, factoryAddress) {
     const address = factoryAddress ?? this.factoryAddress;
     if (!address) throw new Error("IP-Tickets factory address not configured for this chain");
-    return newContract(IPTicketCollectionFactoryABI, normalizeAddress("STARKNET", address), account);
+    return newContract(IPTicketCollectionFactoryABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address), account);
   }
   _collection(address, account) {
-    return newContract(IPTicketCollectionABI, normalizeAddress("STARKNET", address), account);
+    return newContract(IPTicketCollectionABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address), account);
   }
   _collectionRead(address) {
     const provider = new starknet.RpcProvider({ nodeUrl: this.config.rpcUrl });
-    return newContract(IPTicketCollectionABI, normalizeAddress("STARKNET", address), provider);
+    return newContract(IPTicketCollectionABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address), provider);
   }
   async deployCollection(account, params) {
     const call = this._factory(account, params.factoryAddress).populate("deploy_collection", [
@@ -10829,19 +9611,19 @@ var TicketService = class {
 var ClubService = class {
   constructor(config) {
     this.config = config;
-    this.factoryAddress = getStarknetCoordinates(config.chain).ipClubFactory;
+    this.factoryAddress = chunkOUPVVMLK_cjs.getStarknetCoordinates(config.chain).ipClubFactory;
   }
   _factory(account, factoryAddress) {
     const address = factoryAddress ?? this.factoryAddress;
     if (!address) throw new Error("IP-Club factory address not configured for this chain");
-    return newContract(IPClubFactoryABI, normalizeAddress("STARKNET", address), account);
+    return newContract(IPClubFactoryABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address), account);
   }
   _collection(address, account) {
-    return newContract(IPClubCollectionABI, normalizeAddress("STARKNET", address), account);
+    return newContract(IPClubCollectionABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address), account);
   }
   _collectionRead(address) {
     const provider = new starknet.RpcProvider({ nodeUrl: this.config.rpcUrl });
-    return newContract(IPClubCollectionABI, normalizeAddress("STARKNET", address), provider);
+    return newContract(IPClubCollectionABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address), provider);
   }
   async deployCollection(account, params) {
     const call = this._factory(account, params.factoryAddress).populate("deploy_collection", [
@@ -10904,14 +9686,14 @@ var ClubService = class {
 var SponsorshipService = class {
   constructor(config) {
     this.config = config;
-    this.sponsorshipAddress = getStarknetCoordinates(config.chain).ipSponsorship;
+    this.sponsorshipAddress = chunkOUPVVMLK_cjs.getStarknetCoordinates(config.chain).ipSponsorship;
   }
   _contract(account, address) {
     const resolved = address ?? this.sponsorshipAddress;
     if (!resolved) {
       throw new Error("IP-Sponsorship address not configured for this chain");
     }
-    return newContract(IPSponsorshipABI, normalizeAddress("STARKNET", resolved), account);
+    return newContract(IPSponsorshipABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", resolved), account);
   }
   _contractRead(address) {
     const resolved = address ?? this.sponsorshipAddress;
@@ -10919,7 +9701,7 @@ var SponsorshipService = class {
       throw new Error("IP-Sponsorship address not configured for this chain");
     }
     const provider = new starknet.RpcProvider({ nodeUrl: this.config.rpcUrl });
-    return newContract(IPSponsorshipABI, normalizeAddress("STARKNET", resolved), provider);
+    return newContract(IPSponsorshipABI, chunkZFRHADHR_cjs.normalizeAddress("STARKNET", resolved), provider);
   }
   async createOffer(account, params) {
     const specificSponsor = params.specificSponsor ? new starknet.CairoOption(starknet.CairoOptionVariant.Some, params.specificSponsor) : new starknet.CairoOption(starknet.CairoOptionVariant.None);
@@ -10954,7 +9736,7 @@ var SponsorshipService = class {
     const approveCall = {
       contractAddress: params.paymentToken,
       entrypoint: "approve",
-      calldata: [normalizeAddress("STARKNET", sponsorshipAddress), amount.low.toString(), amount.high.toString()]
+      calldata: [chunkZFRHADHR_cjs.normalizeAddress("STARKNET", sponsorshipAddress), amount.low.toString(), amount.high.toString()]
     };
     const bidCall = this._contract(account, sponsorshipAddress).populate("place_bid", [
       starknet.cairo.uint256(params.offerId),
@@ -11081,7 +9863,7 @@ var SponsorshipService = class {
 // src/starknet/client.ts
 var MedialaneClient = class {
   constructor(rawConfig = {}) {
-    this.config = resolveConfig(rawConfig);
+    this.config = chunkZFRHADHR_cjs.resolveConfig(rawConfig);
     this.services = {
       pop: new PopService(this.config),
       drop: new DropService(this.config),
@@ -11092,9 +9874,9 @@ var MedialaneClient = class {
       sponsorship: new SponsorshipService(this.config)
     };
     if (!this.config.backendUrl) {
-      const sentinel = new ApiClient("https://medialane-sdk-no-backend.invalid", this.config.apiKey);
+      const sentinel = new chunkZFRHADHR_cjs.ApiClient("https://medialane-sdk-no-backend.invalid", this.config.apiKey);
       const apiMethodNames = new Set(
-        Object.getOwnPropertyNames(ApiClient.prototype).filter(
+        Object.getOwnPropertyNames(chunkZFRHADHR_cjs.ApiClient.prototype).filter(
           (k) => k !== "constructor" && typeof sentinel[k] === "function"
         )
       );
@@ -11111,7 +9893,7 @@ var MedialaneClient = class {
         }
       });
     } else {
-      this.api = new ApiClient(this.config.backendUrl, this.config.apiKey, this.config.retryOptions, this.config.chain);
+      this.api = new chunkZFRHADHR_cjs.ApiClient(this.config.backendUrl, this.config.apiKey, this.config.retryOptions, this.config.chain);
     }
   }
   get chain() {
@@ -11166,25 +9948,6 @@ async function getCounter1155(address, config) {
   const contract = getContract(config);
   return BigInt((await contract.get_counter(address)).toString());
 }
-
-// src/utils/bigint.ts
-function stringifyBigInts(obj) {
-  if (typeof obj === "bigint") {
-    return obj.toString();
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(stringifyBigInts);
-  }
-  if (obj !== null && typeof obj === "object") {
-    return Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => [
-        key,
-        stringifyBigInts(value)
-      ])
-    );
-  }
-  return obj;
-}
 var STARKNET_DOMAIN = [
   { name: "name", type: "shortstring" },
   { name: "version", type: "shortstring" },
@@ -11302,7 +10065,7 @@ function buildListingOrder(i, cfg) {
     salt: i.salt,
     counter: i.counter
   };
-  const typedData = stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
+  const typedData = chunkZFRHADHR_cjs.stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
   return { orderParams, typedData };
 }
 function buildOfferOrder(i, cfg) {
@@ -11323,11 +10086,11 @@ function buildOfferOrder(i, cfg) {
     salt: i.salt,
     counter: i.counter
   };
-  const typedData = stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
+  const typedData = chunkZFRHADHR_cjs.stringifyBigInts(buildOrderTypedData(orderParams, getChainId(cfg)));
   return { orderParams, typedData };
 }
 function registerPayload(orderParams, signature) {
-  return stringifyBigInts({
+  return chunkZFRHADHR_cjs.stringifyBigInts({
     parameters: {
       ...orderParams,
       offer: { ...orderParams.offer, item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type) },
@@ -11358,14 +10121,14 @@ function buildFulfillCalls(a, cfg) {
   return fee ? [approve, fulfill, fee] : [approve, fulfill];
 }
 function buildCancelCalls(a, cfg) {
-  const cancelRequest = stringifyBigInts({
+  const cancelRequest = chunkZFRHADHR_cjs.stringifyBigInts({
     cancelation: { order_hash: a.orderHash, offerer: a.offerer },
     signature: a.signature
   });
   return [contractFor(cfg).populate("cancel_order", [cancelRequest])];
 }
 function buildCancelTypedData(orderHash, offerer, cfg) {
-  return stringifyBigInts(buildCancellationTypedData({ order_hash: orderHash, offerer }, getChainId(cfg)));
+  return chunkZFRHADHR_cjs.stringifyBigInts(buildCancellationTypedData({ order_hash: orderHash, offerer }, getChainId(cfg)));
 }
 function contractFor2(cfg) {
   return newContract(Medialane1155ABI, cfg.marketplace1155Contract, getProvider(cfg));
@@ -11388,7 +10151,7 @@ function buildListing1155Order(i, cfg) {
     salt: i.salt,
     counter: i.counter
   };
-  const typedData = stringifyBigInts(
+  const typedData = chunkZFRHADHR_cjs.stringifyBigInts(
     build1155OrderTypedData(orderParams, getChainId(cfg))
   );
   return { orderParams, typedData };
@@ -11411,13 +10174,13 @@ function buildOffer1155Order(i, cfg) {
     salt: i.salt,
     counter: i.counter
   };
-  const typedData = stringifyBigInts(
+  const typedData = chunkZFRHADHR_cjs.stringifyBigInts(
     build1155OrderTypedData(orderParams, getChainId(cfg))
   );
   return { orderParams, typedData };
 }
 function registerPayload2(orderParams, signature) {
-  return stringifyBigInts({
+  return chunkZFRHADHR_cjs.stringifyBigInts({
     parameters: {
       ...orderParams,
       offer: { ...orderParams.offer, item_type: starknet.shortString.encodeShortString(orderParams.offer.item_type) },
@@ -11448,14 +10211,14 @@ function buildFulfill1155Calls(a, cfg) {
   return fee ? [approve, fulfill, fee] : [approve, fulfill];
 }
 function buildCancel1155Calls(a, cfg) {
-  const cancelPayload = stringifyBigInts({
+  const cancelPayload = chunkZFRHADHR_cjs.stringifyBigInts({
     cancelation: { order_hash: a.orderHash, offerer: a.offerer },
     signature: a.signature
   });
   return [contractFor2(cfg).populate("cancel_order", [cancelPayload])];
 }
 function buildCancel1155TypedData(orderHash, offerer, cfg) {
-  return stringifyBigInts(
+  return chunkZFRHADHR_cjs.stringifyBigInts(
     build1155CancellationTypedData({ order_hash: orderHash, offerer }, getChainId(cfg))
   );
 }
@@ -11616,135 +10379,6 @@ var StarknetVenue = class {
   }
 };
 
-// src/starknet/admin-auth/types.ts
-var ADMIN_SCOPE = "admin-api";
-function adminRequestDigest(req) {
-  return starknet.hash.computePoseidonHashOnElements([
-    starknet.hash.starknetKeccak(req.method.toUpperCase()),
-    starknet.hash.starknetKeccak(req.path),
-    starknet.hash.starknetKeccak(req.body ?? ""),
-    starknet.num.toBigInt(req.nonce),
-    BigInt(req.ts)
-  ]);
-}
-function signAdminRequest(sessionPrivateKey, req) {
-  const digest = adminRequestDigest(req);
-  return starknet.ec.starkCurve.sign(digest, sessionPrivateKey).toCompactHex();
-}
-function verifyAdminRequestSig(sessionPublicKey, req, sig) {
-  try {
-    return starknet.ec.starkCurve.verify(sig, adminRequestDigest(req), sessionPublicKey);
-  } catch {
-    return false;
-  }
-}
-function buildAdminSessionTypedData(p) {
-  return {
-    types: {
-      StarknetDomain: [
-        { name: "name", type: "shortstring" },
-        { name: "version", type: "shortstring" },
-        { name: "chainId", type: "shortstring" },
-        { name: "revision", type: "shortstring" }
-      ],
-      AdminSession: [
-        { name: "sessionKeyHash", type: "felt" },
-        { name: "scope", type: "shortstring" },
-        { name: "issuedAt", type: "felt" },
-        { name: "expiresAt", type: "felt" }
-      ]
-    },
-    primaryType: "AdminSession",
-    domain: { name: "Medialane Admin", version: "1", chainId: p.chainId ?? "SN_MAIN", revision: "1" },
-    message: {
-      sessionKeyHash: p.sessionKeyHash,
-      scope: p.scope,
-      issuedAt: String(p.issuedAt),
-      expiresAt: String(p.expiresAt)
-    }
-  };
-}
-function sessionKeyHashOf(sessionPublicKey) {
-  return starknet.num.toHex(starknet.hash.starknetKeccak(sessionPublicKey));
-}
-async function createAdminSessionGrant(signTypedData, opts) {
-  const priv = starknet.ec.starkCurve.utils.randomPrivateKey();
-  const sessionPrivateKey = "0x" + starknet.encode.buf2hex(priv);
-  const sessionPublicKey = "0x" + starknet.encode.buf2hex(starknet.ec.starkCurve.getPublicKey(sessionPrivateKey, false));
-  const sessionKeyHash = sessionKeyHashOf(sessionPublicKey);
-  const nowSec = Math.floor((opts.now?.() ?? Date.now()) / 1e3);
-  const issuedAt = nowSec;
-  const expiresAt = nowSec + (opts.ttlSeconds ?? 7200);
-  const data = buildAdminSessionTypedData({ sessionKeyHash, scope: ADMIN_SCOPE, issuedAt, expiresAt, chainId: opts.chainId });
-  const walletSig = await signTypedData(data);
-  const grant = {
-    wallet: opts.wallet,
-    chain: opts.chain ?? "STARKNET",
-    sessionPublicKey,
-    sessionKeyHash,
-    scope: ADMIN_SCOPE,
-    issuedAt,
-    expiresAt,
-    walletSig
-  };
-  return { grant, sessionPrivateKey };
-}
-
-// src/starknet/admin-auth/headers.ts
-var ADMIN_HEADERS = {
-  grant: "x-ml-admin-grant",
-  sig: "x-ml-admin-sig",
-  nonce: "x-ml-admin-nonce",
-  ts: "x-ml-admin-ts"
-};
-function b64urlEncode(s) {
-  const bytes = new TextEncoder().encode(s);
-  let bin = "";
-  for (const b of bytes) bin += String.fromCharCode(b);
-  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function b64urlDecode(s) {
-  const pad = s.length % 4 ? "=".repeat(4 - s.length % 4) : "";
-  const bin = atob(s.replace(/-/g, "+").replace(/_/g, "/") + pad);
-  const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0));
-  return new TextDecoder().decode(bytes);
-}
-function randomNonce() {
-  const b = new Uint8Array(16);
-  crypto.getRandomValues(b);
-  let hex = "";
-  for (const x of b) hex += x.toString(16).padStart(2, "0");
-  return "0x" + hex;
-}
-function encodeAdminHeaders(session, reqInit) {
-  const nonce = randomNonce();
-  const ts = Math.floor((reqInit.now?.() ?? Date.now()) / 1e3);
-  const req = { method: reqInit.method, path: reqInit.path, body: reqInit.body ?? "", nonce, ts };
-  const sig = signAdminRequest(session.sessionPrivateKey, req);
-  return {
-    [ADMIN_HEADERS.grant]: b64urlEncode(JSON.stringify(session.grant)),
-    [ADMIN_HEADERS.sig]: sig,
-    [ADMIN_HEADERS.nonce]: nonce,
-    [ADMIN_HEADERS.ts]: String(ts)
-  };
-}
-function parseAdminHeaders(get) {
-  const rawGrant = get(ADMIN_HEADERS.grant);
-  const sig = get(ADMIN_HEADERS.sig);
-  const nonce = get(ADMIN_HEADERS.nonce);
-  const tsRaw = get(ADMIN_HEADERS.ts);
-  if (!rawGrant || !sig || !nonce || !tsRaw) return null;
-  try {
-    const grant = JSON.parse(b64urlDecode(rawGrant));
-    if (!grant.wallet || !grant.sessionPublicKey || !grant.sessionKeyHash || !Array.isArray(grant.walletSig) || typeof grant.expiresAt !== "number") return null;
-    const ts = Number(tsRaw);
-    if (!Number.isFinite(ts)) return null;
-    return { grant, sig, nonce, ts };
-  } catch {
-    return null;
-  }
-}
-
 // src/starknet/siws/client.ts
 var STORAGE_PREFIX = "ml_siws_";
 function decodeBase64url(str) {
@@ -11863,7 +10497,7 @@ function buildFundingTransferCall(instructions) {
 async function fundWithChainTransfer(api, wallet, options) {
   const step = options.onStep ?? (() => {
   });
-  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const pollMs = options.pollMs ?? 3e3;
   const maxPolls = options.maxPolls ?? 20;
   step("creating");
@@ -11893,19 +10527,11 @@ async function fundWithChainTransfer(api, wallet, options) {
       return { status: "SETTLED", intentId: intent.id, credited: res.data.credited };
     }
     reason = res.data.reason;
-    await sleep2(pollMs);
+    await sleep(pollMs);
   }
   return { status: "PENDING", intentId: intent.id, reason };
 }
 
-// src/errors.ts
-var UserFacingError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "UserFacingError";
-  }
-};
-
 // src/starknet/services/executeIntent.ts
 async function confirmIntentBestEffort(client, intentId, txHash) {
   await client.api.confirmIntent(intentId, txHash).catch(() => {
@@ -11935,14 +10561,14 @@ async function assertTransactionSucceeded(provider, txHash, retryDelaysMs = RECE
       const receipt = await provider.getTransactionReceipt(txHash);
       const status = receipt.execution_status ?? receipt.status;
       if (status === "REVERTED" || status === "REJECTED") {
-        throw new UserFacingError("Transaction was submitted but reverted onchain. Please check your balance and try again.");
+        throw new chunkZFRHADHR_cjs.UserFacingError("Transaction was submitted but reverted onchain. Please check your balance and try again.");
       }
       if (status) return receipt;
     } catch (err) {
       if (err instanceof Error && err.message.includes("reverted onchain")) throw err;
     }
   }
-  throw new UserFacingError("Verification timed out. Check your account for the transaction status.");
+  throw new chunkZFRHADHR_cjs.UserFacingError("Verification timed out. Check your account for the transaction status.");
 }
 async function executeIntent(provider, signer, client, intent, opts = {}) {
   let calls;
@@ -11974,323 +10600,6 @@ async function executeIntents(provider, signer, client, intents, opts = {}) {
   ]);
   return { txHash, receipt };
 }
-
-// src/services/registry.ts
-var SN2 = getStarknetCoordinates("STARKNET");
-var SERVICES = {
-  "mip-erc721": {
-    id: "mip-erc721",
-    displayName: "IP Collection",
-    description: "Tokenize intellectual property as a per-creator ERC-721 collection.",
-    standard: "ERC721",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.collection721,
-        startBlock: SN2.collection721StartBlock
-      }
-    },
-    uiVariant: "standard",
-    capabilities: ["list", "buy", "make_offer", "cancel", "transfer", "mint", "remix", "license"],
-    events: [
-      { name: "CollectionCreated", emittedBy: "factory" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "ip-erc721": {
-    id: "ip-erc721",
-    displayName: "Programmable IP",
-    description: "One shared ERC-721 contract any wallet can mint into.",
-    standard: "ERC721",
-    provenance: "MEDIALANE",
-    uiVariant: "standard",
-    capabilities: ["list", "buy", "make_offer", "cancel", "transfer", "mint", "remix", "license"],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "data-tokenization-erc721": {
-    id: "data-tokenization-erc721",
-    displayName: "Data Tokenization",
-    description: "Establish verifiable ownership of your data, with licensing terms that hold up wherever it travels.",
-    standard: "ERC721",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.dataTokenization721,
-        startBlock: SN2.dataTokenization721StartBlock
-      }
-    },
-    uiVariant: "standard",
-    capabilities: ["list", "buy", "make_offer", "cancel", "transfer", "mint", "remix", "license"],
-    events: [
-      { name: "CollectionCreated", emittedBy: "factory" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "mip-erc1155": {
-    id: "mip-erc1155",
-    displayName: "NFT Editions",
-    description: "Per-creator ERC-1155 collection; creator mints editions.",
-    standard: "ERC1155",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.collection1155,
-        classHash: SN2.collection1155ClassHash,
-        startBlock: SN2.collection1155StartBlock
-      }
-    },
-    uiVariant: "edition",
-    capabilities: ["list", "buy", "make_offer", "cancel", "transfer", "mint", "remix", "license"],
-    events: [
-      { name: "CollectionDeployed", emittedBy: "factory" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "pop-protocol": {
-    id: "pop-protocol",
-    displayName: "POP Protocol",
-    description: "Soulbound proof-of-presence collectibles per event.",
-    standard: "ERC721",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.popFactory,
-        classHash: SN2.popCollectionClassHash
-      }
-    },
-    uiVariant: "pop",
-    capabilities: ["claim", "mint"],
-    events: [
-      { name: "CollectionCreated", emittedBy: "factory" },
-      { name: "AllowlistUpdated", emittedBy: "instance", poll: "slow" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "certificate-emission": {
-    id: "certificate-emission",
-    displayName: "Certificate Emission",
-    description: "Issue a soulbound credential to a list of recipients in one run \u2014 everyone gets a wallet and their certificate.",
-    standard: "ERC721",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.popFactory,
-        classHash: SN2.popCollectionClassHash
-      }
-    },
-    uiVariant: "pop",
-    capabilities: ["mint", "airdrop"],
-    events: [
-      { name: "CollectionCreated", emittedBy: "factory" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "drop-collection": {
-    id: "drop-collection",
-    displayName: "Collection Drop",
-    description: "Sequential mint with claim windows + allowlist.",
-    standard: "ERC721",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.dropFactory,
-        classHash: SN2.dropCollectionClassHash
-      }
-    },
-    uiVariant: "drop",
-    capabilities: ["claim", "list", "buy", "make_offer", "cancel", "transfer"],
-    events: [
-      { name: "DropCreated", emittedBy: "factory" },
-      { name: "AllowlistUpdated", emittedBy: "instance", poll: "slow" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "ip-tickets": {
-    id: "ip-tickets",
-    displayName: "IP Tickets",
-    description: "Create verifiable on-chain tickets \u2014 mint to attendees, trade like any collection.",
-    standard: "ERC1155",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.ipTicketsFactory,
-        classHash: SN2.ipTicketCollectionClassHash
-      }
-    },
-    uiVariant: "ticket",
-    capabilities: ["mint", "redeem", "list", "buy", "make_offer", "cancel", "transfer"],
-    events: [
-      { name: "CollectionDeployed", emittedBy: "factory" },
-      { name: "TicketCreated", emittedBy: "instance" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "ip-ticketing": {
-    id: "ip-ticketing",
-    displayName: "IP Ticketing",
-    description: "Distribute verifiable on-chain tickets to a list of recipients in one run \u2014 everyone gets a wallet and their ticket.",
-    standard: "ERC1155",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.ipTicketsFactory,
-        classHash: SN2.ipTicketCollectionClassHash
-      }
-    },
-    uiVariant: "ticket",
-    capabilities: ["mint", "airdrop", "redeem", "list", "buy", "make_offer", "cancel", "transfer"],
-    events: [
-      { name: "CollectionDeployed", emittedBy: "factory" },
-      { name: "TicketCreated", emittedBy: "instance" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "ip-club": {
-    id: "ip-club",
-    displayName: "IP Club",
-    description: "Membership clubs \u2014 create tiers, mint membership cards, trade like any collection.",
-    standard: "ERC1155",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.ipClubFactory,
-        classHash: SN2.ipClubCollectionClassHash
-      }
-    },
-    uiVariant: "club",
-    capabilities: ["mint", "list", "buy", "make_offer", "cancel", "transfer"],
-    events: [
-      { name: "ClubDeployed", emittedBy: "factory" },
-      { name: "MembershipCreated", emittedBy: "instance" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "ip-sponsorship": {
-    id: "ip-sponsorship",
-    displayName: "IP Sponsorship",
-    description: "Sponsorship offers and licenses anchored to an existing Medialane asset.",
-    standard: "ERC721",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.ipSponsorship,
-        classHash: SN2.ipSponsorshipClassHash,
-        startBlock: SN2.ipSponsorshipStartBlock
-      }
-    },
-    uiVariant: "standard",
-    capabilities: ["sponsor", "transfer"],
-    events: [
-      { name: "OfferCreated", emittedBy: "factory" },
-      { name: "ProposalCreated", emittedBy: "factory" },
-      { name: "LicenseMinted", emittedBy: "factory" }
-    ],
-    metadataSchema: { licenseDefault: "CC BY-SA" }
-  },
-  "creator-coin": {
-    id: "creator-coin",
-    displayName: "Creator Coin",
-    description: "Launch a fixed-supply social token with permanently-locked Ekubo liquidity.",
-    standard: "ERC20",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.creatorCoinFactory,
-        classHash: SN2.creatorCoinFactoryClassHash,
-        startBlock: SN2.creatorCoinStartBlock
-      }
-    },
-    uiVariant: "coin",
-    capabilities: ["launch", "swap", "transfer"],
-    events: [
-      { name: "CreatorCoinCreated", emittedBy: "factory" },
-      { name: "CreatorCoinLaunched", emittedBy: "factory" }
-    ]
-  },
-  "medialane-marketplace-erc721": {
-    id: "medialane-marketplace-erc721",
-    displayName: "Medialane Marketplace (ERC-721)",
-    description: "ERC-721 order matching venue.",
-    standard: "ERC721",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.marketplace721,
-        classHash: SN2.marketplace721ClassHash,
-        startBlock: SN2.marketplace721StartBlock
-      }
-    },
-    uiVariant: "standard",
-    capabilities: ["list", "buy", "make_offer", "cancel"],
-    events: [
-      { name: "OrderCreated", emittedBy: "factory" },
-      { name: "OrderFulfilled", emittedBy: "factory" },
-      { name: "OrderCancelled", emittedBy: "factory" }
-    ]
-  },
-  "medialane-marketplace-erc1155": {
-    id: "medialane-marketplace-erc1155",
-    displayName: "Medialane Marketplace (ERC-1155)",
-    description: "ERC-1155 order matching venue.",
-    standard: "ERC1155",
-    provenance: "MEDIALANE",
-    onchain: {
-      STARKNET: {
-        factoryAddress: SN2.marketplace1155,
-        classHash: SN2.marketplace1155ClassHash,
-        startBlock: SN2.marketplace1155StartBlock
-      }
-    },
-    uiVariant: "edition",
-    capabilities: ["list", "buy", "make_offer", "cancel"],
-    events: [
-      { name: "OrderCreated", emittedBy: "factory" },
-      { name: "OrderFulfilled", emittedBy: "factory" },
-      { name: "OrderCancelled", emittedBy: "factory" }
-    ]
-  },
-  "unruggable-erc20": {
-    id: "unruggable-erc20",
-    displayName: "Unruggable",
-    description: "An ERC-20 launched through the unruggable.meme protocol, the same contract Medialane's Creator Coin is forked from. Not deployed via a Medialane service, but exposes the same on-chain guarantees: capped team allocation, permanently locked liquidity, fixed supply. Brought in by owner claim or admin/partnership \u2014 never bulk-indexed.",
-    standard: "ERC20",
-    provenance: "EXTERNAL",
-    uiVariant: "coin",
-    capabilities: ["swap", "transfer"]
-  },
-  "external-erc20": {
-    id: "external-erc20",
-    displayName: "Memecoin",
-    description: "A plain ERC-20 not deployed via a Medialane service and carrying no protocol-level guarantees. Brought in by owner claim or admin/partnership \u2014 never bulk-indexed. Generalizes to future chains.",
-    standard: "ERC20",
-    provenance: "EXTERNAL",
-    uiVariant: "coin",
-    capabilities: ["swap", "transfer"]
-  },
-  "external-erc721": {
-    id: "external-erc721",
-    displayName: "External ERC-721",
-    description: "ERC-721 contract not deployed via a Medialane service.",
-    standard: "ERC721",
-    provenance: "EXTERNAL",
-    uiVariant: "standard",
-    capabilities: ["list", "buy", "make_offer", "cancel", "transfer"]
-  },
-  "external-erc1155": {
-    id: "external-erc1155",
-    displayName: "External ERC-1155",
-    description: "ERC-1155 contract not deployed via a Medialane service.",
-    standard: "ERC1155",
-    provenance: "EXTERNAL",
-    uiVariant: "edition",
-    capabilities: ["list", "buy", "make_offer", "cancel", "transfer"]
-  }
-};
-function getService(id) {
-  return id && id in SERVICES ? SERVICES[id] : void 0;
-}
-
-// src/starknet/services/receipts.ts
 var DEPLOY_EVENTS = {
   "mip-erc1155": { event: "CollectionDeployed", address: (e) => e.keys?.[1] },
   "ip-tickets": { event: "CollectionDeployed", address: (e) => e.keys?.[1] },
@@ -12312,14 +10621,14 @@ function u2562(low, high) {
   return (BigInt(low ?? 0) + (BigInt(high ?? 0) << 128n)).toString();
 }
 function deployedCollectionFromReceipt(receipt, service) {
-  const factory = getService(service)?.onchain?.STARKNET?.factoryAddress;
+  const factory = chunkZFRHADHR_cjs.getService(service)?.onchain?.STARKNET?.factoryAddress;
   const { event, address } = DEPLOY_EVENTS[service];
   const selector = BigInt(starknet.hash.getSelectorFromName(event));
   for (const e of receipt.events ?? []) {
     if (factory && !sameFelt(e.from_address, factory)) continue;
     if (!sameFelt(e.keys?.[0], selector)) continue;
     const value = address(e);
-    if (value) return normalizeAddress("STARKNET", value);
+    if (value) return chunkZFRHADHR_cjs.normalizeAddress("STARKNET", value);
   }
   return null;
 }
@@ -12410,17 +10719,6 @@ function deriveOwnerKeyPair(secret, recipientId) {
   const publicKey = starknet.ec.starkCurve.getStarkKey(privateKey);
   return { privateKey, publicKey };
 }
-function ownerConstructorCalldata(ownerPubkey) {
-  return ["0x0", starknet.num.toHex(ownerPubkey), "0x1"];
-}
-function computeAccountAddress(ownerPubkey, salt = 0) {
-  return starknet.hash.calculateContractAddressFromHash(
-    starknet.num.toHex(salt),
-    STARKNET_MEDIAWALLET_CLASS_HASH,
-    ownerConstructorCalldata(ownerPubkey),
-    0
-  );
-}
 var STARKNET_SIGNER_TYPE = "0x537461726b6e6574205369676e6572";
 var OPTION_NONE = "0x1";
 var SIGNER_STARKNET = "0x0";
@@ -12451,13 +10749,13 @@ function buildRemoveOwnerByGuidCall(accountAddress, ownerGuid) {
 }
 function buildDeployAccountParams(ownerPubkey, salt = 0) {
   return {
-    classHash: STARKNET_MEDIAWALLET_CLASS_HASH,
-    constructorCalldata: ownerConstructorCalldata(ownerPubkey),
+    classHash: chunkZFRHADHR_cjs.STARKNET_MEDIAWALLET_CLASS_HASH,
+    constructorCalldata: chunkZFRHADHR_cjs.ownerConstructorCalldata(ownerPubkey),
     addressSalt: starknet.num.toHex(salt),
-    contractAddress: computeAccountAddress(ownerPubkey, salt)
+    contractAddress: chunkZFRHADHR_cjs.computeAccountAddress(ownerPubkey, salt)
   };
 }
-var norm = (address) => normalizeAddress("STARKNET", address);
+var norm = (address) => chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address);
 var SIGNER_TYPE_NAMES = ["Starknet", "Secp256k1", "Secp256r1"];
 function encodeFeltArray(items) {
   return [starknet.num.toHex(items.length), ...items];
@@ -12543,53 +10841,6 @@ async function getEscapeSecurityPeriod(provider, address) {
   });
   return Number(res[0]);
 }
-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(starknet.ec.starkCurve.utils.randomPrivateKey()).map((b) => b.toString(16).padStart(2, "0")).join("");
-  return { privateKeyHex, publicKeyHex: starknet.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 >= starknet.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: starknet.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 = starknet.ec.starkCurve.sign(msgHash, privateKeyHex);
-  return [starknet.num.toHex(sig.r), starknet.num.toHex(sig.s)];
-}
 
 // src/wallet/store.ts
 function createOwnerStore(config) {
@@ -12697,7 +10948,7 @@ var InvalidRecoveryKeyError = class extends Error {
 var canonicalAddress = (address) => `0x${BigInt(address).toString(16).padStart(64, "0")}`;
 function keyPair(privateKey) {
   try {
-    return starkKeyPairFromPrivateKey(privateKey);
+    return chunkZFRHADHR_cjs.starkKeyPairFromPrivateKey(privateKey);
   } catch {
     throw new InvalidRecoveryKeyError();
   }
@@ -12710,7 +10961,7 @@ function parseRecoveryKey(input) {
   const trimmed = input.trim();
   if (!trimmed.startsWith(PREFIX)) {
     const { privateKeyHex, publicKeyHex } = keyPair(trimmed);
-    return { walletAddress: computeAccountAddress(publicKeyHex, 0), privateKey: privateKeyHex };
+    return { walletAddress: chunkZFRHADHR_cjs.computeAccountAddress(publicKeyHex, 0), privateKey: privateKeyHex };
   }
   const parts = trimmed.slice(PREFIX.length).split(":");
   const [walletAddress, privateKey] = parts;
@@ -12732,7 +10983,7 @@ function describeRecoveryAction(escape) {
   return "none";
 }
 function normalizeWalletAddress(address) {
-  return normalizeAddress("STARKNET", address);
+  return chunkZFRHADHR_cjs.normalizeAddress("STARKNET", address);
 }
 function isValidStarknetAddress(address) {
   try {
@@ -12767,150 +11018,6 @@ function createSelfFundConsent(estimateFee) {
     }
   };
 }
-
-// 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(recovery) {
-      const { privateKeyHex, publicKeyHex } = starkKeyPairFromPrivateKey(recovery.privateKey);
-      const registration = await registerPasskey();
-      const secret = await secretFromRegistration(registration);
-      const { iv, ciphertext } = await seal(secret, privateKeyHex);
-      return {
-        credentialId: registration.credentialId,
-        ownerPubKey: publicKeyHex,
-        address: recovery.walletAddress,
-        iv,
-        ciphertext
-      };
-    }
-  };
-}
-
-// src/utils/token.ts
-function getTokenBySymbol(symbol) {
-  if (typeof symbol !== "string") return void 0;
-  const upper = symbol.toUpperCase();
-  return SUPPORTED_TOKENS.find((t) => t.symbol === upper);
-}
-
-// src/wallet/executors.ts
 function accountFor(provider, address, privateKeyHex) {
   return new starknet.Account({ provider, address, signer: privateKeyHex, cairoVersion: "1" });
 }
@@ -12921,7 +11028,7 @@ async function estimateSelfFundedFee(provider, address, calls) {
   return { feeRaw: estimate.overall_fee, unit: estimate.unit, balanceRaw };
 }
 async function feeTokenBalance(provider, address, unit) {
-  const token = getTokenBySymbol(unit === "FRI" ? "STRK" : "ETH");
+  const token = chunkZFRHADHR_cjs.getTokenBySymbol(unit === "FRI" ? "STRK" : "ETH");
   if (!token) throw new Error(`No fee token for unit ${unit}`);
   const [low = "0x0", high = "0x0"] = await provider.callContract({
     contractAddress: token.address,
@@ -12948,7 +11055,7 @@ function sponsoredExecutor(deps) {
         { proxyUrl: deps.proxyUrl, fetchImpl: deps.fetchImpl },
         {
           address: userAddress,
-          signTypedData: async (data) => signWithPrivateKey(privateKeyHex, starknet.typedData.getMessageHash(data, userAddress))
+          signTypedData: async (data) => chunkZFRHADHR_cjs.signWithPrivateKey(privateKeyHex, starknet.typedData.getMessageHash(data, userAddress))
         },
         calls
       );
@@ -12998,7 +11105,7 @@ async function deploySponsored(input) {
   return { transactionHash };
 }
 async function deploySelfFunded(input) {
-  const classHash = getCoordinates("STARKNET").mediaWalletClassHash;
+  const classHash = chunkOUPVVMLK_cjs.getCoordinates("STARKNET").mediaWalletClassHash;
   if (!classHash) throw new Error("Media Wallet class hash is not configured");
   const account = new starknet.Account({
     provider: input.provider,
@@ -13008,13 +11115,13 @@ async function deploySelfFunded(input) {
   });
   const { transaction_hash } = await account.deployAccount({
     classHash,
-    constructorCalldata: ownerConstructorCalldata(input.ownerPubKey),
+    constructorCalldata: chunkZFRHADHR_cjs.ownerConstructorCalldata(input.ownerPubKey),
     addressSalt: 0,
     contractAddress: input.ownerAddress
   });
   return { transactionHash: transaction_hash };
 }
-async function waitUntilDeployed(provider, address, timeoutMs = 9e4, sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+async function waitUntilDeployed(provider, address, timeoutMs = 9e4, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
   const deadline = Date.now() + timeoutMs;
   let wait = 1e3;
   for (; ; ) {
@@ -13024,7 +11131,7 @@ async function waitUntilDeployed(provider, address, timeoutMs = 9e4, sleep2 = (m
         "Your wallet was submitted but has not appeared on Starknet yet. Please try again in a moment."
       );
     }
-    await sleep2(wait);
+    await sleep(wait);
     wait = Math.min(Math.round(wait * 1.5), 5e3);
   }
 }
@@ -13071,7 +11178,7 @@ async function completeDeployment(deps, onStep, options = {}) {
     backendUrl: deps.backendUrl,
     walletAddress: address,
     signer: {
-      signMessage: async (td) => signWithPrivateKey(privateKeyHex, starknet.typedData.getMessageHash(td, address))
+      signMessage: async (td) => chunkZFRHADHR_cjs.signWithPrivateKey(privateKeyHex, starknet.typedData.getMessageHash(td, address))
     }
   });
   deps.store.notifyChange();
@@ -13176,7 +11283,7 @@ function createMediaWallet(config) {
         address: sealed.address,
         signTypedData: async (data) => {
           const privateKeyHex = await unlockOnce(sealed);
-          return signWithPrivateKey(privateKeyHex, starknet.typedData.getMessageHash(data, sealed.address));
+          return chunkZFRHADHR_cjs.signWithPrivateKey(privateKeyHex, starknet.typedData.getMessageHash(data, sealed.address));
         },
         execute: async (calls) => {
           const { transactionHash } = await run(sealed, calls);
@@ -13246,8 +11353,54 @@ async function claimSessionWallet(api, walletAddress, deps) {
   if (removeOwnerGuid) await deps.removeOwner(sealed, removeOwnerGuid);
 }
 
-exports.ADMIN_HEADERS = ADMIN_HEADERS;
-exports.ADMIN_SCOPE = ADMIN_SCOPE;
+Object.defineProperty(exports, "InvalidStarkPrivateKeyError", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.InvalidStarkPrivateKeyError; }
+});
+Object.defineProperty(exports, "PasskeyCancelledError", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.PasskeyCancelledError; }
+});
+Object.defineProperty(exports, "UserFacingError", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.UserFacingError; }
+});
+Object.defineProperty(exports, "computeAccountAddress", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.computeAccountAddress; }
+});
+Object.defineProperty(exports, "createPasskeyOwner", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.createPasskeyOwner; }
+});
+Object.defineProperty(exports, "deriveAesKey", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.deriveAesKey; }
+});
+Object.defineProperty(exports, "generateStarkKeyPair", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.generateStarkKeyPair; }
+});
+Object.defineProperty(exports, "ownerConstructorCalldata", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.ownerConstructorCalldata; }
+});
+Object.defineProperty(exports, "sealPrivateKey", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.sealPrivateKey; }
+});
+Object.defineProperty(exports, "signWithPrivateKey", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.signWithPrivateKey; }
+});
+Object.defineProperty(exports, "starkKeyPairFromPrivateKey", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.starkKeyPairFromPrivateKey; }
+});
+Object.defineProperty(exports, "unsealPrivateKey", {
+  enumerable: true,
+  get: function () { return chunkZFRHADHR_cjs.unsealPrivateKey; }
+});
 exports.COIN_MAX_SUPPLY = MAX_SUPPLY;
 exports.COIN_MIN_SUPPLY = MIN_SUPPLY;
 exports.ClubService = ClubService;
@@ -13271,7 +11424,6 @@ exports.IPTicketCollectionABI = IPTicketCollectionABI;
 exports.IPTicketCollectionFactoryABI = IPTicketCollectionFactoryABI;
 exports.InvalidPairingPayloadError = InvalidPairingPayloadError;
 exports.InvalidRecoveryKeyError = InvalidRecoveryKeyError;
-exports.InvalidStarkPrivateKeyError = InvalidStarkPrivateKeyError;
 exports.MAX_HOLDERS_AT_LAUNCH = MAX_HOLDERS_AT_LAUNCH;
 exports.MAX_TEAM_ALLOCATION_PERCENT = MAX_TEAM_ALLOCATION_PERCENT;
 exports.Medialane1155ABI = Medialane1155ABI;
@@ -13279,24 +11431,20 @@ exports.MedialaneClient = MedialaneClient;
 exports.MedialaneError = MedialaneError;
 exports.POPCollectionABI = POPCollectionABI;
 exports.POPFactoryABI = POPFactoryABI;
-exports.PasskeyCancelledError = PasskeyCancelledError;
 exports.PopService = PopService;
 exports.SUGGESTED_DEFAULT_PRICE = SUGGESTED_DEFAULT_PRICE;
 exports.SponsoredCallRejectedError = SponsoredCallRejectedError;
 exports.SponsorshipService = SponsorshipService;
 exports.StarknetVenue = StarknetVenue;
 exports.TicketService = TicketService;
-exports.UserFacingError = UserFacingError;
 exports.VALIDATED_EKUBO_PARAMS = VALIDATED_EKUBO_PARAMS;
 exports.accountFor = accountFor;
-exports.adminRequestDigest = adminRequestDigest;
 exports.adoptSessionWallet = adoptSessionWallet;
 exports.allowsFallbackFunding = allowsFallbackFunding;
 exports.assertTransactionSucceeded = assertTransactionSucceeded;
 exports.build1155CancellationTypedData = build1155CancellationTypedData;
 exports.build1155OrderTypedData = build1155OrderTypedData;
 exports.buildAddOwnerCall = buildAddOwnerCall;
-exports.buildAdminSessionTypedData = buildAdminSessionTypedData;
 exports.buildCancelEscapeCall = buildCancelEscapeCall;
 exports.buildCancellationTypedData = buildCancellationTypedData;
 exports.buildCompleteEscapeOwnerCall = buildCompleteEscapeOwnerCall;
@@ -13315,26 +11463,21 @@ exports.canRemoveDevice = canRemoveDevice;
 exports.claimSessionWallet = claimSessionWallet;
 exports.coinToRaw = toRaw;
 exports.completeDeployment = completeDeployment;
-exports.computeAccountAddress = computeAccountAddress;
 exports.computeOwnerGuid = computeOwnerGuid;
 exports.confirmIntentBestEffort = confirmIntentBestEffort;
-exports.createAdminSessionGrant = createAdminSessionGrant;
 exports.createDeploymentCoordinator = createDeploymentCoordinator;
 exports.createMediaWallet = createMediaWallet;
 exports.createOwnerStore = createOwnerStore;
-exports.createPasskeyOwner = createPasskeyOwner;
 exports.createSelfFundConsent = createSelfFundConsent;
 exports.decodeEscapeAndStatus = decodeEscapeAndStatus;
 exports.decodeGuardiansInfo = decodeGuardiansInfo;
 exports.deploySelfFunded = deploySelfFunded;
 exports.deploySponsored = deploySponsored;
 exports.deployedCollectionFromReceipt = deployedCollectionFromReceipt;
-exports.deriveAesKey = deriveAesKey;
 exports.deriveOwnerKeyPair = deriveOwnerKeyPair;
 exports.describeDevices = describeDevices;
 exports.describeGuardianStatus = describeGuardianStatus;
 exports.describeRecoveryAction = describeRecoveryAction;
-exports.encodeAdminHeaders = encodeAdminHeaders;
 exports.encodeByteArray = encodeByteArray;
 exports.encodePairingPayload = encodePairingPayload;
 exports.encodeRecoveryKey = encodeRecoveryKey;
@@ -13345,7 +11488,6 @@ exports.executeSponsored = executeSponsored;
 exports.fdvHuman = fdvHuman;
 exports.fundWithChainTransfer = fundWithChainTransfer;
 exports.fundingApiFor = fundingApiFor;
-exports.generateStarkKeyPair = generateStarkKeyPair;
 exports.getCounter = getCounter;
 exports.getCounter1155 = getCounter1155;
 exports.getCreatorCoinGuarantees = getCreatorCoinGuarantees;
@@ -13363,32 +11505,22 @@ exports.isValidStarknetAddress = isValidStarknetAddress;
 exports.mintedTokenIdFromReceipt = mintedTokenIdFromReceipt;
 exports.normalizeSiwsSignature = normalizeSiwsSignature;
 exports.normalizeWalletAddress = normalizeWalletAddress;
-exports.ownerConstructorCalldata = ownerConstructorCalldata;
 exports.parseAccountAddress = parseAccountAddress;
-exports.parseAdminHeaders = parseAdminHeaders;
 exports.parseCreatorCoinCreated = parseCreatorCoinCreated;
 exports.parsePairingPayload = parsePairingPayload;
 exports.parseRecoveryKey = parseRecoveryKey;
 exports.priceToEkuboParams = priceToEkuboParams;
-exports.randomNonce = randomNonce;
 exports.requestSiwsToken = requestSiwsToken;
-exports.sealPrivateKey = sealPrivateKey;
 exports.selfFundedExecutor = selfFundedExecutor;
-exports.sessionKeyHashOf = sessionKeyHashOf;
-exports.signAdminRequest = signAdminRequest;
-exports.signWithPrivateKey = signWithPrivateKey;
 exports.sponsoredExecutor = sponsoredExecutor;
-exports.starkKeyPairFromPrivateKey = starkKeyPairFromPrivateKey;
 exports.storeSiwsToken = storeSiwsToken;
 exports.syncTransactionBestEffort = syncTransactionBestEffort;
 exports.teamCoinsRaw = teamCoinsRaw;
 exports.toDropContractConditions = toContractConditions;
-exports.unsealPrivateKey = unsealPrivateKey;
 exports.validateCoinName = validateName;
 exports.validateCoinSupply = validateSupply;
 exports.validateCoinSymbol = validateSymbol;
 exports.validatePrice = validatePrice;
-exports.verifyAdminRequestSig = verifyAdminRequestSig;
 exports.waitUntilDeployed = waitUntilDeployed;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map