@medialane/sdk 0.155.0 → 0.156.0

package/dist/chunk-ZFRHADHR.cjs

@@ -0,0 +1,1854 @@
+'use strict';
+
+var chunkOUPVVMLK_cjs = require('./chunk-OUPVVMLK.cjs');
+var zod = require('zod');
+var sha3_js = require('@noble/hashes/sha3.js');
+var base = require('@scure/base');
+var starknet = require('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/fee/app-config.ts
+var DEFAULT_BPS = 100;
+function bps(raw) {
+  if (!raw) return DEFAULT_BPS;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : DEFAULT_BPS;
+}
+function resolveAppFeeConfig(env = {}) {
+  return resolveFeeConfig({
+    enabled: env.NEXT_PUBLIC_FEE_ENABLED !== "false",
+    fundAddress: env.NEXT_PUBLIC_FEE_FUND_ADDRESS || void 0,
+    marketplaceBps: bps(env.NEXT_PUBLIC_FEE_MARKETPLACE_BPS),
+    launchpadBps: bps(env.NEXT_PUBLIC_FEE_LAUNCHPAD_BPS)
+  });
+}
+var MedialaneConfigSchema = zod.z.object({
+  chain: zod.z.enum(chunkOUPVVMLK_cjs.CHAINS).default(chunkOUPVVMLK_cjs.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 = chunkOUPVVMLK_cjs.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 hash2 = sha3_js.keccak_256(new TextEncoder().encode(lower));
+  let out = "0x";
+  for (let i = 0; i < 40; i++) {
+    const nibble = hash2[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;
+}
+function normalizeHash(hash2) {
+  try {
+    const hex = BigInt(hash2).toString(16);
+    return "0x" + hex.padStart(64, "0").toLowerCase();
+  } catch {
+    throw new Error(`Invalid hash: "${hash2}"`);
+  }
+}
+function shortenAddress(chain, address, chars = 4) {
+  const norm = normalizeAddress(chain, address);
+  return `${norm.slice(0, chars + 2)}...${norm.slice(-chars)}`;
+}
+
+// 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 != null && !(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) });
+  }
+  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)
+    });
+  }
+  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;
+  }
+};
+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/constants.ts
+var SN = chunkOUPVVMLK_cjs.getCoordinates("STARKNET");
+var STARKNET_MARKETPLACE_721_CONTRACT = SN.marketplace721;
+var STARKNET_MARKETPLACE_721_CLASS_HASH = SN.marketplace721ClassHash;
+var STARKNET_MARKETPLACE_721_START_BLOCK = SN.marketplace721StartBlock;
+var STARKNET_MARKETPLACE_1155_CONTRACT = SN.marketplace1155;
+var STARKNET_MARKETPLACE_1155_CLASS_HASH = SN.marketplace1155ClassHash;
+var STARKNET_MARKETPLACE_1155_START_BLOCK = SN.marketplace1155StartBlock;
+var STARKNET_COLLECTION_721_CONTRACT = SN.collection721;
+var STARKNET_DATA_TOKENIZATION_721_CONTRACT = SN.dataTokenization721;
+var STARKNET_COLLECTION_721_START_BLOCK = SN.collection721StartBlock;
+var STARKNET_IPNFT_CLASS_HASH = SN.ipNftClassHash;
+var STARKNET_IPCOLLECTION_CLASS_HASH = SN.ipCollectionClassHash;
+var STARKNET_COLLECTION_1155_CONTRACT = SN.collection1155;
+var STARKNET_COLLECTION_1155_FACTORY_CLASS_HASH = SN.collection1155FactoryClassHash;
+var STARKNET_COLLECTION_1155_CLASS_HASH = SN.collection1155ClassHash;
+var STARKNET_COLLECTION_1155_START_BLOCK = SN.collection1155StartBlock;
+var STARKNET_POP_FACTORY_CONTRACT = SN.popFactory;
+var STARKNET_POP_COLLECTION_CLASS_HASH = SN.popCollectionClassHash;
+var STARKNET_DROP_FACTORY_CONTRACT = SN.dropFactory;
+var STARKNET_DROP_COLLECTION_CLASS_HASH = SN.dropCollectionClassHash;
+var STARKNET_NFTCOMMENTS_CONTRACT = SN.nftComments;
+var STARKNET_IP_TICKETS_FACTORY_CONTRACT = SN.ipTicketsFactory;
+var STARKNET_IP_TICKET_COLLECTION_CLASS_HASH = SN.ipTicketCollectionClassHash;
+var STARKNET_IP_CLUB_FACTORY_CONTRACT = SN.ipClubFactory;
+var STARKNET_IP_CLUB_COLLECTION_CLASS_HASH = SN.ipClubCollectionClassHash;
+var STARKNET_IP_SPONSORSHIP_CONTRACT = SN.ipSponsorship;
+var STARKNET_IP_SPONSORSHIP_CLASS_HASH = SN.ipSponsorshipClassHash;
+var STARKNET_MEDIAWALLET_CLASS_HASH = SN.mediaWalletClassHash;
+var STARKNET_CREATOR_COIN_FACTORY_CONTRACT = SN.creatorCoinFactory;
+var STARKNET_CREATOR_COIN_EKUBO_LAUNCHER = SN.creatorCoinEkuboLauncher;
+var STARKNET_CREATOR_COIN_CLASS_HASH = SN.creatorCoinClassHash;
+var STARKNET_CREATOR_COIN_FACTORY_CLASS_HASH = SN.creatorCoinFactoryClassHash;
+var STARKNET_CREATOR_COIN_START_BLOCK = SN.creatorCoinStartBlock;
+var STARKNET_GENESIS_MINT_CONTRACT = SN.genesisMint;
+var STARKNET_GENESIS_NFT_URI = "ipfs://bafkreiag6wzov7migmxwx3wrtudvbx4ajrlbjopqw7uni7nn2nsxv4eykm";
+var STARKNET_EKUBO_CORE = 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
+  }
+];
+var DEFAULT_CURRENCY = "USDC";
+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
+  );
+}
+
+// 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/services/registry.ts
+var SN2 = chunkOUPVVMLK_cjs.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 isServiceId(id) {
+  return typeof id === "string" && id in SERVICES;
+}
+function getService(id) {
+  return id && id in SERVICES ? SERVICES[id] : void 0;
+}
+function listServices() {
+  return Object.values(SERVICES);
+}
+function getServicesByCapability(cap) {
+  return Object.values(SERVICES).filter(
+    (s) => s.capabilities.includes(cap)
+  );
+}
+function hasCapability(id, cap) {
+  return getService(id)?.capabilities.includes(cap) ?? false;
+}
+
+// src/utils/token.ts
+function parseAmount(human, decimals) {
+  const [whole, frac = ""] = human.split(".");
+  const fracPadded = frac.padEnd(decimals, "0").slice(0, decimals);
+  return (BigInt(whole) * BigInt(10) ** BigInt(decimals) + BigInt(fracPadded)).toString();
+}
+function formatAmount(raw, decimals) {
+  const value = BigInt(raw);
+  const factor = 10n ** BigInt(decimals);
+  const whole = value / factor;
+  const remainder = value % factor;
+  const fractional = remainder.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return fractional ? `${whole}.${fractional}` : whole.toString();
+}
+function getTokenByAddress(address) {
+  if (typeof address !== "string" || address.trim() === "") return void 0;
+  let target = null;
+  try {
+    target = BigInt(address);
+  } catch {
+    target = null;
+  }
+  return SUPPORTED_TOKENS.find((t) => {
+    if (target !== null) {
+      try {
+        return BigInt(t.address) === target;
+      } catch {
+      }
+    }
+    return t.address.toLowerCase() === address.toLowerCase();
+  });
+}
+function getTokenBySymbol(symbol) {
+  if (typeof symbol !== "string") return void 0;
+  const upper = symbol.toUpperCase();
+  return SUPPORTED_TOKENS.find((t) => t.symbol === upper);
+}
+function getListableTokens() {
+  return SUPPORTED_TOKENS.filter((t) => t.listable);
+}
+
+// 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;
+}
+function u256ToBigInt(low, high) {
+  return BigInt(low) + (BigInt(high) << 128n);
+}
+function encodeU256(n) {
+  return [
+    (n & 0xffffffffffffffffffffffffffffffffn).toString(),
+    (n >> 128n).toString()
+  ];
+}
+
+// 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/errors.ts
+var UserFacingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserFacingError";
+  }
+};
+
+exports.ApiClient = ApiClient;
+exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
+exports.FeeConfigSchema = FeeConfigSchema;
+exports.InvalidStarkPrivateKeyError = InvalidStarkPrivateKeyError;
+exports.MedialaneApiError = MedialaneApiError;
+exports.POLICY_REFUSAL_CODES = POLICY_REFUSAL_CODES;
+exports.PasskeyCancelledError = PasskeyCancelledError;
+exports.STARKNET_COLLECTION_1155_CLASS_HASH = STARKNET_COLLECTION_1155_CLASS_HASH;
+exports.STARKNET_COLLECTION_1155_CONTRACT = STARKNET_COLLECTION_1155_CONTRACT;
+exports.STARKNET_COLLECTION_1155_FACTORY_CLASS_HASH = STARKNET_COLLECTION_1155_FACTORY_CLASS_HASH;
+exports.STARKNET_COLLECTION_1155_START_BLOCK = STARKNET_COLLECTION_1155_START_BLOCK;
+exports.STARKNET_COLLECTION_721_CONTRACT = STARKNET_COLLECTION_721_CONTRACT;
+exports.STARKNET_COLLECTION_721_START_BLOCK = STARKNET_COLLECTION_721_START_BLOCK;
+exports.STARKNET_CREATOR_COIN_CLASS_HASH = STARKNET_CREATOR_COIN_CLASS_HASH;
+exports.STARKNET_CREATOR_COIN_EKUBO_LAUNCHER = STARKNET_CREATOR_COIN_EKUBO_LAUNCHER;
+exports.STARKNET_CREATOR_COIN_FACTORY_CLASS_HASH = STARKNET_CREATOR_COIN_FACTORY_CLASS_HASH;
+exports.STARKNET_CREATOR_COIN_FACTORY_CONTRACT = STARKNET_CREATOR_COIN_FACTORY_CONTRACT;
+exports.STARKNET_CREATOR_COIN_START_BLOCK = STARKNET_CREATOR_COIN_START_BLOCK;
+exports.STARKNET_DATA_TOKENIZATION_721_CONTRACT = STARKNET_DATA_TOKENIZATION_721_CONTRACT;
+exports.STARKNET_DROP_COLLECTION_CLASS_HASH = STARKNET_DROP_COLLECTION_CLASS_HASH;
+exports.STARKNET_DROP_FACTORY_CONTRACT = STARKNET_DROP_FACTORY_CONTRACT;
+exports.STARKNET_EKUBO_CORE = STARKNET_EKUBO_CORE;
+exports.STARKNET_GENESIS_MINT_CONTRACT = STARKNET_GENESIS_MINT_CONTRACT;
+exports.STARKNET_GENESIS_NFT_URI = STARKNET_GENESIS_NFT_URI;
+exports.STARKNET_IPCOLLECTION_CLASS_HASH = STARKNET_IPCOLLECTION_CLASS_HASH;
+exports.STARKNET_IPNFT_CLASS_HASH = STARKNET_IPNFT_CLASS_HASH;
+exports.STARKNET_IP_CLUB_COLLECTION_CLASS_HASH = STARKNET_IP_CLUB_COLLECTION_CLASS_HASH;
+exports.STARKNET_IP_CLUB_FACTORY_CONTRACT = STARKNET_IP_CLUB_FACTORY_CONTRACT;
+exports.STARKNET_IP_SPONSORSHIP_CLASS_HASH = STARKNET_IP_SPONSORSHIP_CLASS_HASH;
+exports.STARKNET_IP_SPONSORSHIP_CONTRACT = STARKNET_IP_SPONSORSHIP_CONTRACT;
+exports.STARKNET_IP_TICKETS_FACTORY_CONTRACT = STARKNET_IP_TICKETS_FACTORY_CONTRACT;
+exports.STARKNET_IP_TICKET_COLLECTION_CLASS_HASH = STARKNET_IP_TICKET_COLLECTION_CLASS_HASH;
+exports.STARKNET_MARKETPLACE_1155_CLASS_HASH = STARKNET_MARKETPLACE_1155_CLASS_HASH;
+exports.STARKNET_MARKETPLACE_1155_CONTRACT = STARKNET_MARKETPLACE_1155_CONTRACT;
+exports.STARKNET_MARKETPLACE_1155_START_BLOCK = STARKNET_MARKETPLACE_1155_START_BLOCK;
+exports.STARKNET_MARKETPLACE_721_CLASS_HASH = STARKNET_MARKETPLACE_721_CLASS_HASH;
+exports.STARKNET_MARKETPLACE_721_CONTRACT = STARKNET_MARKETPLACE_721_CONTRACT;
+exports.STARKNET_MARKETPLACE_721_START_BLOCK = STARKNET_MARKETPLACE_721_START_BLOCK;
+exports.STARKNET_MEDIAWALLET_CLASS_HASH = STARKNET_MEDIAWALLET_CLASS_HASH;
+exports.STARKNET_NFTCOMMENTS_CONTRACT = STARKNET_NFTCOMMENTS_CONTRACT;
+exports.STARKNET_POP_COLLECTION_CLASS_HASH = STARKNET_POP_COLLECTION_CLASS_HASH;
+exports.STARKNET_POP_FACTORY_CONTRACT = STARKNET_POP_FACTORY_CONTRACT;
+exports.SUPPORTED_TOKENS = SUPPORTED_TOKENS;
+exports.UserFacingError = UserFacingError;
+exports.computeAccountAddress = computeAccountAddress;
+exports.createFailoverFetch = createFailoverFetch;
+exports.createPasskeyOwner = createPasskeyOwner;
+exports.deriveAesKey = deriveAesKey;
+exports.encodeU256 = encodeU256;
+exports.formatAmount = formatAmount;
+exports.generateStarkKeyPair = generateStarkKeyPair;
+exports.getListableTokens = getListableTokens;
+exports.getService = getService;
+exports.getServicesByCapability = getServicesByCapability;
+exports.getTokenByAddress = getTokenByAddress;
+exports.getTokenBySymbol = getTokenBySymbol;
+exports.hasCapability = hasCapability;
+exports.isPolicyRefusal = isPolicyRefusal;
+exports.isServiceId = isServiceId;
+exports.isTransientRpcError = isTransientRpcError;
+exports.listServices = listServices;
+exports.normalizeAddress = normalizeAddress;
+exports.normalizeHash = normalizeHash;
+exports.ownerConstructorCalldata = ownerConstructorCalldata;
+exports.parseAmount = parseAmount;
+exports.resolveAppFeeConfig = resolveAppFeeConfig;
+exports.resolveConfig = resolveConfig;
+exports.resolveFeeConfig = resolveFeeConfig;
+exports.sealPrivateKey = sealPrivateKey;
+exports.shortenAddress = shortenAddress;
+exports.signWithPrivateKey = signWithPrivateKey;
+exports.starkKeyPairFromPrivateKey = starkKeyPairFromPrivateKey;
+exports.stringifyBigInts = stringifyBigInts;
+exports.u256ToBigInt = u256ToBigInt;
+exports.unsealPrivateKey = unsealPrivateKey;
+//# sourceMappingURL=chunk-ZFRHADHR.cjs.map
+//# sourceMappingURL=chunk-ZFRHADHR.cjs.map