@zenland/sdk 0.1.0

package/dist/react.js

@@ -0,0 +1,704 @@
+"use client";
+
+// src/react/context.tsx
+import { createContext, useContext, useMemo } from "react";
+
+// src/request.ts
+var ZenlandGraphQLError = class extends Error {
+  errors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "ZenlandGraphQLError";
+    this.errors = errors;
+  }
+};
+var ZenlandRequestError = class extends Error {
+  status;
+  statusText;
+  constructor(message, status, statusText) {
+    super(message);
+    this.name = "ZenlandRequestError";
+    this.status = status;
+    this.statusText = statusText;
+  }
+};
+async function graphqlRequest(baseUrl, document, variables, options) {
+  const endpoint = `${baseUrl}/graphql`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({ query: document, variables }),
+    signal: options?.signal,
+    cache: "no-store"
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new ZenlandRequestError(
+      `Zenland request failed (${res.status} ${res.statusText})${text ? `: ${text}` : ""}`,
+      res.status,
+      res.statusText
+    );
+  }
+  const json = await res.json();
+  if (json.errors?.length) {
+    throw new ZenlandGraphQLError(
+      json.errors.map((e) => e.message ?? "GraphQL error").join("; "),
+      json.errors
+    );
+  }
+  if (!json.data) {
+    throw new Error("Zenland response missing data.");
+  }
+  return json.data;
+}
+
+// src/queries.ts
+var AGENT_QUERY = `
+query Agent($id: String!) {
+  agent(id: $id) {
+    id
+    isActive
+    isAvailable
+    stablecoinDecimals
+    stablecoinToken
+    stablecoinStake
+    daoTokenStake
+    disputeFeeBps
+    assignmentFeeBps
+    description
+    contact
+    totalResolved
+    activeCases
+    registrationTime
+    lastEngagementTimestamp
+    totalEarnings
+    totalSlashed
+    cases(limit: 5, orderBy: "invitedAt", orderDirection: "desc") {
+      items {
+        id
+        escrow
+        invitedAt
+        resolvedAt
+        timedOut
+        escrowRef {
+          id
+          amount
+          token
+          state
+        }
+      }
+      totalCount
+    }
+  }
+}
+`;
+var AGENTS_QUERY = `
+query Agents($where: agentFilter, $orderBy: String, $orderDirection: String, $limit: Int, $offset: Int) {
+  agents(where: $where, orderBy: $orderBy, orderDirection: $orderDirection, limit: $limit, offset: $offset) {
+    totalCount
+    items {
+      id
+      isActive
+      isAvailable
+      stablecoinDecimals
+      stablecoinStake
+      daoTokenStake
+      disputeFeeBps
+      assignmentFeeBps
+      description
+      contact
+      totalResolved
+      activeCases
+      registrationTime
+      lastEngagementTimestamp
+      totalEarnings
+      totalSlashed
+    }
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+    }
+  }
+}
+`;
+var ESCROW_QUERY = `
+query escrow($id: String!) {
+  escrow(id: $id) {
+    id
+    buyer
+    seller
+    agent
+    amount
+    token
+    state
+    createdAt
+    sellerAcceptDeadline
+    buyerProtectionTime
+    termsHash
+    version
+    fundedAt
+    fulfilledAt
+    resolvedAt
+    agentInvitedAt
+    splitProposer
+    proposedBuyerBps
+    proposedSellerBps
+    buyerApprovedSplit
+    sellerApprovedSplit
+    agentFeeReceived
+    buyerReceived
+    sellerReceived
+    creationFee
+  }
+}
+`;
+var ESCROWS_QUERY = `
+query escrows(
+  $limit: Int = 30
+  $offset: Int = 0
+  $orderBy: String = "createdAt"
+  $orderDirection: String = "desc"
+  $where: escrowFilter
+) {
+  escrows(
+    limit: $limit
+    offset: $offset
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+    where: $where
+  ) {
+    items {
+      id
+      buyer
+      seller
+      agent
+      amount
+      token
+      state
+      createdAt
+      fundedAt
+      fulfilledAt
+      sellerAcceptDeadline
+      agentInvitedAt
+      buyerProtectionTime
+      splitProposer
+      buyerApprovedSplit
+      sellerApprovedSplit
+      proposedBuyerBps
+      proposedSellerBps
+    }
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+    }
+    totalCount
+  }
+}
+`;
+var PROTOCOL_STATS_QUERY = `
+query protocolStats($id: String! = "global") {
+  protocolStats(id: $id) {
+    id
+    totalEscrowsCreated
+    totalVolumeEscrowed
+    totalFeesCollected
+    currentTVL
+    activeEscrowCount
+    totalAgentsRegistered
+    activeAgentsCount
+  }
+}
+`;
+var TRANSACTION_LOGS_QUERY = `
+query transactionLogs(
+  $escrowAddress: String
+  $limit: Int
+  $offset: Int
+  $orderBy: String
+  $orderDirection: String
+) {
+  transactionLogs(
+    where: { escrowAddress: $escrowAddress }
+    limit: $limit
+    offset: $offset
+    orderBy: $orderBy
+    orderDirection: $orderDirection
+  ) {
+    items {
+      id
+      txHash
+      blockNumber
+      timestamp
+      eventName
+      contractAddress
+      contractType
+      escrowAddress
+      agentAddress
+      userAddress
+      eventData
+    }
+  }
+}
+`;
+
+// src/domains/escrows.ts
+var STATE_GROUPS = {
+  ACTIVE: ["PENDING", "ACTIVE", "FULFILLED"],
+  IN_DISPUTE: ["DISPUTED", "AGENT_INVITED"],
+  COMPLETED: ["RELEASED", "AGENT_RESOLVED", "REFUNDED", "SPLIT"]
+};
+function createEscrowsDomain(baseUrl) {
+  async function list(args) {
+    const where = {};
+    if (args?.buyer) where.buyer = args.buyer.toLowerCase();
+    if (args?.seller) where.seller = args.seller.toLowerCase();
+    if (args?.agent) where.agent = args.agent.toLowerCase();
+    if (args?.states && args.states.length > 0) {
+      where.state_in = args.states;
+    } else if (args?.state) {
+      where.state = args.state;
+    }
+    if (args?.user) {
+      const userLower = args.user.toLowerCase();
+      where.OR = [{ buyer: userLower }, { seller: userLower }, { agent: userLower }];
+    }
+    const variables = {
+      limit: args?.limit ?? 30,
+      offset: args?.offset ?? 0,
+      orderBy: args?.orderBy ?? "createdAt",
+      orderDirection: args?.orderDirection ?? "desc",
+      where: Object.keys(where).length > 0 ? where : void 0
+    };
+    const response = await graphqlRequest(
+      baseUrl,
+      ESCROWS_QUERY,
+      variables
+    );
+    return response.escrows;
+  }
+  async function getById(id) {
+    const variables = { id: id.toLowerCase() };
+    const response = await graphqlRequest(
+      baseUrl,
+      ESCROW_QUERY,
+      variables
+    );
+    return response.escrow;
+  }
+  async function getByUser(userAddress, args) {
+    return list({ ...args, user: userAddress });
+  }
+  async function getByStateGroup(stateGroup, args) {
+    return list({ ...args, states: [...STATE_GROUPS[stateGroup]] });
+  }
+  return {
+    list,
+    getById,
+    getByUser,
+    getByStateGroup
+  };
+}
+
+// src/domains/agents.ts
+function createAgentsDomain(baseUrl) {
+  async function list(args) {
+    const where = {};
+    if (args?.onlyActive) where.isActive = true;
+    if (args?.onlyAvailable) where.isAvailable = true;
+    const variables = {
+      limit: args?.limit ?? 30,
+      offset: args?.offset ?? 0,
+      orderBy: args?.orderBy ?? "totalResolved",
+      orderDirection: args?.orderDirection ?? "desc",
+      where: Object.keys(where).length > 0 ? where : void 0
+    };
+    const response = await graphqlRequest(
+      baseUrl,
+      AGENTS_QUERY,
+      variables
+    );
+    return response.agents;
+  }
+  async function getById(id) {
+    const variables = { id: id.toLowerCase() };
+    const response = await graphqlRequest(
+      baseUrl,
+      AGENT_QUERY,
+      variables
+    );
+    return response.agent;
+  }
+  async function getAvailable(args) {
+    return list({ ...args, onlyActive: true, onlyAvailable: true });
+  }
+  return {
+    list,
+    getById,
+    getAvailable
+  };
+}
+
+// src/domains/protocol-stats.ts
+function normalizeProtocolStats(raw) {
+  return {
+    id: raw.id,
+    totalEscrowsCreated: raw.totalEscrowsCreated,
+    totalVolumeEscrowed: BigInt(raw.totalVolumeEscrowed),
+    totalFeesCollected: BigInt(raw.totalFeesCollected),
+    currentTVL: BigInt(raw.currentTVL),
+    activeEscrowCount: raw.activeEscrowCount,
+    totalAgentsRegistered: raw.totalAgentsRegistered,
+    activeAgentsCount: raw.activeAgentsCount
+  };
+}
+function createProtocolStatsDomain(baseUrl) {
+  async function get() {
+    const variables = { id: "global" };
+    const response = await graphqlRequest(
+      baseUrl,
+      PROTOCOL_STATS_QUERY,
+      variables
+    );
+    if (!response.protocolStats) {
+      return null;
+    }
+    return normalizeProtocolStats(response.protocolStats);
+  }
+  async function getRaw() {
+    const variables = { id: "global" };
+    const response = await graphqlRequest(
+      baseUrl,
+      PROTOCOL_STATS_QUERY,
+      variables
+    );
+    return response.protocolStats;
+  }
+  return {
+    get,
+    getRaw
+  };
+}
+
+// src/domains/transaction-logs.ts
+function createTransactionLogsDomain(baseUrl) {
+  async function list(args) {
+    const variables = {
+      escrowAddress: args?.escrowAddress?.toLowerCase(),
+      limit: args?.limit ?? 100,
+      offset: args?.offset ?? 0,
+      orderBy: args?.orderBy ?? "timestamp",
+      orderDirection: args?.orderDirection ?? "asc"
+    };
+    const response = await graphqlRequest(
+      baseUrl,
+      TRANSACTION_LOGS_QUERY,
+      variables
+    );
+    return response.transactionLogs.items;
+  }
+  async function getByEscrow(escrowAddress, args) {
+    return list({ ...args, escrowAddress });
+  }
+  function parseEventData(eventData) {
+    try {
+      return JSON.parse(eventData);
+    } catch {
+      return {};
+    }
+  }
+  return {
+    list,
+    getByEscrow,
+    parseEventData
+  };
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.zen.land";
+function createZenlandClient(config) {
+  const baseUrl = normalizeBaseUrl(config?.baseUrl ?? DEFAULT_BASE_URL);
+  return {
+    baseUrl,
+    escrows: createEscrowsDomain(baseUrl),
+    agents: createAgentsDomain(baseUrl),
+    protocolStats: createProtocolStatsDomain(baseUrl),
+    transactionLogs: createTransactionLogsDomain(baseUrl)
+  };
+}
+function normalizeBaseUrl(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+var zenland = createZenlandClient();
+
+// src/react/context.tsx
+import { jsx } from "react/jsx-runtime";
+var ZenlandContext = createContext(null);
+function ZenlandProvider({ children, config }) {
+  const client = useMemo(() => createZenlandClient(config), [config]);
+  return /* @__PURE__ */ jsx(ZenlandContext.Provider, { value: client, children });
+}
+function useZenlandClient() {
+  const context = useContext(ZenlandContext);
+  if (!context) {
+    throw new Error("useZenlandClient must be used within a ZenlandProvider");
+  }
+  return context;
+}
+function useZenlandClientOptional() {
+  const context = useContext(ZenlandContext);
+  return useMemo(() => context ?? createZenlandClient(), [context]);
+}
+
+// src/react/hooks/useEscrow.ts
+import { useQuery } from "@tanstack/react-query";
+function useEscrow(id, options) {
+  const client = useZenlandClientOptional();
+  return useQuery({
+    queryKey: ["zenland", "escrow", id],
+    queryFn: () => {
+      if (!id) return null;
+      return client.escrows.getById(id);
+    },
+    enabled: !!id && (options?.enabled ?? true)
+  });
+}
+
+// src/react/hooks/useEscrows.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useEscrows(args) {
+  const client = useZenlandClientOptional();
+  const { address, role = "all", stateTab, enabled = true } = args ?? {};
+  const getStatesFromTab = () => {
+    if (!stateTab || stateTab === "all") {
+      return args?.states;
+    }
+    return [...STATE_GROUPS[stateTab]];
+  };
+  return useQuery2({
+    queryKey: ["zenland", "escrows", address, role, stateTab, args?.state, args?.states, args?.limit, args?.offset],
+    queryFn: async () => {
+      if (!address) {
+        return { items: [], totalCount: 0, pageInfo: { hasNextPage: false, hasPreviousPage: false } };
+      }
+      const states = getStatesFromTab();
+      return client.escrows.list({
+        limit: args?.limit,
+        offset: args?.offset,
+        buyer: role === "buyer" ? address : void 0,
+        seller: role === "seller" ? address : void 0,
+        agent: role === "agent" ? address : void 0,
+        user: role === "all" ? address : void 0,
+        state: args?.state,
+        states
+      });
+    },
+    enabled: !!address && enabled
+  });
+}
+
+// src/react/hooks/useAgent.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+function useAgent(address, options) {
+  const client = useZenlandClientOptional();
+  return useQuery3({
+    queryKey: ["zenland", "agent", address],
+    queryFn: () => {
+      if (!address) return null;
+      return client.agents.getById(address);
+    },
+    enabled: !!address && (options?.enabled ?? true)
+  });
+}
+
+// src/react/hooks/useAgents.ts
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+function useAgents(args) {
+  const client = useZenlandClientOptional();
+  const { enabled = true, ...filterArgs } = args ?? {};
+  return useQuery4({
+    queryKey: ["zenland", "agents", filterArgs.onlyActive, filterArgs.onlyAvailable, filterArgs.limit, filterArgs.offset],
+    queryFn: () => client.agents.list(filterArgs),
+    enabled
+  });
+}
+
+// src/react/hooks/useProtocolStats.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+function useProtocolStats(options) {
+  const client = useZenlandClientOptional();
+  return useQuery5({
+    queryKey: ["zenland", "protocolStats"],
+    queryFn: () => client.protocolStats.get(),
+    enabled: options?.enabled ?? true,
+    staleTime: options?.staleTime ?? 30 * 1e3,
+    // 30 seconds
+    refetchInterval: options?.refetchInterval ?? 60 * 1e3
+    // 1 minute
+  });
+}
+
+// src/react/hooks/useRecentEscrows.ts
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+function useRecentEscrows(options) {
+  const client = useZenlandClientOptional();
+  const limit = options?.limit ?? 5;
+  return useQuery6({
+    queryKey: ["zenland", "recentEscrows", limit],
+    queryFn: async () => {
+      const result = await client.escrows.list({
+        limit,
+        orderBy: "createdAt",
+        orderDirection: "desc"
+      });
+      return result.items;
+    },
+    enabled: options?.enabled ?? true,
+    staleTime: options?.staleTime ?? 15 * 1e3,
+    // 15 seconds
+    refetchInterval: options?.refetchInterval ?? 30 * 1e3
+    // 30 seconds
+  });
+}
+
+// src/react/hooks/useUserStats.ts
+import { useQuery as useQuery7 } from "@tanstack/react-query";
+var ACTIVE_STATES = STATE_GROUPS.ACTIVE;
+var DISPUTE_STATES = STATE_GROUPS.IN_DISPUTE;
+var COMPLETED_STATES = STATE_GROUPS.COMPLETED;
+var TVL_STATES = [...ACTIVE_STATES, ...DISPUTE_STATES];
+async function fetchUserEscrowCount(client, userAddress, states) {
+  const userLower = userAddress.toLowerCase();
+  const result = await client.escrows.list({
+    limit: 1,
+    user: userLower,
+    states: [...states]
+  });
+  return result.totalCount;
+}
+async function fetchUserTVL(client, userAddress) {
+  const userLower = userAddress.toLowerCase();
+  const result = await client.escrows.list({
+    limit: 1e3,
+    user: userLower,
+    states: [...TVL_STATES]
+  });
+  return result.items.reduce((sum, escrow) => sum + BigInt(escrow.amount), BigInt(0));
+}
+async function fetchUserRecentEscrows(client, userAddress, limit = 5) {
+  const userLower = userAddress.toLowerCase();
+  const result = await client.escrows.list({
+    limit,
+    user: userLower
+  });
+  return result.items;
+}
+async function getUserDashboardStats(client, userAddress) {
+  const [activeCount, disputeCount, completedCount, tvl, recentEscrows] = await Promise.all([
+    fetchUserEscrowCount(client, userAddress, ACTIVE_STATES),
+    fetchUserEscrowCount(client, userAddress, DISPUTE_STATES),
+    fetchUserEscrowCount(client, userAddress, COMPLETED_STATES),
+    fetchUserTVL(client, userAddress),
+    fetchUserRecentEscrows(client, userAddress, 5)
+  ]);
+  return {
+    activeCount,
+    disputeCount,
+    completedCount,
+    tvl,
+    recentEscrows
+  };
+}
+async function getGlobalDashboardStats(client) {
+  const [activeCount, disputeCount, completedCount, recentEscrows] = await Promise.all([
+    fetchGlobalEscrowCount(client, [...ACTIVE_STATES]),
+    fetchGlobalEscrowCount(client, [...DISPUTE_STATES]),
+    fetchGlobalEscrowCount(client, [...COMPLETED_STATES]),
+    fetchGlobalRecentEscrows(client, 5)
+  ]);
+  return {
+    activeCount,
+    disputeCount,
+    completedCount,
+    tvl: null,
+    recentEscrows
+  };
+}
+async function fetchGlobalEscrowCount(client, states) {
+  const result = await client.escrows.list({
+    limit: 1,
+    states
+  });
+  return result.totalCount;
+}
+async function fetchGlobalRecentEscrows(client, limit = 5) {
+  const result = await client.escrows.list({ limit });
+  return result.items;
+}
+function useUserStats(userAddress) {
+  const client = useZenlandClientOptional();
+  return useQuery7({
+    queryKey: ["zenland", "userStats", userAddress],
+    queryFn: async () => {
+      if (!userAddress) return null;
+      return getUserDashboardStats(client, userAddress);
+    },
+    enabled: !!userAddress,
+    staleTime: 15 * 1e3,
+    refetchInterval: 30 * 1e3
+  });
+}
+function useGlobalStats() {
+  const client = useZenlandClientOptional();
+  return useQuery7({
+    queryKey: ["zenland", "globalStats"],
+    queryFn: () => getGlobalDashboardStats(client),
+    staleTime: 30 * 1e3,
+    refetchInterval: 60 * 1e3
+  });
+}
+
+// src/react/hooks/useTransactionLogsByEscrow.ts
+import { useQuery as useQuery8 } from "@tanstack/react-query";
+function useTransactionLogsByEscrow(escrowAddress, options) {
+  const client = useZenlandClientOptional();
+  const addr = escrowAddress?.toLowerCase();
+  return useQuery8({
+    queryKey: [
+      "zenland",
+      "transactionLogs",
+      "escrow",
+      addr,
+      options?.list?.limit,
+      options?.list?.offset,
+      options?.list?.orderBy,
+      options?.list?.orderDirection
+    ],
+    queryFn: async () => {
+      if (!addr) return [];
+      return client.transactionLogs.getByEscrow(addr, options?.list);
+    },
+    enabled: !!addr && (options?.enabled ?? true),
+    staleTime: options?.staleTime ?? 3e4,
+    refetchInterval: options?.refetchInterval,
+    refetchOnWindowFocus: false
+  });
+}
+export {
+  STATE_GROUPS,
+  ZenlandProvider,
+  createZenlandClient,
+  useAgent,
+  useAgents,
+  useEscrow,
+  useEscrows,
+  useGlobalStats,
+  useProtocolStats,
+  useRecentEscrows,
+  useTransactionLogsByEscrow,
+  useUserStats,
+  useZenlandClient,
+  useZenlandClientOptional
+};
+//# sourceMappingURL=react.js.map