@medialane/sdk 0.198.0 → 0.200.0

package/dist/chunk-KGAGWULG.js

@@ -0,0 +1,932 @@
+import { getCoordinates } from './chunk-5KY6P434.js';
+import { intentPath, dropStateFromWire } from './chunk-WRBXQPRL.js';
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { base58, base32 } from '@scure/base';
+
+// src/errors.ts
+var UserFacingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserFacingError";
+  }
+};
+var MedialaneError = class extends Error {
+  constructor(message, code = "UNKNOWN", cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "MedialaneError";
+  }
+};
+var RESOURCE_NOT_FOUND = [
+  ["/v1/orders", "ORDER_NOT_FOUND"],
+  ["/v1/tokens", "TOKEN_NOT_FOUND"],
+  ["/v1/collections", "COLLECTION_NOT_FOUND"],
+  ["/v1/intents", "INTENT_NOT_FOUND"]
+];
+function errorCodeFor(status, path = "") {
+  if (status === 404) {
+    return RESOURCE_NOT_FOUND.find(([prefix]) => path.startsWith(prefix))?.[1] ?? "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 MedialaneError {
+  constructor(status, message, retryAfterMs, details, path, serverCode) {
+    super(message, errorCodeFor(status, path));
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+    this.details = details;
+    this.serverCode = serverCode;
+    this.name = "MedialaneApiError";
+  }
+};
+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;
+}
+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 hash = keccak_256(new TextEncoder().encode(lower));
+  let out = "0x";
+  for (let i = 0; i < 40; i++) {
+    const nibble = hash[i >> 1] >> (i % 2 === 0 ? 4 : 0) & 15;
+    out += nibble >= 8 ? lower[i].toUpperCase() : lower[i];
+  }
+  return out;
+}
+function normalizeSolana(address) {
+  try {
+    const bytes = base58.decode(address);
+    if (bytes.length !== 32) throw new Error("not a 32-byte key");
+    return address;
+  } catch {
+    throw new Error(`Invalid SOLANA address: "${address}"`);
+  }
+}
+var STELLAR_VERSION_BYTES = /* @__PURE__ */ new Set([6 << 3, 2 << 3]);
+function normalizeStellar(address) {
+  const upper = address.toUpperCase();
+  if (!/^[GC][A-Z2-7]{55}$/.test(upper)) {
+    throw new Error(`Invalid STELLAR address: "${address}"`);
+  }
+  let decoded;
+  try {
+    decoded = base32.decode(upper);
+  } catch {
+    throw new Error(`Invalid STELLAR address: "${address}"`);
+  }
+  if (decoded.length !== 35 || !STELLAR_VERSION_BYTES.has(decoded[0])) {
+    throw new Error(`Invalid STELLAR address: "${address}"`);
+  }
+  const payload = decoded.subarray(0, 33);
+  const checksum = decoded[33] | decoded[34] << 8;
+  if (crc16xmodem(payload) !== checksum) {
+    throw new Error(`Invalid STELLAR address: "${address}"`);
+  }
+  return upper;
+}
+function crc16xmodem(bytes) {
+  let crc = 0;
+  for (const byte of bytes) {
+    crc ^= byte << 8;
+    for (let i = 0; i < 8; i++) {
+      crc = crc & 32768 ? (crc << 1 ^ 4129) & 65535 : crc << 1 & 65535;
+    }
+  }
+  return crc;
+}
+function normalizeHash(hash) {
+  try {
+    const hex = BigInt(hash).toString(16);
+    return "0x" + hex.padStart(64, "0").toLowerCase();
+  } catch {
+    throw new Error(`Invalid hash: "${hash}"`);
+  }
+}
+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/transport.ts
+function queryString(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0 && value !== null && value !== "") params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
+async function failureFrom(response, path) {
+  const text = await response.text().catch(() => response.statusText);
+  let message = `Request failed with status ${response.status}`;
+  let details = text;
+  let serverCode;
+  try {
+    const body = JSON.parse(text);
+    if (typeof body.error === "string" && body.error.trim() !== "") message = body.error;
+    if (typeof body.code === "string") serverCode = body.code;
+    details = body;
+  } catch {
+    details = text;
+  }
+  return new MedialaneApiError(
+    response.status,
+    message,
+    parseRetryAfter(response.headers.get("retry-after")),
+    details,
+    path,
+    serverCode
+  );
+}
+var Transport = class _Transport {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.headers = options.apiKey ? { "x-api-key": options.apiKey } : {};
+    this.chain = options.chain ?? "STARKNET";
+  }
+  withBearer(bearer) {
+    return new _Transport({ ...this.options, bearer });
+  }
+  settings() {
+    return this.options;
+  }
+  addr(address) {
+    return normalizeAddress(this.chain, address);
+  }
+  async request(path, opts = {}) {
+    const method = opts.method ?? "GET";
+    const url = `${this.baseUrl}${path}${queryString(opts.query)}`;
+    const headers = { ...this.headers };
+    const token = opts.bearer ?? this.defaultBearer();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    let body;
+    if (opts.body instanceof FormData) {
+      body = opts.body;
+    } else if (opts.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(opts.body);
+    }
+    const absent = (status) => opts.absent?.includes(status) === true;
+    const response = await withRetry(
+      async () => {
+        const res = await (this.options.fetch ?? globalThis.fetch)(url, { method, headers, body });
+        if (!res.ok && !absent(res.status)) throw await failureFrom(res, path);
+        return res;
+      },
+      this.options.retry,
+      method
+    );
+    if (absent(response.status)) return null;
+    return response.json();
+  }
+  get(path, query) {
+    return this.request(path, { query });
+  }
+  post(path, body, opts = {}) {
+    return this.request(path, { ...opts, method: "POST", body: body ?? {} });
+  }
+  patch(path, body, opts = {}) {
+    return this.request(path, { ...opts, method: "PATCH", body });
+  }
+  delete(path, body, opts = {}) {
+    return this.request(path, { ...opts, method: "DELETE", body });
+  }
+  find(path, opts = {}) {
+    const { also, ...rest } = opts;
+    return this.request(path, { ...rest, absent: [404, ...also ?? []] });
+  }
+  defaultBearer() {
+    const source = this.options.bearer;
+    return typeof source === "function" ? source() : source;
+  }
+};
+
+// src/api/domains/orders.ts
+function createOrdersApi(t) {
+  return {
+    list(query = {}) {
+      return t.get("/v1/orders", {
+        status: query.status,
+        collection: query.collection,
+        currency: query.currency,
+        sort: query.sort,
+        page: query.page,
+        limit: query.limit,
+        offerer: query.offerer ? t.addr(query.offerer) : void 0,
+        minPrice: query.minPrice,
+        maxPrice: query.maxPrice,
+        chain: query.chain
+      });
+    },
+    async get(orderHash) {
+      return (await t.get(`/v1/orders/${orderHash}`)).data;
+    },
+    forToken(contract, tokenId) {
+      return t.get(`/v1/orders/token/${t.addr(contract)}/${tokenId}`);
+    },
+    receivedBy(address, opts = {}) {
+      return t.get(`/v1/orders/received/${t.addr(address)}`, { page: opts.page ?? 1, limit: opts.limit ?? 50 });
+    },
+    byUser(address, opts = {}) {
+      return t.get(`/v1/orders/user/${t.addr(address)}`, { page: opts.page ?? 1, limit: opts.limit ?? 20 });
+    },
+    counterOffers(query) {
+      return t.get("/v1/orders/counter-offers", {
+        originalOrderHash: query.originalOrderHash,
+        sellerAddress: query.sellerAddress,
+        page: query.page,
+        limit: query.limit
+      });
+    }
+  };
+}
+
+// src/api/domains/tokens.ts
+function createTokensApi(t) {
+  return {
+    list(query = {}) {
+      return t.get("/v1/tokens", {
+        page: query.page,
+        limit: query.limit,
+        sort: query.sort,
+        ipType: query.ipType,
+        derivatives: query.derivatives
+      });
+    },
+    async get(contract, tokenId, opts = {}) {
+      const res = await t.get(`/v1/tokens/${contract}/${tokenId}`, opts.wait ? { wait: "true" } : void 0);
+      return res.data;
+    },
+    async balance(contract, tokenId, owner) {
+      return (await t.get(`/v1/tokens/${contract}/${tokenId}/balances/${t.addr(owner)}`)).data;
+    },
+    ownedBy(address, opts = {}) {
+      return t.get(`/v1/tokens/owned/${t.addr(address)}`, { page: opts.page ?? 1, limit: opts.limit ?? 20 });
+    },
+    history(contract, tokenId, opts = {}) {
+      return t.get(`/v1/tokens/${contract}/${tokenId}/history`, { page: opts.page ?? 1, limit: opts.limit ?? 20 });
+    },
+    comments(contract, tokenId, opts = {}) {
+      return t.get(`/v1/tokens/${t.addr(contract)}/${tokenId}/comments`, { page: opts.page, limit: opts.limit });
+    },
+    remixes(contract, tokenId, opts = {}) {
+      return t.get(`/v1/tokens/${t.addr(contract)}/${tokenId}/remixes`, { page: opts.page, limit: opts.limit });
+    }
+  };
+}
+
+// src/api/domains/collections.ts
+var slugOf = (slug) => encodeURIComponent(slug.toLowerCase().trim());
+function createCollectionsApi(t) {
+  return {
+    list(query = {}) {
+      return t.get("/v1/collections", {
+        page: query.page,
+        limit: query.limit,
+        owner: query.owner ? t.addr(query.owner) : void 0,
+        service: query.service,
+        sort: query.sort,
+        isFeatured: query.isFeatured,
+        hideEmpty: query.hideEmpty,
+        standard: query.standard,
+        chain: query.chain
+      });
+    },
+    async get(contract) {
+      return (await t.get(`/v1/collections/${t.addr(contract)}`)).data;
+    },
+    async findBySlug(slug) {
+      const res = await t.find(`/v1/collections/by-slug/${slugOf(slug)}`);
+      return res?.data ?? null;
+    },
+    tokens(contract, opts = {}) {
+      return t.get(`/v1/collections/${t.addr(contract)}/tokens`, {
+        page: opts.page ?? 1,
+        limit: opts.limit ?? 20,
+        sort: opts.sort ?? "recent"
+      });
+    },
+    async register(contractAddress) {
+      return (await t.post("/v1/collections/register", { contractAddress })).data;
+    },
+    findProfile(contractAddress) {
+      return t.find(`/v1/collections/${t.addr(contractAddress)}/profile`);
+    },
+    updateProfile(contractAddress, data) {
+      return t.patch(`/v1/collections/${t.addr(contractAddress)}/profile`, data);
+    },
+    findGatedContent(contractAddress) {
+      return t.find(`/v1/collections/${t.addr(contractAddress)}/gated-content`, { also: [403] });
+    },
+    claim(contractAddress, walletAddress) {
+      return t.post("/v1/collections/claim", { contractAddress, walletAddress });
+    },
+    requestClaim(params) {
+      return t.post("/v1/collections/claim/request", params);
+    },
+    slugAvailability(slug) {
+      return t.get(`/v1/collection-slug-claims/check/${slugOf(slug)}`);
+    },
+    submitSlugClaim(contractAddress, slug, notifyEmail) {
+      return t.post("/v1/collection-slug-claims", { contractAddress, slug, notifyEmail });
+    },
+    mySlugClaims() {
+      return t.get("/v1/collection-slug-claims/me");
+    }
+  };
+}
+
+// src/api/domains/activity.ts
+function createActivityApi(t) {
+  return {
+    list(query = {}) {
+      return t.get("/v1/activities", {
+        type: query.type,
+        contract: query.contract,
+        page: query.page,
+        limit: query.limit,
+        chain: query.chain
+      });
+    },
+    byAddress(address, opts = {}) {
+      return t.get(`/v1/activities/${t.addr(address)}`, { page: opts.page ?? 1, limit: opts.limit ?? 20 });
+    },
+    wallet(address, chain = "STARKNET") {
+      return t.get("/v1/wallet-activity", { address: t.addr(address), chain });
+    }
+  };
+}
+function createSearchApi(t) {
+  return (q, limit = 10, chain) => t.get("/v1/search", { q, limit, chain });
+}
+
+// src/api/domains/intents.ts
+function createIntentsApi(t) {
+  return {
+    async create(kind, params, opts) {
+      const res = await t.post(intentPath(kind), params, { bearer: opts?.bearer });
+      return res.data;
+    },
+    async checkout(params) {
+      const res = await t.post(intentPath("checkout"), params);
+      return res.data;
+    },
+    async get(id) {
+      return (await t.get(`/v1/intents/${id}`)).data;
+    },
+    async submitSignature(id, signature) {
+      return (await t.patch(`/v1/intents/${id}/signature`, { signature })).data;
+    },
+    async confirm(id, txHash) {
+      return (await t.patch(`/v1/intents/${id}/confirm`, { txHash })).data;
+    },
+    async syncTransaction(txHash) {
+      return (await t.post("/v1/tx/sync", { txHash })).data;
+    }
+  };
+}
+
+// src/api/domains/metadata.ts
+function createMetadataApi(t) {
+  return {
+    signedUrl(kind) {
+      return t.get("/v1/metadata/signed-url", { kind });
+    },
+    upload(metadata) {
+      return t.post("/v1/metadata/upload", metadata);
+    },
+    async uploadDirectory(files) {
+      return (await t.post("/v1/metadata/upload-directory", { files })).data;
+    },
+    resolve(uri) {
+      return t.get("/v1/metadata/resolve", { uri });
+    },
+    uploadFile(file) {
+      const formData = new FormData();
+      formData.append("file", file);
+      return t.request("/v1/metadata/upload-file", { method: "POST", body: formData });
+    }
+  };
+}
+
+// src/api/domains/creators.ts
+function createCreatorsApi(t) {
+  return {
+    list(opts = {}) {
+      return t.get("/v1/creators", { search: opts.search, page: opts.page || void 0, limit: opts.limit || void 0 });
+    },
+    findProfile(walletAddress) {
+      return t.find(`/v1/creators/${t.addr(walletAddress)}/profile`);
+    },
+    findByUsername(username) {
+      return t.find(`/v1/creators/by-username/${encodeURIComponent(username.toLowerCase().trim())}`);
+    },
+    updateProfile(walletAddress, data) {
+      return t.patch(`/v1/creators/${t.addr(walletAddress)}/profile`, data);
+    },
+    async isHidden(wallet) {
+      return (await t.get(`/v1/creators/${t.addr(wallet)}/hidden`)).isHidden;
+    },
+    myUsernameClaim() {
+      return t.get("/v1/username-claims/me");
+    },
+    usernameAvailability(username) {
+      return t.get(`/v1/username-claims/check/${encodeURIComponent(username)}`);
+    },
+    async submitUsernameClaim(username, notifyEmail) {
+      const res = await t.post("/v1/username-claims", {
+        username,
+        ...notifyEmail ? { notifyEmail } : {}
+      });
+      return res.claim;
+    }
+  };
+}
+
+// src/api/domains/account.ts
+function createAccountApi(t) {
+  return {
+    registerUser(params) {
+      return t.post("/v1/users/register", params);
+    },
+    upsertMyWallet(options = {}) {
+      const body = { walletType: options.walletType ?? "UNKNOWN" };
+      if (options.chain) body.chain = options.chain;
+      if (options.email) body.email = options.email;
+      return t.post("/v1/users/me", body);
+    },
+    findMyWallet() {
+      return t.find("/v1/users/me");
+    },
+    changeMyEmail(email) {
+      return t.post("/v1/users/me/email", { email });
+    },
+    async sessionWallet() {
+      const body = await t.post("/v1/users/me/wallet", {});
+      return body.walletAddress ? { walletAddress: body.walletAddress, needsKeySetup: body.needsKeySetup === true } : null;
+    },
+    setupWalletKey(params) {
+      return t.post("/v1/users/me/wallet/key", params);
+    },
+    generateWallet(newWalletSiwsToken) {
+      return t.post("/v1/users/me/generate-wallet", { newWalletSiwsToken });
+    },
+    async emailExists(email) {
+      return (await t.get("/v1/auth/email/exists", { email })).exists;
+    },
+    async requestEmailCode(email) {
+      await t.post("/v1/auth/email/request-code", { email });
+    },
+    async registerEmailAccount(email) {
+      await t.post("/v1/auth/email/register-account", { email });
+    },
+    async verifyEmailCode(email, code) {
+      await t.post("/v1/auth/email/verify-code", { email, code });
+    },
+    async confirmEmail(token) {
+      const body = await t.post("/v1/auth/email/confirm", { token });
+      return { email: body.email };
+    }
+  };
+}
+
+// src/api/domains/portal.ts
+function createPortalApi(t) {
+  const data = async (promise) => (await promise).data;
+  const fundingPath = (id) => `/v1/portal/funding/${encodeURIComponent(id)}`;
+  return {
+    me: () => data(t.get("/v1/portal/me")),
+    apiKeys: () => data(t.get("/v1/portal/keys")),
+    createApiKey: (input, confirmation) => data(t.post("/v1/portal/keys", { ...input ?? {}, confirmation })),
+    deleteApiKey: (id, confirmation) => data(t.delete(`/v1/portal/keys/${id}`, { confirmation })),
+    creditHistory: () => data(t.get("/v1/portal/credits/history")),
+    spend: () => data(t.get("/v1/portal/credits/spend")),
+    checkDeposit: (txHash) => data(t.post("/v1/portal/credits/check", { txHash })),
+    pricing: () => t.get("/v1/pricing"),
+    funding: {
+      methods: () => data(t.get("/v1/portal/funding/methods")),
+      create: (input) => data(t.post("/v1/portal/funding", { method: input.method, params: input.params })),
+      get: (id) => data(t.get(fundingPath(id))),
+      challenge: (id, payer) => data(t.post(`${fundingPath(id)}/challenge`, { payer })),
+      authorize: (id, input) => data(t.post(`${fundingPath(id)}/authorize`, { payer: input.payer, signature: input.signature })),
+      submit: (id, txHash) => data(t.post(`${fundingPath(id)}/submit`, { txHash })),
+      cancel: (id) => data(t.post(`${fundingPath(id)}/cancel`, {}))
+    }
+  };
+}
+
+// src/api/domains/business.ts
+function createBusinessApi(t) {
+  return {
+    async emit(params) {
+      return (await t.post("/v1/business/issuance/emission", params)).data;
+    },
+    registerProvisioning(params) {
+      return t.post("/v1/business/provisioning", { chain: params.chain ?? "STARKNET", email: params.email });
+    }
+  };
+}
+
+// src/api/domains/remix.ts
+function createRemixApi(t) {
+  const one = async (promise) => (await promise).data;
+  return {
+    submit: (params) => one(t.post("/v1/remix-offers", params)),
+    submitAuto: (params) => one(t.post("/v1/remix-offers/auto", params)),
+    confirmSelf: (params) => one(t.post("/v1/remix-offers/self/confirm", params)),
+    list: (query) => t.get("/v1/remix-offers", { role: query.role, status: query.status, page: query.page, limit: query.limit }),
+    get: (id) => one(t.get(`/v1/remix-offers/${id}`)),
+    confirm: (id, params) => one(t.post(`/v1/remix-offers/${id}/confirm`, params)),
+    reject: (id) => one(t.post(`/v1/remix-offers/${id}/reject`, {})),
+    extend: (id, days) => one(t.post(`/v1/remix-offers/${id}/extend`, { days }))
+  };
+}
+
+// src/api/domains/coins.ts
+function createCoinsApi(t) {
+  return {
+    list(opts = {}) {
+      return t.get("/v1/coins", {
+        page: opts.page || void 0,
+        limit: opts.limit || void 0,
+        service: opts.service,
+        sort: opts.sort,
+        creator: opts.creator ? t.addr(opts.creator) : void 0,
+        chain: opts.chain
+      });
+    },
+    async get(contract) {
+      return (await t.get(`/v1/coins/${t.addr(contract)}`)).data;
+    },
+    async prices() {
+      return (await t.get("/v1/coins/prices")).data;
+    },
+    claim(coinAddress) {
+      return t.post("/v1/coins/claim", { coinAddress });
+    },
+    claims(status = "PENDING") {
+      return t.get("/v1/coins/claims", { status });
+    },
+    async updateProfile(contract, data) {
+      return (await t.patch(`/v1/coins/${t.addr(contract)}`, data)).data;
+    },
+    async sync(coinAddress, owner) {
+      return (await t.post("/v1/coins/sync", { coinAddress, ...owner ? { owner } : {} })).data;
+    }
+  };
+}
+
+// src/api/domains/drops.ts
+function createDropsApi(t) {
+  return {
+    async fee() {
+      return (await t.get("/v1/drops/fee")).data;
+    },
+    list(query = {}) {
+      return t.get("/v1/drops", {
+        status: query.status,
+        organizer: query.organizer ? t.addr(query.organizer) : void 0,
+        page: query.page,
+        limit: query.limit
+      });
+    },
+    async find(contract) {
+      const res = await t.find(`/v1/drops/${t.addr(contract)}`);
+      return res?.data ?? null;
+    },
+    mints(contract, opts = {}) {
+      return t.get(`/v1/drops/${t.addr(contract)}/mints`, { page: opts.page, limit: opts.limit });
+    }
+  };
+}
+
+// src/api/domains/sponsorship.ts
+function createSponsorshipApi(t) {
+  return {
+    offers(query = {}) {
+      return t.get("/v1/sponsorship/offers", {
+        limit: query.limit ?? 50,
+        nftContract: query.nftContract,
+        author: query.author,
+        owner: query.owner,
+        open: query.open
+      });
+    },
+    async findOffer(offerId) {
+      const res = await t.find(`/v1/sponsorship/offers/${encodeURIComponent(offerId)}`);
+      return res?.data ?? null;
+    },
+    async bids(offerId) {
+      return (await t.get(`/v1/sponsorship/offers/${encodeURIComponent(offerId)}/bids`)).data;
+    },
+    proposals(query = {}) {
+      return t.get("/v1/sponsorship/proposals", {
+        limit: query.limit ?? 50,
+        nftContract: query.nftContract,
+        proposer: query.proposer,
+        owner: query.owner,
+        open: query.open
+      });
+    },
+    async findProposal(proposalId) {
+      const res = await t.find(`/v1/sponsorship/proposals/${encodeURIComponent(proposalId)}`);
+      return res?.data ?? null;
+    },
+    licenses(query = {}) {
+      return t.get("/v1/sponsorship/licenses", { limit: query.limit ?? 50, holder: query.holder, author: query.author });
+    }
+  };
+}
+
+// src/api/domains/rewards.ts
+function createRewardsApi(t) {
+  return {
+    async get(address) {
+      return (await t.get(`/v1/rewards/${t.addr(address)}`)).data;
+    },
+    leaderboard(opts = {}) {
+      return t.get("/v1/rewards", { page: opts.page ?? 1, limit: opts.limit ?? 50 });
+    },
+    events(address, opts = {}) {
+      return t.get(`/v1/rewards/${t.addr(address)}/events`, { page: opts.page ?? 1, limit: opts.limit ?? 20 });
+    },
+    async config() {
+      return (await t.get("/v1/rewards/config")).data;
+    },
+    async batch(addresses) {
+      if (addresses.length === 0) return [];
+      const res = await t.get("/v1/rewards/batch", {
+        addresses: addresses.map((a) => t.addr(a)).join(",")
+      });
+      return res.data;
+    }
+  };
+}
+
+// src/api/domains/platform.ts
+function createPlatformApi(t) {
+  return {
+    async stats() {
+      return (await t.get("/v1/stats")).data;
+    },
+    async swapQuote(body) {
+      return (await t.post("/v1/swap/quote", body)).quote;
+    },
+    async submitReport(report) {
+      const targetContract = report.targetContract ? t.addr(report.targetContract) : void 0;
+      const targetAddress = report.targetAddress ? t.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 t.post("/v1/reports", { ...report, targetKey, targetContract, targetAddress });
+    }
+  };
+}
+
+// src/api/domains/chainReads.ts
+function createChainReadsApi(t) {
+  const data = async (path) => (await t.get(path)).data;
+  return {
+    ticket: (contract, tokenId) => data(`/v1/tickets/${t.addr(contract)}/${tokenId}`),
+    ticketCount: async (contract) => (await data(`/v1/tickets/${t.addr(contract)}/count`)).count,
+    clubMembershipCount: async (contract) => (await data(`/v1/club/${t.addr(contract)}/count`)).count,
+    clubMembership: (contract, tokenId) => data(`/v1/club/${t.addr(contract)}/${tokenId}`),
+    isClubMember: async (contract, tokenId, wallet) => (await data(`/v1/club/${t.addr(contract)}/${tokenId}/member/${t.addr(wallet)}`)).isMember,
+    ipNftTokenData: (contract, tokenId) => data(`/v1/ipnft/${t.addr(contract)}/${tokenId}`),
+    coinGuarantees: (contract) => data(`/v1/coins/${t.addr(contract)}/guarantees`),
+    popClaimInfo: (collection) => data(`/v1/pop/${t.addr(collection)}/claim-info`),
+    async dropState(contract) {
+      const wire = await data(`/v1/drops/${t.addr(contract)}/state`);
+      return wire ? dropStateFromWire(wire) : null;
+    }
+  };
+}
+
+// src/api/client.ts
+var ApiClient = class _ApiClient {
+  constructor(options) {
+    this.transport = new Transport(options);
+    const t = this.transport;
+    this.orders = createOrdersApi(t);
+    this.tokens = createTokensApi(t);
+    this.collections = createCollectionsApi(t);
+    this.activity = createActivityApi(t);
+    this.search = createSearchApi(t);
+    this.intents = createIntentsApi(t);
+    this.metadata = createMetadataApi(t);
+    this.creators = createCreatorsApi(t);
+    this.account = createAccountApi(t);
+    this.portal = createPortalApi(t);
+    this.business = createBusinessApi(t);
+    this.remix = createRemixApi(t);
+    this.coins = createCoinsApi(t);
+    this.drops = createDropsApi(t);
+    this.sponsorship = createSponsorshipApi(t);
+    this.rewards = createRewardsApi(t);
+    this.platform = createPlatformApi(t);
+    this.chainReads = createChainReadsApi(t);
+  }
+  withBearer(bearer) {
+    return new _ApiClient({ ...this.transport.settings(), bearer });
+  }
+};
+
+// src/wallet/passkey-errors.ts
+var PasskeyCancelledError = class extends Error {
+  constructor(message = "Passkey prompt was cancelled.") {
+    super(message);
+    this.name = "PasskeyCancelledError";
+  }
+};
+var DeviceKeyMissingError = class extends Error {
+  constructor() {
+    super("This browser no longer holds the wallet key. Recover the wallet with its recovery key.");
+    this.name = "DeviceKeyMissingError";
+  }
+};
+var PasskeyUnsupportedError = class extends Error {
+  constructor(reason) {
+    super(
+      reason === "no-webauthn" ? "Passkeys are not available in this environment." : "This passkey did not return a PRF secret, so it cannot seal a wallet key."
+    );
+    this.name = "PasskeyUnsupportedError";
+    this.reason = reason;
+  }
+};
+
+// src/constants.ts
+var SN = getCoordinates("STARKNET");
+var STARKNET_MARKETPLACE_721_CONTRACT = SN.marketplace721;
+var STARKNET_MARKETPLACE_1155_CONTRACT = SN.marketplace1155;
+var STARKNET_COLLECTION_721_CONTRACT = SN.collection721;
+var STARKNET_DATA_TOKENIZATION_721_CONTRACT = SN.dataTokenization721;
+var STARKNET_COLLECTION_1155_CONTRACT = SN.collection1155;
+var STARKNET_POP_FACTORY_CONTRACT = SN.popFactory;
+var STARKNET_POP_FACTORY_START_BLOCK = SN.popFactoryStartBlock;
+var STARKNET_DROP_FACTORY_CONTRACT = SN.dropFactory;
+var STARKNET_DROP_FACTORY_START_BLOCK = SN.dropFactoryStartBlock;
+var STARKNET_NFTCOMMENTS_CONTRACT = SN.nftComments;
+var STARKNET_IP_TICKETS_FACTORY_CONTRACT = SN.ipTicketsFactory;
+var STARKNET_IP_CLUB_FACTORY_CONTRACT = SN.ipClubFactory;
+var STARKNET_IP_SPONSORSHIP_CONTRACT = SN.ipSponsorship;
+var STARKNET_MEDIAWALLET_CLASS_HASH = SN.mediaWalletClassHash;
+var STARKNET_CREATOR_COIN_FACTORY_CONTRACT = SN.creatorCoinFactory;
+var STARKNET_GENESIS_MINT_CONTRACT = SN.genesisMint;
+var STARKNET_GENESIS_NFT_URI = "ipfs://bafkreiag6wzov7migmxwx3wrtudvbx4ajrlbjopqw7uni7nn2nsxv4eykm";
+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";
+
+// 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);
+}
+
+export { ApiClient, DEFAULT_CURRENCY, DeviceKeyMissingError, MedialaneApiError, MedialaneError, PasskeyCancelledError, PasskeyUnsupportedError, STARKNET_COLLECTION_1155_CONTRACT, STARKNET_COLLECTION_721_CONTRACT, STARKNET_CREATOR_COIN_FACTORY_CONTRACT, STARKNET_DATA_TOKENIZATION_721_CONTRACT, STARKNET_DROP_FACTORY_CONTRACT, STARKNET_DROP_FACTORY_START_BLOCK, STARKNET_GENESIS_MINT_CONTRACT, STARKNET_GENESIS_NFT_URI, STARKNET_IP_CLUB_FACTORY_CONTRACT, STARKNET_IP_SPONSORSHIP_CONTRACT, STARKNET_IP_TICKETS_FACTORY_CONTRACT, STARKNET_MARKETPLACE_1155_CONTRACT, STARKNET_MARKETPLACE_721_CONTRACT, STARKNET_MEDIAWALLET_CLASS_HASH, STARKNET_NFTCOMMENTS_CONTRACT, STARKNET_POP_FACTORY_CONTRACT, STARKNET_POP_FACTORY_START_BLOCK, SUPPORTED_TOKENS, UserFacingError, formatAmount, getListableTokens, getTokenByAddress, getTokenBySymbol, normalizeAddress, normalizeHash, parseAmount, shortenAddress };
+//# sourceMappingURL=chunk-KGAGWULG.js.map
+//# sourceMappingURL=chunk-KGAGWULG.js.map