@stellar-snaps/sdk 0.2.0 → 0.3.1

package/dist/index.js

@@ -23,8 +23,62 @@ function _interopNamespace(e) {
 
 var StellarSdk__namespace = /*#__PURE__*/_interopNamespace(StellarSdk);
 
+// src/errors.ts
+var StellarSnapError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "StellarSnapError";
+  }
+};
+var InvalidAddressError = class extends StellarSnapError {
+  constructor(address) {
+    super(`Invalid Stellar address: ${address}`, "INVALID_ADDRESS");
+    this.name = "InvalidAddressError";
+  }
+};
+var InvalidAmountError = class extends StellarSnapError {
+  constructor(amount) {
+    super(`Invalid amount: ${amount}. Must be a positive number.`, "INVALID_AMOUNT");
+    this.name = "InvalidAmountError";
+  }
+};
+var InvalidAssetError = class extends StellarSnapError {
+  constructor(message) {
+    super(message, "INVALID_ASSET");
+    this.name = "InvalidAssetError";
+  }
+};
+var InvalidUriError = class extends StellarSnapError {
+  constructor(message) {
+    super(message, "INVALID_URI");
+    this.name = "InvalidUriError";
+  }
+};
+var SnapNotFoundError = class extends StellarSnapError {
+  constructor(snapId) {
+    super(`Snap not found: ${snapId}`, "SNAP_NOT_FOUND");
+    this.name = "SnapNotFoundError";
+  }
+};
+var SnapUnauthorizedError = class extends StellarSnapError {
+  constructor(message = "Unauthorized") {
+    super(message, "SNAP_UNAUTHORIZED");
+    this.name = "SnapUnauthorizedError";
+  }
+};
+var SnapApiError = class extends StellarSnapError {
+  constructor(message, statusCode) {
+    super(message, "SNAP_API_ERROR");
+    this.statusCode = statusCode;
+    this.name = "SnapApiError";
+  }
+};
+
 // src/create-snap.ts
