@sage-protocol/sdk 0.1.24 → 0.1.25

package/dist/node/index.cjs

@@ -14,7 +14,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.24",
+      version: "0.1.25",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -9789,6 +9789,335 @@ var require_contributions = __commonJS({
   }
 });
 
+// src/browser/reputation.js
+var require_reputation = __commonJS({
+  "src/browser/reputation.js"(exports2, module2) {
+    var { getAddress } = require_utils();
+    var subgraph = require_subgraph2();
+    function safeGetAddress(value) {
+      try {
+        return getAddress(value);
+      } catch {
+        return null;
+      }
+    }
+    function clampInt(value, { min = 1, max = 100, fallback = 100 } = {}) {
+      const n = Number(value);
+      if (!Number.isFinite(n)) return fallback;
+      return Math.min(max, Math.max(min, Math.trunc(n)));
+    }
+    function toBigIntString(value, fallback = "0") {
+      try {
+        if (typeof value === "bigint") return value.toString();
+        if (typeof value === "number") return String(Math.trunc(value));
+        const str = String(value).trim();
+        if (!str) return fallback;
+        if (!/^-?\d+$/.test(str)) return fallback;
+        return str;
+      } catch {
+        return fallback;
+      }
+    }
+    function mapSafe(list, mapper) {
+      const out = [];
+      for (const item of list || []) {
+        try {
+          const v = mapper(item);
+          if (v != null) out.push(v);
+        } catch {
+        }
+      }
+      return out;
+    }
+    async function getBadgesByRecipient({ url, recipient, first = 50 }) {
+      if (!url) throw new Error("subgraph url required");
+      if (!recipient) throw new Error("recipient required");
+      const addr = safeGetAddress(recipient);
+      if (!addr) throw new Error("invalid recipient address");
+      const doc = `
+    query($recipient: Bytes!, $first: Int!) {
+      soulboundBadges(
+        where: { recipient: $recipient }
+        first: $first
+        orderBy: blockTimestamp
+        orderDirection: desc
+      ) {
+        id
+        contract
+        badgeId
+        recipient
+        evidenceURI
+        blockNumber
+        blockTimestamp
+        transactionHash
+      }
+    }
+  `;
+      const data = await subgraph.query(url, doc, {
+        recipient: addr.toLowerCase(),
+        first: clampInt(first, { min: 1, max: 100, fallback: 50 })
+      });
+      return mapSafe(data?.soulboundBadges, (row) => {
+        const contract = safeGetAddress(row.contract);
+        const recipientAddr = safeGetAddress(row.recipient);
+        if (!contract || !recipientAddr) return null;
+        return {
+          id: String(row.id),
+          contract,
+          badgeId: toBigIntString(row.badgeId, "0"),
+          recipient: recipientAddr,
+          evidenceURI: row.evidenceURI || null,
+          blockNumber: Number(row.blockNumber || 0),
+          blockTimestamp: Number(row.blockTimestamp || 0),
+          transactionHash: row.transactionHash || null
+        };
+      });
+    }
+    async function listContributions({ url, contributor, subdao, first = 50, orderBy = "updatedAt", orderDirection = "desc" }) {
+      if (!url) throw new Error("subgraph url required");
+      const filters = [];
+      if (contributor) {
+        const addr = safeGetAddress(contributor);
+        if (!addr) throw new Error("invalid contributor address");
+        filters.push(`contributor: "${addr.toLowerCase()}"`);
+      }
+      if (subdao) {
+        const addr = safeGetAddress(subdao);
+        if (!addr) throw new Error("invalid subdao address");
+        filters.push(`dao: "${addr.toLowerCase()}"`);
+      }
+      const where = filters.length ? `where: { ${filters.join(", ")} }` : "";
+      const safeOrderBy = ["updatedAt", "createdAt"].includes(orderBy) ? orderBy : "updatedAt";
+      const safeOrderDirection = orderDirection === "asc" ? "asc" : "desc";
+      const doc = `
+    query($first: Int!) {
+      promptContributions(
+        ${where}
+        first: $first
+        orderBy: ${safeOrderBy}
+        orderDirection: ${safeOrderDirection}
+      ) {
+        id
+        dao
+        promptKey
+        contributor
+        cid
+        proposalId
+        forVotes
+        againstVotes
+        abstainVotes
+        uniqueVoters
+        quorum
+        fromBounty
+        bountyId
+        badgeId
+        badgeEvidenceURI
+        createdAt
+        updatedAt
+        transactionHash
+      }
+    }
+  `;
+      const data = await subgraph.query(url, doc, {
+        first: clampInt(first, { min: 1, max: 100, fallback: 50 })
+      });
+      return mapSafe(data?.promptContributions, (row) => {
+        const dao = safeGetAddress(row.dao);
+        const contributorAddr = safeGetAddress(row.contributor);
+        if (!dao) return null;
+        return {
+          id: String(row.id),
+          dao,
+          promptKey: String(row.promptKey),
+          contributor: contributorAddr || "0x0000000000000000000000000000000000000000",
+          cid: String(row.cid),
+          timestamp: Number(row.updatedAt || 0),
+          createdAt: Number(row.createdAt || 0),
+          updatedAt: Number(row.updatedAt || 0),
+          transactionHash: row.transactionHash || null,
+          proposalId: row.proposalId != null ? toBigIntString(row.proposalId) : null,
+          forVotes: row.forVotes != null ? toBigIntString(row.forVotes) : null,
+          againstVotes: row.againstVotes != null ? toBigIntString(row.againstVotes) : null,
+          abstainVotes: row.abstainVotes != null ? toBigIntString(row.abstainVotes) : null,
+          uniqueVoters: row.uniqueVoters != null ? Number(row.uniqueVoters) : null,
+          quorum: row.quorum != null ? toBigIntString(row.quorum) : null,
+          fromBounty: Boolean(row.fromBounty),
+          bountyId: row.bountyId != null ? toBigIntString(row.bountyId) : null,
+          badgeId: row.badgeId != null ? toBigIntString(row.badgeId) : null,
+          badgeEvidenceURI: row.badgeEvidenceURI || null
+        };
+      });
+    }
+    function computeAggregates(contributions) {
+      if (!contributions || contributions.length === 0) {
+        return {
+          totalContributions: 0,
+          uniqueContributors: 0,
+          bountyOriginated: 0,
+          governanceOriginated: 0,
+          totalForVotes: "0",
+          totalAgainstVotes: "0",
+          averageVoterCount: 0,
+          badgeCount: 0
+        };
+      }
+      const contributorSet = /* @__PURE__ */ new Set();
+      let bountyOriginated = 0;
+      let governanceOriginated = 0;
+      let totalForVotes = 0n;
+      let totalAgainstVotes = 0n;
+      let voterCountSum = 0;
+      let voterCountN = 0;
+      let badgeCount = 0;
+      for (const c of contributions) {
+        if (c.contributor) contributorSet.add(c.contributor.toLowerCase());
+        if (c.fromBounty) {
+          bountyOriginated++;
+        } else {
+          governanceOriginated++;
+        }
+        if (c.forVotes != null) {
+          try {
+            totalForVotes += BigInt(c.forVotes);
+          } catch {
+          }
+        }
+        if (c.againstVotes != null) {
+          try {
+            totalAgainstVotes += BigInt(c.againstVotes);
+          } catch {
+          }
+        }
+        if (c.uniqueVoters != null) {
+          voterCountSum += c.uniqueVoters;
+          voterCountN++;
+        }
+        if (c.badgeId != null) badgeCount++;
+      }
+      return {
+        totalContributions: contributions.length,
+        uniqueContributors: contributorSet.size,
+        bountyOriginated,
+        governanceOriginated,
+        totalForVotes: totalForVotes.toString(),
+        totalAgainstVotes: totalAgainstVotes.toString(),
+        averageVoterCount: voterCountN > 0 ? Math.round(voterCountSum / voterCountN) : 0,
+        badgeCount
+      };
+    }
+    async function getByAddress({
+      url,
+      address,
+      subdao,
+      includeBadges = true,
+      includeContributions = true,
+      first = 100
+    } = {}) {
+      if (!url) throw new Error("subgraph url required");
+      if (!address) throw new Error("address required");
+      const addr = safeGetAddress(address);
+      if (!addr) throw new Error("invalid address");
+      const subdaoAddr = subdao ? safeGetAddress(subdao) : null;
+      if (subdao && !subdaoAddr) throw new Error("invalid subdao address");
+      const limit = clampInt(first, { min: 1, max: 200, fallback: 100 });
+      let badges = void 0;
+      if (includeBadges) {
+        badges = await getBadgesByRecipient({ url, recipient: addr, first: limit });
+      }
+      let contributionAggregates = void 0;
+      let lastContributionAt = null;
+      if (includeContributions) {
+        const rows = await listContributions({
+          url,
+          contributor: addr,
+          subdao: subdaoAddr || void 0,
+          first: limit,
+          orderBy: "updatedAt",
+          orderDirection: "desc"
+        });
+        if (rows && rows.length) {
+          const updatedAt = rows[0]?.updatedAt ?? rows[0]?.timestamp ?? null;
+          lastContributionAt = updatedAt != null ? Number(updatedAt) : null;
+          if (!Number.isFinite(lastContributionAt)) lastContributionAt = null;
+        }
+        contributionAggregates = computeAggregates(rows || []);
+      }
+      const signals = {
+        badgeCount: includeBadges ? badges ? badges.length : 0 : null,
+        totalContributions: includeContributions ? contributionAggregates ? contributionAggregates.totalContributions : 0 : null,
+        governanceOriginated: includeContributions ? contributionAggregates ? contributionAggregates.governanceOriginated : 0 : null,
+        bountyOriginated: includeContributions ? contributionAggregates ? contributionAggregates.bountyOriginated : 0 : null,
+        lastContributionAt: includeContributions ? lastContributionAt : null
+      };
+      const out = {
+        address: addr,
+        subdao: subdaoAddr || null,
+        signals
+      };
+      if (includeBadges) out.badges = badges;
+      if (includeContributions) {
+        out.contributionAggregates = contributionAggregates;
+        out.lastContributionAt = lastContributionAt;
+      }
+      return out;
+    }
+    function normalizeGateInt(value, name) {
+      if (value === void 0 || value === null) return null;
+      const n = Number(value);
+      if (!Number.isFinite(n) || n < 0) {
+        throw new Error(`invalid gate: ${name}`);
+      }
+      return Math.trunc(n);
+    }
+    function normalizeRequiredBadgeIds(value) {
+      const list = Array.isArray(value) ? value : value != null ? [value] : [];
+      const out = [];
+      for (const item of list) {
+        const id2 = toBigIntString(item, "");
+        if (id2) out.push(id2);
+      }
+      return out;
+    }
+    function evaluate(result, gates = {}) {
+      const reasons = [];
+      const minBadges = normalizeGateInt(gates.minBadges, "minBadges");
+      const minContributions = normalizeGateInt(gates.minContributions, "minContributions");
+      const requiredBadges = normalizeRequiredBadgeIds(gates.requireBadges ?? gates.requireBadge);
+      const badgeCount = Number(result?.signals?.badgeCount ?? (result?.badges?.length ?? 0));
+      const totalContributions = Number(result?.signals?.totalContributions ?? (result?.contributionAggregates?.totalContributions ?? 0));
+      if (minBadges != null) {
+        if (!Number.isFinite(badgeCount)) {
+          reasons.push("badges_unavailable");
+        } else if (badgeCount < minBadges) {
+          reasons.push(`minBadges:${badgeCount}<${minBadges}`);
+        }
+      }
+      if (minContributions != null) {
+        if (!Number.isFinite(totalContributions)) {
+          reasons.push("contributions_unavailable");
+        } else if (totalContributions < minContributions) {
+          reasons.push(`minContributions:${totalContributions}<${minContributions}`);
+        }
+      }
+      if (requiredBadges.length) {
+        const have = new Set((result?.badges || []).map((b) => toBigIntString(b?.badgeId, "")).filter(Boolean));
+        for (const req2 of requiredBadges) {
+          if (!have.has(req2)) reasons.push(`missingBadge:${req2}`);
+        }
+      }
+      return { ok: reasons.length === 0, reasons };
+    }
+    module2.exports = {
+      getByAddress,
+      evaluate,
+      // Expose lower-level functions for advanced usage
+      getBadgesByRecipient,
+      listContributions,
+      computeAggregates
+    };
+  }
+});
+
 // src/votingMultiplier/index.js
 var require_votingMultiplier = __commonJS({
   "src/votingMultiplier/index.js"(exports2, module2) {
@@ -14043,6 +14372,7 @@ var require_src = __commonJS({
     var boost = require_boost();
     var bounty = require_bounty();
     var contributions = require_contributions();
+    var reputation = require_reputation();
     var votingMultiplier = require_votingMultiplier();
     var auction = require_auction();
     var wallet = require_wallet();
@@ -14096,6 +14426,7 @@ var require_src = __commonJS({
       utils: { ...utils, privateTx, safe, time },
       bounty,
       contributions,
+      reputation,
       votingMultiplier,
       auction,
       wallet: Object.assign(wallet, {