@fractalshq/sync 0.0.1

package/dist/index.js

@@ -0,0 +1,551 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_RPC_ENDPOINT: () => DEFAULT_RPC_ENDPOINT,
+  DISTRIBUTION_MEMO_PREFIX: () => DISTRIBUTION_MEMO_PREFIX,
+  GET: () => GET,
+  MEMO_PROGRAM_ID: () => MEMO_PROGRAM_ID,
+  POST: () => POST,
+  SyncServerClient: () => SyncServerClient,
+  XNET_2022_MINT: () => XNET_2022_MINT,
+  assertTruthy: () => assertTruthy,
+  buildDistributionMemoTag: () => buildDistributionMemoTag,
+  createMethodHandler: () => createMethodHandler,
+  syncRouteHandler: () => syncRouteHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server/client.ts
+var SyncServerClient = class _SyncServerClient {
+  constructor(options) {
+    this.options = options;
+  }
+  static fromRequest(req, baseURL = process.env.SYNC_BASE_URL || "") {
+    const copyHeaders = () => {
+      const headers = {};
+      const cookie = req.headers.get("cookie");
+      if (cookie) headers["cookie"] = cookie;
+      const auth = req.headers.get("authorization");
+      if (auth) headers["authorization"] = auth;
+      const ua = req.headers.get("user-agent");
+      if (ua) headers["user-agent"] = ua;
+      const xff = req.headers.get("x-forwarded-for");
+      if (xff) headers["x-forwarded-for"] = xff;
+      return headers;
+    };
+    return new _SyncServerClient({ baseURL, getHeaders: copyHeaders });
+  }
+  static fromApiKey(apiKey, baseURL = process.env.SYNC_BASE_URL || "") {
+    return new _SyncServerClient({
+      baseURL,
+      getHeaders: () => apiKey ? { "x-internal-api-key": apiKey } : {}
+    });
+  }
+  async request(path, init) {
+    const headersInit = typeof this.options.getHeaders === "function" ? await this.options.getHeaders() : {};
+    const headers = new Headers(__spreadValues(__spreadValues({ "content-type": "application/json" }, headersInit), (init == null ? void 0 : init.headers) || {}));
+    const res = await fetch(`${this.options.baseURL}${path}`, __spreadProps(__spreadValues({}, init), { headers, credentials: "include" }));
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(text || `Request failed: ${res.status}`);
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  }
+  buildQueryString(query) {
+    if (!query) return "";
+    if (typeof query === "string") return query.startsWith("?") ? query.slice(1) : query;
+    if (query instanceof URLSearchParams) return query.toString();
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0 || value === null) continue;
+      params.set(key, String(value));
+    }
+    return params.toString();
+  }
+  withQuery(path, query) {
+    const qs = this.buildQueryString(query);
+    if (!qs) return path;
+    return `${path}?${qs}`;
+  }
+  listDistributions(params) {
+    const search = new URLSearchParams();
+    if (params == null ? void 0 : params.orgId) search.set("orgId", params.orgId);
+    if (params == null ? void 0 : params.status) search.set("status", params.status);
+    if (params == null ? void 0 : params.mint) search.set("mint", params.mint);
+    if (params == null ? void 0 : params.limit) search.set("limit", String(params.limit));
+    if (params == null ? void 0 : params.cursor) search.set("cursor", params.cursor);
+    const qs = search.toString();
+    return this.request(`/api/v1/distributions${qs ? `?${qs}` : ""}`);
+  }
+  createDistribution(body) {
+    return this.request(`/api/v1/distributions/create-transaction`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  createDistributionWithId(distributionId, body) {
+    return this.request(
+      `/api/v1/distributions/${encodeURIComponent(distributionId)}/create-transaction`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  commitDistribution(distributionId, body) {
+    return this.request(`/api/v1/distributions/${encodeURIComponent(distributionId)}/commit`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  buildClaimTransaction(body) {
+    return this.request(`/api/v1/claims/${encodeURIComponent(body.distributionId)}/create-transaction`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  commitClaim(body) {
+    return this.request(`/api/v1/claims/${encodeURIComponent(body.distributionId)}/commit`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  getClaimable() {
+    return this.request(`/api/test-xnet-claims`);
+  }
+  getClaimsMe(query) {
+    return this.request(this.withQuery(`/api/v1/claims/me`, query));
+  }
+  getDistributionsMe(query) {
+    return this.request(this.withQuery(`/api/v1/distributions/me`, query));
+  }
+  getDistributionMeById(distributionId) {
+    return this.request(`/api/v1/distributions/me/${encodeURIComponent(distributionId)}`);
+  }
+  getClaimHistory() {
+    return this.request(`/api/v1/claims/history`);
+  }
+  health() {
+    return this.request(`/api/v1/health`);
+  }
+};
+
+// src/server/handler/errors.ts
+var SyncHandlerError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message || code);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "SyncHandlerError";
+  }
+};
+
+// src/server/handler/roles.ts
+var ORG_DEPLOYER_ROLES = /* @__PURE__ */ new Set(["owner", "admin", "deployer"]);
+var PLATFORM_DEPLOYER_ROLES = /* @__PURE__ */ new Set(["admin", "deployer"]);
+function normalizeRole(role) {
+  if (!role) return "";
+  return String(role).trim().toLowerCase();
+}
+function resolveWalletFromMe(me) {
+  var _a, _b, _c, _d, _e;
+  if (!me || typeof me !== "object") return null;
+  const candidate = (me == null ? void 0 : me.wallet) || ((_a = me == null ? void 0 : me.user) == null ? void 0 : _a.wallet) || ((_b = me == null ? void 0 : me.user) == null ? void 0 : _b.pubkey) || ((_c = me == null ? void 0 : me.user) == null ? void 0 : _c.name) || ((_d = me == null ? void 0 : me.user) == null ? void 0 : _d.id) || null;
+  if (candidate && typeof candidate === "string" && candidate.length > 0) return candidate;
+  const accounts = Array.isArray(me == null ? void 0 : me.accounts) ? me.accounts : [];
+  const walletAccount = accounts.find((acct) => typeof (acct == null ? void 0 : acct.pubkey) === "string" && acct.pubkey.length > 0);
+  return (_e = walletAccount == null ? void 0 : walletAccount.pubkey) != null ? _e : null;
+}
+function requireLoggedIn(req) {
+  const auth = req.apiAuth;
+  if (auth && auth.ok) return auth;
+  throw new SyncHandlerError(401, "unauthorized");
+}
+function requireDeployer(req) {
+  const auth = requireLoggedIn(req);
+  if (ORG_DEPLOYER_ROLES.has(normalizeRole(auth.orgRole)) || PLATFORM_DEPLOYER_ROLES.has(normalizeRole(auth.platformRole))) {
+    return auth;
+  }
+  throw new SyncHandlerError(403, "forbidden_deployer_role");
+}
+function getSessionWallet(req) {
+  var _a, _b;
+  const direct = typeof req.wallet === "string" && req.wallet.length > 0 ? req.wallet : null;
+  if (direct) return direct;
+  const authWallet = typeof ((_a = req.apiAuth) == null ? void 0 : _a.wallet) === "string" && req.apiAuth.wallet.length > 0 ? req.apiAuth.wallet : null;
+  if (authWallet) return authWallet;
+  return resolveWalletFromMe((_b = req.apiAuth) == null ? void 0 : _b.me);
+}
+function requireSessionWallet(req, expected) {
+  const wallet = getSessionWallet(req);
+  if (!wallet) {
+    throw new SyncHandlerError(401, "unauthorized");
+  }
+  if (expected && expected.length > 0 && expected !== wallet) {
+    throw new SyncHandlerError(403, "forbidden_wallet_mismatch");
+  }
+  return wallet;
+}
+
+// src/server/handler/utils.ts
+var BODY_SYMBOL = Symbol.for("fractals.sync.handler.body");
+async function readJsonBody(req) {
+  const existing = req[BODY_SYMBOL];
+  if (existing !== void 0) return existing;
+  try {
+    const parsed = await req.json();
+    req[BODY_SYMBOL] = parsed;
+    return parsed;
+  } catch (error) {
+    throw new SyncHandlerError(400, "invalid_json", "Request body must be valid JSON");
+  }
+}
+function coerceString(value) {
+  if (typeof value === "string" && value.trim().length > 0) return value;
+  return void 0;
+}
+function toOptionalNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  return void 0;
+}
+function decodePathSegment(value) {
+  if (typeof value !== "string") return "";
+  try {
+    return decodeURIComponent(value);
+  } catch (e) {
+    return value;
+  }
+}
+
+// src/server/handler/claims.ts
+async function handleClaimsRoute(ctx) {
+  if (ctx.segments.length < 2) return null;
+  const [rawDistributionId, action] = ctx.segments;
+  const distributionId = decodePathSegment(rawDistributionId);
+  if (!distributionId) {
+    throw new SyncHandlerError(400, "distribution_id_required");
+  }
+  if (ctx.method !== "POST") return null;
+  if (action === "create-transaction") {
+    return handleClaimBuild(ctx, distributionId);
+  }
+  if (action === "commit") {
+    return handleClaimCommit(ctx, distributionId);
+  }
+  return null;
+}
+async function handleClaimBuild(ctx, distributionId) {
+  const raw = await readJsonBody(ctx.req);
+  const body = __spreadValues({}, raw);
+  const explicitWallet = coerceString(body.claimant) || coerceString(body.claimantPubkey) || coerceString(body.wallet);
+  const claimant = requireSessionWallet(ctx.req, explicitWallet);
+  body.distributionId = distributionId;
+  body.claimant = claimant;
+  const normalizedIndex = toOptionalNumber(raw.index);
+  if (typeof normalizedIndex === "number") body.index = normalizedIndex;
+  const normalizedUnlocked = toOptionalNumber(raw.unlockedAmount);
+  if (typeof normalizedUnlocked === "number") body.unlockedAmount = normalizedUnlocked;
+  const normalizedLocked = toOptionalNumber(raw.lockedAmount);
+  if (typeof normalizedLocked === "number") body.lockedAmount = normalizedLocked;
+  if (!body.distributorPda) {
+    const distributorPda = coerceString(raw.distributorPDA);
+    if (distributorPda) body.distributorPda = distributorPda;
+  }
+  const result = await ctx.client.buildClaimTransaction(body);
+  return Response.json(result);
+}
+async function handleClaimCommit(ctx, distributionId) {
+  var _a, _b, _c;
+  const body = await readJsonBody(ctx.req);
+  const explicitWallet = coerceString(body.claimantPubkey) || coerceString(body.claimant) || coerceString(body.wallet);
+  const claimant = requireSessionWallet(ctx.req, explicitWallet);
+  const payload = __spreadValues({}, body);
+  payload.distributionId = distributionId;
+  payload.claimantPubkey = claimant;
+  const signature = (_a = coerceString(payload.signature)) != null ? _a : coerceString(body.signature);
+  if (signature) payload.signature = signature;
+  const signedTransactionBase64 = coerceString(body.signedTransactionBase64);
+  const transaction = (_c = (_b = coerceString(payload.transaction)) != null ? _b : coerceString(body.transaction)) != null ? _c : signedTransactionBase64;
+  if (transaction) payload.transaction = transaction;
+  if (signedTransactionBase64) payload.signedTransactionBase64 = signedTransactionBase64;
+  const hasSignature = typeof payload.signature === "string" && payload.signature.length > 0;
+  const hasTxn = typeof payload.transaction === "string" && payload.transaction.length > 0;
+  const hasTxnBase64 = typeof payload.signedTransactionBase64 === "string" && payload.signedTransactionBase64.length > 0;
+  if (!hasSignature && !hasTxn && !hasTxnBase64) {
+    throw new SyncHandlerError(400, "transaction_or_signature_required");
+  }
+  const result = await ctx.client.commitClaim(payload);
+  return Response.json(result);
+}
+
+// src/server/handler/distributions.ts
+async function handleDistributionsRoute(ctx) {
+  if (ctx.segments.length === 0) return null;
+  const [first, second] = ctx.segments;
+  if (ctx.method === "POST" && first === "create-transaction" && !second) {
+    requireDeployer(ctx.req);
+    const body = await readJsonBody(ctx.req);
+    const result = await ctx.client.createDistribution(body);
+    return Response.json(result);
+  }
+  const distributionId = decodePathSegment(first);
+  if (!distributionId) {
+    throw new SyncHandlerError(400, "distribution_id_required");
+  }
+  if (ctx.method === "POST" && second === "create-transaction") {
+    requireDeployer(ctx.req);
+    const body = await readJsonBody(ctx.req);
+    const result = await ctx.client.createDistributionWithId(distributionId, body);
+    return Response.json(result);
+  }
+  if (ctx.method === "POST" && second === "commit") {
+    requireDeployer(ctx.req);
+    const body = await readJsonBody(ctx.req);
+    const result = await ctx.client.commitDistribution(distributionId, body);
+    return Response.json(result);
+  }
+  return null;
+}
+
+// src/server/handler/me.ts
+async function handleClaimsMeRoute(ctx) {
+  var _a, _b;
+  if (ctx.method !== "GET") return null;
+  if (ctx.segments.length > 0) return null;
+  requireLoggedIn(ctx.req);
+  const result = await ctx.client.getClaimsMe((_b = (_a = ctx.url) == null ? void 0 : _a.searchParams) != null ? _b : void 0);
+  return Response.json(result);
+}
+async function handleDistributionsMeRoute(ctx) {
+  var _a, _b;
+  if (ctx.method !== "GET") return null;
+  requireLoggedIn(ctx.req);
+  if (ctx.segments.length === 0) {
+    const result = await ctx.client.getDistributionsMe((_b = (_a = ctx.url) == null ? void 0 : _a.searchParams) != null ? _b : void 0);
+    return Response.json(result);
+  }
+  if (ctx.segments.length === 1) {
+    const distributionId = decodePathSegment(ctx.segments[0]);
+    const result = await ctx.client.getDistributionMeById(distributionId);
+    return Response.json(result);
+  }
+  return null;
+}
+
+// src/server/handler.ts
+var ALLOWED_METHODS = /* @__PURE__ */ new Set(["GET", "POST"]);
+var ALLOW_HEADER = "GET, POST";
+async function syncRouteHandler(req, context = {}, options = {}) {
+  var _a;
+  const method = (req.method || "GET").toUpperCase();
+  if (!ALLOWED_METHODS.has(method)) {
+    return new Response(JSON.stringify({ error: "method_not_allowed" }), {
+      status: 405,
+      headers: { "content-type": "application/json", allow: ALLOW_HEADER }
+    });
+  }
+  const url = resolveUrl(req);
+  const segments = await resolveSegments(req, context, url);
+  if (segments.length === 0) {
+    return notFound();
+  }
+  const logger = (_a = options.logger) != null ? _a : console;
+  let client;
+  try {
+    client = resolveClient(req, options);
+  } catch (error) {
+    return handleError(error, req, options, logger);
+  }
+  const [resource, ...rest] = segments;
+  const baseContext = { req, client, method, url, segments: rest };
+  try {
+    let response = null;
+    if (resource === "claims") {
+      if (rest[0] === "me") {
+        response = await handleClaimsMeRoute(__spreadProps(__spreadValues({}, baseContext), { segments: rest.slice(1) }));
+      } else {
+        response = await handleClaimsRoute(baseContext);
+      }
+    } else if (resource === "distributions") {
+      if (rest[0] === "me") {
+        response = await handleDistributionsMeRoute(__spreadProps(__spreadValues({}, baseContext), { segments: rest.slice(1) }));
+      } else {
+        response = await handleDistributionsRoute(baseContext);
+      }
+    }
+    if (response) return response;
+    return notFound();
+  } catch (error) {
+    return handleError(error, req, options, logger);
+  }
+}
+function createMethodHandler(method) {
+  return (req, context, options) => {
+    const incoming = (req.method || "").toUpperCase();
+    if (incoming && incoming !== method) {
+      return new Response(JSON.stringify({ error: "method_not_allowed" }), {
+        status: 405,
+        headers: { "content-type": "application/json", allow: method }
+      });
+    }
+    return syncRouteHandler(req, context, options);
+  };
+}
+var GET = createMethodHandler("GET");
+var POST = createMethodHandler("POST");
+function notFound() {
+  return Response.json({ error: "not_found" }, { status: 404 });
+}
+function resolveClient(req, options) {
+  var _a, _b, _c;
+  if (options.client) return options.client;
+  const baseURL = (_c = (_b = (_a = options.baseURL) != null ? _a : process.env.SYNC_BASE_URL) != null ? _b : process.env.NEXT_PUBLIC_SYNC_BASE_URL) != null ? _c : "";
+  if (!baseURL) {
+    throw new SyncHandlerError(500, "sync_base_url_missing", "SYNC_BASE_URL is not configured");
+  }
+  if (options.getHeadersFromRequest) {
+    return new SyncServerClient({
+      baseURL,
+      getHeaders: () => options.getHeadersFromRequest(req)
+    });
+  }
+  return SyncServerClient.fromRequest(req, baseURL);
+}
+async function resolveSegments(req, context, url) {
+  var _a;
+  const params = await resolveParams(context == null ? void 0 : context.params);
+  if (params == null ? void 0 : params.fractalsSync) {
+    return sanitizeSegments(params.fractalsSync);
+  }
+  const pathname = (_a = url == null ? void 0 : url.pathname) != null ? _a : typeof req.url === "string" ? safePathname(req.url) : "";
+  if (!pathname) return [];
+  const parts = pathname.split("/").filter(Boolean);
+  if (parts.length === 0) return [];
+  const catchAllIndex = parts.findIndex((part) => part === "fractals-sync" || part === "[...fractals-sync]");
+  if (catchAllIndex >= 0) {
+    return sanitizeSegments(parts.slice(catchAllIndex + 1));
+  }
+  return [];
+}
+async function resolveParams(params) {
+  var _a;
+  if (!params) return null;
+  if (typeof (params == null ? void 0 : params.then) === "function") {
+    return (_a = await params) != null ? _a : null;
+  }
+  return params != null ? params : null;
+}
+function sanitizeSegments(segments) {
+  return segments.map((segment) => decodePathSegment(String(segment || ""))).filter((segment) => segment.length > 0);
+}
+function resolveUrl(req) {
+  if (req.nextUrl instanceof URL) {
+    return req.nextUrl;
+  }
+  const rawUrl = typeof req.url === "string" ? req.url : null;
+  if (!rawUrl) return null;
+  try {
+    return new URL(rawUrl, "http://localhost");
+  } catch (e) {
+    return null;
+  }
+}
+function safePathname(url) {
+  try {
+    return new URL(url, "http://localhost").pathname;
+  } catch (e) {
+    return "";
+  }
+}
+async function handleError(error, req, options, logger) {
+  var _a, _b;
+  if (error instanceof SyncHandlerError) {
+    if (error.code === "unauthorized" && options.onUnauthorized) {
+      try {
+        const custom = await options.onUnauthorized(req);
+        if (custom) return custom;
+      } catch (hookError) {
+        (_a = logger == null ? void 0 : logger.warn) == null ? void 0 : _a.call(logger, "[syncRouteHandler] onUnauthorized hook failed", hookError);
+      }
+    }
+    const payload = { error: error.code };
+    if (error.message && error.message !== error.code) payload.message = error.message;
+    if (error.details !== void 0) payload.details = error.details;
+    return Response.json(payload, { status: error.status });
+  }
+  (_b = logger == null ? void 0 : logger.error) == null ? void 0 : _b.call(logger, "[syncRouteHandler] unhandled_error", error);
+  return Response.json({ error: "sync_handler_error" }, { status: 500 });
+}
+
+// src/core/constants.ts
+var MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+var XNET_2022_MINT = "xNETbUB7cRb3AAu2pNG2pUwQcJ2BHcktfvSB8x1Pq6L";
+var DEFAULT_RPC_ENDPOINT = process.env.NEXT_PUBLIC_SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
+var DISTRIBUTION_MEMO_PREFIX = "dist";
+
+// src/core/helpers.ts
+function buildDistributionMemoTag(distributionId, action = "claim") {
+  return `${DISTRIBUTION_MEMO_PREFIX}:${distributionId}:${action}`;
+}
+function assertTruthy(value, message) {
+  if (value === null || value === void 0) {
+    throw new Error(message);
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_RPC_ENDPOINT,
+  DISTRIBUTION_MEMO_PREFIX,
+  GET,
+  MEMO_PROGRAM_ID,
+  POST,
+  SyncServerClient,
+  XNET_2022_MINT,
+  assertTruthy,
+  buildDistributionMemoTag,
+  createMethodHandler,
+  syncRouteHandler
+});

package/dist/index.mjs

@@ -0,0 +1,29 @@
+import {
+  DEFAULT_RPC_ENDPOINT,
+  DISTRIBUTION_MEMO_PREFIX,
+  MEMO_PROGRAM_ID,
+  XNET_2022_MINT,
+  assertTruthy,
+  buildDistributionMemoTag
+} from "./chunk-TCJM2GIK.mjs";
+import {
+  GET,
+  POST,
+  SyncServerClient,
+  createMethodHandler,
+  syncRouteHandler
+} from "./chunk-N3276DIZ.mjs";
+import "./chunk-I4E63NIC.mjs";
+export {
+  DEFAULT_RPC_ENDPOINT,
+  DISTRIBUTION_MEMO_PREFIX,
+  GET,
+  MEMO_PROGRAM_ID,
+  POST,
+  SyncServerClient,
+  XNET_2022_MINT,
+  assertTruthy,
+  buildDistributionMemoTag,
+  createMethodHandler,
+  syncRouteHandler
+};

package/dist/react/index.d.mts

@@ -0,0 +1,40 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { UseQueryOptions, UseQueryResult, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { g as ListDistributionsResponse, a as Distribution, o as ClaimableResponse, q as ClaimHistoryResponse, B as BuildClaimTransactionRequest, l as BuildClaimTransactionResponse, m as CommitClaimRequest, n as CommitClaimResponse } from '../api-CQqyHbnT.mjs';
+
+type Fetcher = typeof fetch;
+interface SyncContextValue {
+    basePath: string;
+    fetcher?: Fetcher;
+}
+interface SyncProviderProps {
+    basePath?: string;
+    fetcher?: Fetcher;
+    children: ReactNode;
+}
+declare function SyncProvider({ basePath, fetcher, children }: SyncProviderProps): react.FunctionComponentElement<react.ProviderProps<SyncContextValue>>;
+interface SyncClient {
+    basePath: string;
+    request<T>(path: string, init?: RequestInit): Promise<T>;
+    get<T>(path: string, init?: RequestInit): Promise<T>;
+    post<T>(path: string, body?: unknown, init?: RequestInit): Promise<T>;
+}
+declare function useSyncClient(): SyncClient;
+declare class SyncReactError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(status: number, code?: string | undefined, details?: unknown | undefined);
+}
+type QueryOptions<T> = Omit<UseQueryOptions<T, SyncReactError, T>, "queryKey" | "queryFn">;
+declare function useDistributions<TResponse = ListDistributionsResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+declare function useDistribution<TResponse = Distribution>(distributionId: string | null | undefined, options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+declare function useClaimableDistributions<TResponse = ClaimableResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+declare function useClaimHistory<TResponse = ClaimHistoryResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+type ClaimTransactionInput = Partial<Omit<BuildClaimTransactionRequest, "distributionId" | "claimant">>;
+declare function useClaimTransaction(distributionId: string | null | undefined, options?: UseMutationOptions<BuildClaimTransactionResponse, SyncReactError, ClaimTransactionInput>): UseMutationResult<BuildClaimTransactionResponse, SyncReactError, ClaimTransactionInput>;
+type ClaimCommitInput = Omit<CommitClaimRequest, "distributionId">;
+declare function useCommitClaim(distributionId: string | null | undefined, options?: UseMutationOptions<CommitClaimResponse, SyncReactError, ClaimCommitInput>): UseMutationResult<CommitClaimResponse, SyncReactError, ClaimCommitInput>;
+
+export { type ClaimCommitInput, type ClaimTransactionInput, type SyncClient, SyncProvider, type SyncProviderProps, SyncReactError, useClaimHistory, useClaimTransaction, useClaimableDistributions, useCommitClaim, useDistribution, useDistributions, useSyncClient };

package/dist/react/index.d.ts

@@ -0,0 +1,40 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { UseQueryOptions, UseQueryResult, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { g as ListDistributionsResponse, a as Distribution, o as ClaimableResponse, q as ClaimHistoryResponse, B as BuildClaimTransactionRequest, l as BuildClaimTransactionResponse, m as CommitClaimRequest, n as CommitClaimResponse } from '../api-CQqyHbnT.js';
+
+type Fetcher = typeof fetch;
+interface SyncContextValue {
+    basePath: string;
+    fetcher?: Fetcher;
+}
+interface SyncProviderProps {
+    basePath?: string;
+    fetcher?: Fetcher;
+    children: ReactNode;
+}
+declare function SyncProvider({ basePath, fetcher, children }: SyncProviderProps): react.FunctionComponentElement<react.ProviderProps<SyncContextValue>>;
+interface SyncClient {
+    basePath: string;
+    request<T>(path: string, init?: RequestInit): Promise<T>;
+    get<T>(path: string, init?: RequestInit): Promise<T>;
+    post<T>(path: string, body?: unknown, init?: RequestInit): Promise<T>;
+}
+declare function useSyncClient(): SyncClient;
+declare class SyncReactError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(status: number, code?: string | undefined, details?: unknown | undefined);
+}
+type QueryOptions<T> = Omit<UseQueryOptions<T, SyncReactError, T>, "queryKey" | "queryFn">;
+declare function useDistributions<TResponse = ListDistributionsResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+declare function useDistribution<TResponse = Distribution>(distributionId: string | null | undefined, options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+declare function useClaimableDistributions<TResponse = ClaimableResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+declare function useClaimHistory<TResponse = ClaimHistoryResponse>(options?: QueryOptions<TResponse>): UseQueryResult<TResponse, SyncReactError>;
+type ClaimTransactionInput = Partial<Omit<BuildClaimTransactionRequest, "distributionId" | "claimant">>;
+declare function useClaimTransaction(distributionId: string | null | undefined, options?: UseMutationOptions<BuildClaimTransactionResponse, SyncReactError, ClaimTransactionInput>): UseMutationResult<BuildClaimTransactionResponse, SyncReactError, ClaimTransactionInput>;
+type ClaimCommitInput = Omit<CommitClaimRequest, "distributionId">;
+declare function useCommitClaim(distributionId: string | null | undefined, options?: UseMutationOptions<CommitClaimResponse, SyncReactError, ClaimCommitInput>): UseMutationResult<CommitClaimResponse, SyncReactError, ClaimCommitInput>;
+
+export { type ClaimCommitInput, type ClaimTransactionInput, type SyncClient, SyncProvider, type SyncProviderProps, SyncReactError, useClaimHistory, useClaimTransaction, useClaimableDistributions, useCommitClaim, useDistribution, useDistributions, useSyncClient };