+var DEFAULT_BASE_URL = "https://stellar-snaps.vercel.app";
 async function createSnap(options) {
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
   const {
     creator,
     title,
@@ -36,20 +90,19 @@ async function createSnap(options) {
     memo,
     memoType = "MEMO_TEXT",
     network = "testnet",
-    imageUrl,
-    serverUrl = "https://stellarsnaps.com"
+    imageUrl
   } = options;
   if (!creator || creator.length !== 56 || !creator.startsWith("G")) {
-    throw new Error("Invalid creator address");
+    throw new InvalidAddressError(creator || "");
   }
   if (!title || title.trim().length === 0) {
-    throw new Error("Title is required");
+    throw new SnapApiError("Title is required");
   }
   if (!destination || destination.length !== 56 || !destination.startsWith("G")) {
-    throw new Error("Invalid destination address");
+    throw new InvalidAddressError(destination || "");
   }
   if (assetCode !== "XLM" && !assetIssuer) {
-    throw new Error("Asset issuer is required for non-XLM assets");
+    throw new SnapApiError("Asset issuer is required for non-XLM assets");
   }
   const body = {
     creator,
@@ -64,52 +117,206 @@ async function createSnap(options) {
     network,
     imageUrl
   };
-  const response = await fetch(`${serverUrl}/api/snaps`, {
+  const response = await fetch(`${baseUrl}/api/snaps`, {
     method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
+    headers: { "Content-Type": "application/json" },
     body: JSON.stringify(body)
   });
   if (!response.ok) {
-    const error = await response.json().catch(() => ({ error: "Unknown error" }));
-    throw new Error(error.error || `Failed to create snap: ${response.status}`);
+    const data = await response.json().catch(() => ({ error: "Unknown error" }));
+    const message = data.error || `Failed to create snap: ${response.status}`;
+    throw new SnapApiError(message, response.status);
   }
   const snap = await response.json();
   return {
     id: snap.id,
-    url: `${serverUrl}/s/${snap.id}`,
+    url: `${baseUrl}/s/${snap.id}`,
     snap
   };
 }
 async function getSnap(id, options = {}) {
-  const { serverUrl = "https://stellarsnaps.com" } = options;
-  const response = await fetch(`${serverUrl}/api/snaps/${id}`);
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  const response = await fetch(`${baseUrl}/api/snap/${id}`);
   if (response.status === 404) {
-    return null;
+    throw new SnapNotFoundError(id);
   }
   if (!response.ok) {
-    throw new Error(`Failed to fetch snap: ${response.status}`);
+    const data = await response.json().catch(() => ({}));
+    const message = data.error || `Failed to fetch snap: ${response.status}`;
+    throw new SnapApiError(message, response.status);
   }
   return response.json();
 }
 async function listSnaps(creator, options = {}) {
-  const { serverUrl = "https://stellarsnaps.com" } = options;
-  const response = await fetch(`${serverUrl}/api/snaps?creator=${encodeURIComponent(creator)}`);
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  const response = await fetch(
+    `${baseUrl}/api/snaps?creator=${encodeURIComponent(creator)}`
+  );
   if (!response.ok) {
-    throw new Error(`Failed to list snaps: ${response.status}`);
+    const data = await response.json().catch(() => ({}));
+    const message = data.error || `Failed to list snaps: ${response.status}`;
+    throw new SnapApiError(message, response.status);
   }
   return response.json();
 }
-async function deleteSnap(id, options = {}) {
-  const { serverUrl = "https://stellarsnaps.com" } = options;
-  const response = await fetch(`${serverUrl}/api/snaps/${id}`, {
-    method: "DELETE"
-  });
-  if (!response.ok && response.status !== 404) {
-    throw new Error(`Failed to delete snap: ${response.status}`);
+async function deleteSnap(id, creator, options = {}) {
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  const url = `${baseUrl}/api/snaps?id=${encodeURIComponent(id)}&creator=${encodeURIComponent(creator)}`;
+  const response = await fetch(url, { method: "DELETE" });
+  if (response.status === 404) {
+    throw new SnapNotFoundError(id);
+  }
+  if (response.status === 403) {
+    throw new SnapUnauthorizedError("You do not have permission to delete this snap");
+  }
+  if (!response.ok) {
+    const data = await response.json().catch(() => ({}));
+    const message = data.error || `Failed to delete snap: ${response.status}`;
+    throw new SnapApiError(message, response.status);
+  }
+}
+
+// src/snap-id.ts
+var ALPHABET = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function generateSnapId(length = 8) {
+  let id = "";
+  const randomValues = new Uint8Array(length);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(randomValues);
+  } else {
+    for (let i = 0; i < length; i++) {
+      randomValues[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  for (let i = 0; i < length; i++) {
+    id += ALPHABET[randomValues[i] % ALPHABET.length];
+  }
+  return id;
+}
+function isValidSnapId(id) {
+  if (!id || typeof id !== "string") return false;
+  if (id.length < 4 || id.length > 32) return false;
+  return /^[a-zA-Z0-9_-]+$/.test(id);
+}
+function extractSnapId(url, patterns = ["/s/", "/snap/", "/pay/"]) {
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname;
+    for (const pattern of patterns) {
+      const index = path.indexOf(pattern);
+      if (index !== -1) {
+        const idStart = index + pattern.length;
+        const remaining = path.slice(idStart);
+        const match = remaining.match(/^([a-zA-Z0-9_-]+)/);
+        if (match && isValidSnapId(match[1])) {
+          return match[1];
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/schema.ts
+function validateSnapInput(input) {
+  if (!input.creator || input.creator.length !== 56 || !input.creator.startsWith("G")) {
+    throw new Error("Invalid creator address");
+  }
+  if (!input.destination || input.destination.length !== 56 || !input.destination.startsWith("G")) {
+    throw new Error("Invalid destination address");
+  }
+  if (!input.title || input.title.trim().length === 0) {
+    throw new Error("Title is required");
+  }
+  if (input.title.length > 100) {
+    throw new Error("Title must be 100 characters or less");
+  }
+  if (input.description && input.description.length > 500) {
+    throw new Error("Description must be 500 characters or less");
   }
+  if (input.assetCode && input.assetCode !== "XLM" && !input.assetIssuer) {
+    throw new Error("Asset issuer is required for non-XLM assets");
+  }
+  if (input.assetIssuer && (input.assetIssuer.length !== 56 || !input.assetIssuer.startsWith("G"))) {
+    throw new Error("Invalid asset issuer address");
+  }
+  if (input.amount) {
+    const amountNum = parseFloat(input.amount);
+    if (isNaN(amountNum) || amountNum <= 0) {
+      throw new Error("Amount must be a positive number");
+    }
+  }
+  if (input.network && !["public", "testnet"].includes(input.network)) {
+    throw new Error('Network must be "public" or "testnet"');
+  }
+  if (input.memoType && !["MEMO_TEXT", "MEMO_ID", "MEMO_HASH", "MEMO_RETURN"].includes(input.memoType)) {
+    throw new Error("Invalid memo type");
+  }
+}
+function createSnapObject(id, input) {
+  validateSnapInput(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id,
+    creator: input.creator,
+    title: input.title.trim(),
+    description: input.description?.trim() || null,
+    imageUrl: input.imageUrl || null,
+    destination: input.destination,
+    assetCode: input.assetCode || "XLM",
+    assetIssuer: input.assetIssuer || null,
+    amount: input.amount || null,
+    memo: input.memo || null,
+    memoType: input.memoType || "MEMO_TEXT",
+    network: input.network || "testnet",
+    createdAt: now,
+    updatedAt: now
+  };
 }
+var POSTGRES_SCHEMA = `
+CREATE TABLE IF NOT EXISTS snaps (
+  id TEXT PRIMARY KEY,
+  creator TEXT NOT NULL,
+  title TEXT NOT NULL,
+  description TEXT,
+  image_url TEXT,
+  destination TEXT NOT NULL,
+  asset_code TEXT NOT NULL DEFAULT 'XLM',
+  asset_issuer TEXT,
+  amount TEXT,
+  memo TEXT,
+  memo_type TEXT NOT NULL DEFAULT 'MEMO_TEXT',
+  network TEXT NOT NULL DEFAULT 'testnet',
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_snaps_creator ON snaps(creator);
+CREATE INDEX IF NOT EXISTS idx_snaps_destination ON snaps(destination);
+`;
+var SQLITE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS snaps (
+  id TEXT PRIMARY KEY,
+  creator TEXT NOT NULL,
+  title TEXT NOT NULL,
+  description TEXT,
+  image_url TEXT,
+  destination TEXT NOT NULL,
+  asset_code TEXT NOT NULL DEFAULT 'XLM',
+  asset_issuer TEXT,
+  amount TEXT,
+  memo TEXT,
+  memo_type TEXT NOT NULL DEFAULT 'MEMO_TEXT',
+  network TEXT NOT NULL DEFAULT 'testnet',
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_snaps_creator ON snaps(creator);
+CREATE INDEX IF NOT EXISTS idx_snaps_destination ON snaps(destination);
+`;
 
 // src/create-payment-snap.ts
 var NETWORK_PASSPHRASES = {
@@ -175,39 +382,6 @@ var HORIZON_URLS = {
   testnet: "https://horizon-testnet.stellar.org"
 };
 
-// src/errors.ts
-var StellarSnapError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "StellarSnapError";
-  }
-};
-var InvalidAddressError = class extends StellarSnapError {
-  constructor(address) {
-    super(`Invalid Stellar address: ${address}`, "INVALID_ADDRESS");
-    this.name = "InvalidAddressError";
-  }
-};
-var InvalidAmountError = class extends StellarSnapError {
-  constructor(amount) {
-    super(`Invalid amount: ${amount}. Must be a positive number.`, "INVALID_AMOUNT");
-    this.name = "InvalidAmountError";
-  }
-};
-var InvalidAssetError = class extends StellarSnapError {
-  constructor(message) {
-    super(message, "INVALID_ASSET");
-    this.name = "InvalidAssetError";
-  }
-};
-var InvalidUriError = class extends StellarSnapError {
-  constructor(message) {
-    super(message, "INVALID_URI");
-    this.name = "InvalidUriError";
-  }
-};
-
 // src/create-transaction-snap.ts
 function createTransactionSnap(options) {
   const { xdr, network = "public", message, callback, pubkey } = options;
@@ -566,32 +740,520 @@ function matchUrlToRule(pathname, rules) {
   return null;
 }
 
+// src/url-resolver.ts
+var SHORTENER_DOMAINS = [
+  "t.co",
+  "bit.ly",
+  "goo.gl",
+  "tinyurl.com",
+  "ow.ly",
+  "is.gd",
+  "buff.ly",
+  "adf.ly",
+  "bit.do",
+  "mcaf.ee",
+  "su.pr",
+  "twit.ac",
+  "tiny.cc",
+  "lnkd.in",
+  "db.tt",
+  "qr.ae",
+  "cur.lv",
+  "ity.im",
+  "q.gs",
+  "po.st",
+  "bc.vc",
+  "u.to",
+  "j.mp",
+  "buzurl.com",
+  "cutt.us",
+  "u.bb",
+  "yourls.org",
+  "x.co",
+  "prettylinkpro.com",
+  "viralurl.com",
+  "twitthis.com",
+  "shorturl.at",
+  "rb.gy",
+  "shorturl.com"
+];
+function isShortenerUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const domain = parsed.hostname.toLowerCase();
+    return SHORTENER_DOMAINS.some(
+      (shortener) => domain === shortener || domain.endsWith(`.${shortener}`)
+    );
+  } catch {
+    return false;
+  }
+}
+function extractDomain(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function extractPath(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.pathname;
+  } catch {
+    return "";
+  }
+}
+async function resolveUrl(url) {
+  const originalUrl = url;
+  const wasShortened = isShortenerUrl(url);
+  if (!wasShortened) {
+    return {
+      url,
+      domain: extractDomain(url),
+      originalUrl,
+      wasShortened: false
+    };
+  }
+  try {
+    const response = await fetch(url, {
+      method: "HEAD",
+      redirect: "follow"
+    });
+    const finalUrl = response.url;
+    return {
+      url: finalUrl,
+      domain: extractDomain(finalUrl),
+      originalUrl,
+      wasShortened: true
+    };
+  } catch (error) {
+    return {
+      url,
+      domain: extractDomain(url),
+      originalUrl,
+      wasShortened: true
+    };
+  }
+}
+async function resolveUrls(urls) {
+  return Promise.all(urls.map(resolveUrl));
+}
+
+// src/registry.ts
+function createRegistry(domains = []) {
+  return {
+    domains,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "1.0.0"
+  };
+}
+function addDomain(registry, entry) {
+  const existing = registry.domains.findIndex((d) => d.domain === entry.domain);
+  const newDomains = existing >= 0 ? registry.domains.map((d, i) => i === existing ? entry : d) : [...registry.domains, entry];
+  return {
+    ...registry,
+    domains: newDomains,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function removeDomain(registry, domain) {
+  return {
+    ...registry,
+    domains: registry.domains.filter((d) => d.domain !== domain),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function getDomainStatus(registry, domain) {
+  const normalizedDomain = domain.toLowerCase().replace(/^www\./, "");
+  const entry = registry.domains.find(
+    (d) => d.domain.toLowerCase() === normalizedDomain
+  );
+  return entry || null;
+}
+function isDomainVerified(registry, domain) {
+  const entry = getDomainStatus(registry, domain);
+  return entry?.status === "verified";
+}
+function isDomainBlocked(registry, domain) {
+  const entry = getDomainStatus(registry, domain);
+  return entry?.status === "blocked";
+}
+function getVerifiedDomains(registry) {
+  return registry.domains.filter((d) => d.status === "verified");
+}
+function getBlockedDomains(registry) {
+  return registry.domains.filter((d) => d.status === "blocked");
+}
+function validateRegistry(registry) {
+  if (!registry || typeof registry !== "object") return false;
+  const r = registry;
+  if (!Array.isArray(r.domains)) return false;
+  if (typeof r.updatedAt !== "string") return false;
+  if (typeof r.version !== "string") return false;
+  return r.domains.every((d) => {
+    if (!d || typeof d !== "object") return false;
+    const entry = d;
+    return typeof entry.domain === "string" && ["verified", "unverified", "blocked"].includes(entry.status);
+  });
+}
+
+// src/explorer.ts
+var EXPLORER_URLS = {
+  "stellar.expert": {
+    public: "https://stellar.expert/explorer/public",
+    testnet: "https://stellar.expert/explorer/testnet"
+  },
+  stellarchain: {
+    public: "https://stellarchain.io",
+    testnet: "https://testnet.stellarchain.io"
+  },
+  horizon: {
+    public: "https://horizon.stellar.org",
+    testnet: "https://horizon-testnet.stellar.org"
+  }
+};
+function getTransactionUrl(hash, network = "testnet", explorer = "stellar.expert") {
+  const baseUrl = EXPLORER_URLS[explorer][network];
+  switch (explorer) {
+    case "stellar.expert":
+      return `${baseUrl}/tx/${hash}`;
+    case "stellarchain":
+      return `${baseUrl}/transactions/${hash}`;
+    case "horizon":
+      return `${baseUrl}/transactions/${hash}`;
+    default:
+      return `${baseUrl}/tx/${hash}`;
+  }
+}
+function getAccountUrl(address, network = "testnet", explorer = "stellar.expert") {
+  const baseUrl = EXPLORER_URLS[explorer][network];
+  switch (explorer) {
+    case "stellar.expert":
+      return `${baseUrl}/account/${address}`;
+    case "stellarchain":
+      return `${baseUrl}/accounts/${address}`;
+    case "horizon":
+      return `${baseUrl}/accounts/${address}`;
+    default:
+      return `${baseUrl}/account/${address}`;
+  }
+}
+function getAssetUrl(code, issuer, network = "testnet", explorer = "stellar.expert") {
+  const baseUrl = EXPLORER_URLS[explorer][network];
+  switch (explorer) {
+    case "stellar.expert":
+      return `${baseUrl}/asset/${code}-${issuer}`;
+    case "stellarchain":
+      return `${baseUrl}/assets/${code}:${issuer}`;
+    case "horizon":
+      return `${baseUrl}/assets?asset_code=${code}&asset_issuer=${issuer}`;
+    default:
+      return `${baseUrl}/asset/${code}-${issuer}`;
+  }
+}
+function getOperationUrl(operationId, network = "testnet", explorer = "stellar.expert") {
+  const baseUrl = EXPLORER_URLS[explorer][network];
+  switch (explorer) {
+    case "stellar.expert":
+      return `${baseUrl}/op/${operationId}`;
+    case "stellarchain":
+      return `${baseUrl}/operations/${operationId}`;
+    case "horizon":
+      return `${baseUrl}/operations/${operationId}`;
+    default:
+      return `${baseUrl}/op/${operationId}`;
+  }
+}
+
+// src/meta-tags.ts
+function generateMetaTags(metadata) {
+  const {
+    title,
+    description,
+    imageUrl,
+    amount,
+    assetCode = "XLM",
+    url,
+    siteName = "Stellar Snaps"
+  } = metadata;
+  const autoDescription = description || (amount ? `Pay ${amount} ${assetCode} - ${title}` : `Make a payment - ${title}`);
+  return {
+    og: {
+      "og:title": title,
+      "og:description": autoDescription,
+      "og:url": url,
+      "og:site_name": siteName,
+      "og:type": "website",
+      ...imageUrl && { "og:image": imageUrl }
+    },
+    twitter: {
+      "twitter:card": imageUrl ? "summary_large_image" : "summary",
+      "twitter:title": title,
+      "twitter:description": autoDescription,
+      ...imageUrl && { "twitter:image": imageUrl }
+    },
+    standard: {
+      title: `${title} | ${siteName}`,
+      description: autoDescription
+    }
+  };
+}
+function metaTagsToHtml(tags) {
+  const lines = [];
+  if (tags.standard.title) {
+    lines.push(`<title>${escapeHtml(tags.standard.title)}</title>`);
+  }
+  if (tags.standard.description) {
+    lines.push(
+      `<meta name="description" content="${escapeHtml(tags.standard.description)}" />`
+    );
+  }
+  for (const [property, content] of Object.entries(tags.og)) {
+    lines.push(
+      `<meta property="${escapeHtml(property)}" content="${escapeHtml(content)}" />`
+    );
+  }
+  for (const [name, content] of Object.entries(tags.twitter)) {
+    lines.push(
+      `<meta name="${escapeHtml(name)}" content="${escapeHtml(content)}" />`
+    );
+  }
+  return lines.join("\n");
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function generateJsonLd(metadata) {
+  const { title, description, amount, assetCode = "XLM", url, imageUrl } = metadata;
+  return {
+    "@context": "https://schema.org",
+    "@type": "PaymentService",
+    name: title,
+    description: description || `Pay ${amount || "any amount"} ${assetCode}`,
+    url,
+    ...imageUrl && { image: imageUrl },
+    ...amount && {
+      offers: {
+        "@type": "Offer",
+        price: amount,
+        priceCurrency: assetCode
+      }
+    }
+  };
+}
+
+// src/server.ts
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  "Access-Control-Max-Age": "86400"
+};
+var CACHE_HEADERS = {
+  /** No caching */
+  none: {
+    "Cache-Control": "no-store, no-cache, must-revalidate"
+  },
+  /** Short cache (1 minute) */
+  short: {
+    "Cache-Control": "public, max-age=60, stale-while-revalidate=30"
+  },
+  /** Medium cache (5 minutes) */
+  medium: {
+    "Cache-Control": "public, max-age=300, stale-while-revalidate=60"
+  },
+  /** Long cache (1 hour) */
+  long: {
+    "Cache-Control": "public, max-age=3600, stale-while-revalidate=300"
+  },
+  /** Immutable (1 year) */
+  immutable: {
+    "Cache-Control": "public, max-age=31536000, immutable"
+  }
+};
+function successResponse(data) {
+  return {
+    success: true,
+    data
+  };
+}
+function errorResponse(message, code) {
+  return {
+    success: false,
+    error: message,
+    code
+  };
+}
+function validateRequired(body, fields) {
+  for (const field of fields) {
+    if (body[field] === void 0 || body[field] === null || body[field] === "") {
+      throw new Error(`Missing required field: ${field}`);
+    }
+  }
+}
+function parseQueryParams(url) {
+  try {
+    const parsed = new URL(url);
+    const params = {};
+    parsed.searchParams.forEach((value, key) => {
+      params[key] = value;
+    });
+    return params;
+  } catch {
+    return {};
+  }
+}
+function buildUrl(base, params) {
+  const url = new URL(base);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      url.searchParams.set(key, value);
+    }
+  }
+  return url.toString();
+}
+function createRateLimiter(options) {
+  const buckets = /* @__PURE__ */ new Map();
+  return {
+    /**
+     * Checks if a key is within rate limits.
+     * Returns true if allowed, false if rate limited.
+     */
+    check(key) {
+      const now = Date.now();
+      const bucket = buckets.get(key);
+      if (bucket && bucket.resetAt <= now) {
+        buckets.delete(key);
+      }
+      const current = buckets.get(key);
+      if (!current) {
+        buckets.set(key, {
+          count: 1,
+          resetAt: now + options.windowMs
+        });
+        return true;
+      }
+      if (current.count >= options.maxRequests) {
+        return false;
+      }
+      current.count++;
+      return true;
+    },
+    /**
+     * Gets remaining requests for a key.
+     */
+    remaining(key) {
+      const bucket = buckets.get(key);
+      if (!bucket || bucket.resetAt <= Date.now()) {
+        return options.maxRequests;
+      }
+      return Math.max(0, options.maxRequests - bucket.count);
+    },
+    /**
+     * Resets the limiter for a key.
+     */
+    reset(key) {
+      buckets.delete(key);
+    },
+    /**
+     * Clears all rate limit data.
+     */
+    clear() {
+      buckets.clear();
+    }
+  };
+}
+function parseAddress(input) {
+  const trimmed = input.trim();
+  if (trimmed.includes("*")) {
+    return {
+      address: trimmed,
+      federation: trimmed
+    };
+  }
+  if (trimmed.startsWith("M") && trimmed.length === 69) {
+    return {
+      address: trimmed,
+      muxedId: trimmed
+    };
+  }
+  if (trimmed.startsWith("G") && trimmed.length === 56) {
+    return {
+      address: trimmed
+    };
+  }
+  throw new Error("Invalid address format");
+}
+
+exports.CACHE_HEADERS = CACHE_HEADERS;
+exports.CORS_HEADERS = CORS_HEADERS;
+exports.EXPLORER_URLS = EXPLORER_URLS;
 exports.HORIZON_URLS = HORIZON_URLS;
 exports.InvalidAddressError = InvalidAddressError;
 exports.InvalidAmountError = InvalidAmountError;
 exports.InvalidAssetError = InvalidAssetError;
 exports.InvalidUriError = InvalidUriError;
 exports.NETWORK_PASSPHRASES = NETWORK_PASSPHRASES2;
+exports.POSTGRES_SCHEMA = POSTGRES_SCHEMA;
+exports.SHORTENER_DOMAINS = SHORTENER_DOMAINS;
+exports.SQLITE_SCHEMA = SQLITE_SCHEMA;
+exports.SnapApiError = SnapApiError;
+exports.SnapNotFoundError = SnapNotFoundError;
+exports.SnapUnauthorizedError = SnapUnauthorizedError;
 exports.StellarSnapError = StellarSnapError;
+exports.addDomain = addDomain;
 exports.buildPaymentTransaction = buildPaymentTransaction;
+exports.buildUrl = buildUrl;
 exports.connectFreighter = connectFreighter;
 exports.createAsset = createAsset;
 exports.createDiscoveryFile = createDiscoveryFile;
 exports.createPaymentSnap = createPaymentSnap;
+exports.createRateLimiter = createRateLimiter;
+exports.createRegistry = createRegistry;
 exports.createSnap = createSnap;
+exports.createSnapObject = createSnapObject;
 exports.createTransactionSnap = createTransactionSnap;
 exports.deleteSnap = deleteSnap;
+exports.errorResponse = errorResponse;
+exports.extractDomain = extractDomain;
+exports.extractPath = extractPath;
+exports.extractSnapId = extractSnapId;
+exports.generateJsonLd = generateJsonLd;
+exports.generateMetaTags = generateMetaTags;
+exports.generateSnapId = generateSnapId;
+exports.getAccountUrl = getAccountUrl;
+exports.getAssetUrl = getAssetUrl;
+exports.getBlockedDomains = getBlockedDomains;
+exports.getDomainStatus = getDomainStatus;
 exports.getFreighterNetwork = getFreighterNetwork;
+exports.getOperationUrl = getOperationUrl;
 exports.getSnap = getSnap;
+exports.getTransactionUrl = getTransactionUrl;
+exports.getVerifiedDomains = getVerifiedDomains;
+exports.isDomainBlocked = isDomainBlocked;
+exports.isDomainVerified = isDomainVerified;
 exports.isFreighterConnected = isFreighterConnected;
+exports.isShortenerUrl = isShortenerUrl;
 exports.isValidAmount = isValidAmount;
 exports.isValidAssetCode = isValidAssetCode;
+exports.isValidSnapId = isValidSnapId;
 exports.isValidStellarAddress = isValidStellarAddress;
 exports.listSnaps = listSnaps;
 exports.matchUrlToRule = matchUrlToRule;
+exports.metaTagsToHtml = metaTagsToHtml;
+exports.parseAddress = parseAddress;
+exports.parseQueryParams = parseQueryParams;
 exports.parseSnapUri = parseSnapUri;
+exports.removeDomain = removeDomain;
+exports.resolveUrl = resolveUrl;
+exports.resolveUrls = resolveUrls;
 exports.signWithFreighter = signWithFreighter;
 exports.submitTransaction = submitTransaction;
+exports.successResponse = successResponse;
 exports.validateDiscoveryFile = validateDiscoveryFile;
+exports.validateRegistry = validateRegistry;
+exports.validateRequired = validateRequired;
+exports.validateSnapInput = validateSnapInput;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map