@sage-protocol/sdk 0.1.23 → 0.1.25

package/dist/browser/index.mjs

@@ -14,7 +14,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.23",
+      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",
@@ -106,20 +106,21 @@ var require_abi = __commonJS({
     var SubDAO = [
       "function governor() view returns (address)",
       "function timelock() view returns (address)",
+      // SubDAO ops Safe / treasury (multisig) address. On newer deployments opsSafe() is an alias.
+      "function treasury() view returns (address)",
+      "function opsSafe() view returns (address)",
       "function getGovernanceMode() view returns (uint8)",
+      // New governance profile (3-axis model). May be unavailable on legacy SubDAOs.
+      "function profileInitialized() view returns (bool)",
+      "function getGovernanceProfile() view returns (uint8 kind, uint8 proposalAccess, uint8 executionAccess)",
       "function promptRegistry() view returns (address)",
       "function sageTreasury() view returns (address)",
-      "function stakeToken() view returns (address)",
-      "function minStakeAmount() view returns (uint256)",
       "function accessModel() view returns (uint8)",
       "function membershipPolicy() view returns (uint8)",
       "function profileCID() view returns (string)",
       "function factoryDeployer() view returns (address)",
-      "function stakedAmount(address) view returns (uint256)",
       "function userForkCount(address) view returns (uint256)",
       "function forkCount(string) view returns (uint256)",
-      "function stake(uint256)",
-      "function unstake(uint256)",
       // Fork functions
       "function forkSubDAO(string,string)",
       "function forkSubDAO(string,string,bool)",
@@ -159,7 +160,7 @@ var require_abi = __commonJS({
     var FactoryWrite = [
       "function createSubDAO(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount) returns (address subDAO, address registry)",
       "function createSubDAOWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
-      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID) returns (address subDAO, address registry)",
+      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID, string manifestCID, string manifestVersion) returns (address subDAO, address registry)",
       "function createSubDAOOperatorWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
       "function createSubDAOOperatorWithStableAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
       "function createSubDAOOperator(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin) returns (address subDAO, address registry)",
@@ -176,19 +177,21 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee)",
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee, uint256 nonce)",
       "function daoTimelock(address) view returns (address)",
-      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee))",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee, uint256 nonce))",
       "function getLibraryForkFee(address dao) view returns (uint256)",
       "function setLibraryForkFee(address dao, uint256 fee)",
       "function updateLibrary(address dao, string manifestCID, string version)",
+      "function updateLibraryCAS(address dao, string manifestCID, string version, uint256 expectedNonce)",
       "function registerDAO(address dao, address timelock)",
       "function registerForkedDAO(address childDAO, address childTimelock, address parentDAO, string manifestCID, string version)",
       "function initializeLibraryFromFork(address sourceDao, address forkedDao)",
-      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version)",
+      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version, uint256 nonce)",
       "event DAORegistered(address indexed dao, address indexed timelock)",
       "event LibraryForked(address indexed sourceDao, address indexed forkedDao, string manifestCID)",
-      "event LibraryForkFeeUpdated(address indexed dao, uint256 fee)"
+      "event LibraryForkFeeUpdated(address indexed dao, uint256 fee)",
+      "error NonceMismatch(uint256 expected, uint256 actual)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",
@@ -215,14 +218,23 @@ var require_abi = __commonJS({
     ];
     var Governor = [
       "function name() view returns (string)",
+      // ERC6372 clock (Governor uses this for vote snapshots)
+      "function clock() view returns (uint48)",
       "function timelock() view returns (address)",
       "function _executor() view returns (address)",
       "function sxxxToken() view returns (address)",
       "function votingDelay() view returns (uint256)",
       "function votingPeriod() view returns (uint256)",
       "function proposalThreshold() view returns (uint256)",
+      "function minVotesToVote() view returns (uint256)",
+      // OZ Governor: voting power at a past timepoint
+      "function getVotes(address,uint256) view returns (uint256)",
       // OZ Governor: quorum at a past block
       "function quorum(uint256) view returns (uint256)",
+      // Fixed quorumVotes model (PromptGovernor v2+)
+      "function quorumVotes() view returns (uint256)",
+      "function setQuorumVotes(uint256)",
+      // Legacy OZ Governor: percentage-based quorum (deprecated)
       "function quorumNumerator() view returns (uint256)",
       "function proposalStakeAmount(uint256) view returns (uint256)",
       "function state(uint256) view returns (uint8)",
@@ -235,9 +247,24 @@ var require_abi = __commonJS({
       "function castVoteWithReason(uint256 proposalId, uint8 support, string reason) returns (uint256)",
       "function queue(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash)",
       "function execute(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash)",
+      "function cancel(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) returns (uint256)",
       // Some Governors expose id-based queue/execute via TimelockController
       "function queue(uint256)",
-      "function execute(uint256)"
+      "function execute(uint256)",
+      // Threshold model (PromptGovernor)
+      "function proposalProposer(uint256 proposalId) view returns (address)",
+      "function proposalThresholdSnapshot(uint256 proposalId) view returns (uint256)",
+      "function proposalCreator(uint256 proposalId) view returns (address)",
+      "function proposalCooldown() view returns (uint256)",
+      "function lastProposalTimestamp(address) view returns (uint256)",
+      "function getProposalCooldownInfo(address) view returns (bool canPropose, uint256 cooldownRemaining)",
+      "function canCreateProposal(address) view returns (bool)",
+      "function setMinVotesToVote(uint256)",
+      // Multiplier helpers
+      "function baseVotesToken() view returns (address)",
+      "function isMultiplierEnabled() view returns (bool)",
+      "function multiplierNFT() view returns (address)",
+      "function getVotingBreakdown(address) view returns (uint256 baseVotes, uint256 multiplier, uint256 effectiveVotes)"
     ];
     var Timelock = [
       "function getMinDelay() view returns (uint256)",
@@ -457,13 +484,11 @@ var require_abi = __commonJS({
       "function governanceConfig() view returns (address)",
       "function communityTreasury() view returns (address)",
       "function governanceContract() view returns (address)",
-      "function libraryRegistry() view returns (address)",
       "function subdao() view returns (address)",
       "function soulboundBadge() view returns (address)",
       // Admin
       "function setGovernanceContract(address _gov)",
       "function setCommunityTreasury(address _treasury)",
-      "function setLibraryRegistry(address _registry)",
       "function setSoulboundBadge(address _sbtAddress)",
       "function grantRole(bytes32 role, address account)",
       "function revokeRole(bytes32 role, address account)",
@@ -477,7 +502,7 @@ var require_abi = __commonJS({
       "event VotingStarted(uint256 indexed bountyId, uint256 votingEndTime)",
       "event BountyCompleted(uint256 indexed bountyId, address indexed winner, uint256 reward, string deliverable)",
       "event BountyAutoApproved(uint256 indexed bountyId, address indexed winner)",
-      "event PromptAddedToLibrary(uint256 indexed bountyId, string libraryKey, string promptIPFS)",
+      "event BountyWinnerSelected(uint256 indexed bountyId, address indexed subdao, string libraryKey, string winnerCid, address indexed winner, uint8 libraryAction)",
       "event BountyCancelled(uint256 indexed bountyId, address indexed creator)",
       "event BountyExpired(uint256 indexed bountyId)",
       "event BountyRewardIncreased(uint256 indexed bountyId, uint256 additionalReward, uint256 newTotal)",
@@ -1316,8 +1341,9 @@ var require_ipfs = __commonJS({
           baseUrl: removeTrailingSlash(options.workerBaseUrl || env.SAGE_IPFS_WORKER_URL || ""),
           uploadUrl: removeTrailingSlash(options.workerUploadUrl || env.SAGE_IPFS_UPLOAD_URL || ""),
           token: options.workerUploadToken || env.SAGE_IPFS_UPLOAD_TOKEN || "",
-          challengePath: options.workerChallengePath || env.SAGE_IPFS_WORKER_CHALLENGE_PATH || "/auth/challenge",
+          challengePath: options.workerChallengePath || env.SAGE_IPFS_WORKER_CHALLENGE_PATH || "/ipfs/auth/challenge",
           uploadPath: options.workerUploadPath || env.SAGE_IPFS_WORKER_UPLOAD_PATH || "/ipfs/upload",
+          uploadRawPath: options.workerUploadRawPath || env.SAGE_IPFS_WORKER_UPLOAD_RAW_PATH || "/ipfs/upload-raw",
           pinPath: options.workerPinPath || env.SAGE_IPFS_WORKER_PIN_PATH || "/ipfs/pin",
           warmPath: options.workerWarmPath || env.SAGE_IPFS_WORKER_WARM_PATH || "/ipfs/warm",
           pinUrl: removeTrailingSlash(options.workerPinUrl || env.SAGE_IPFS_WORKER_PIN_URL || ""),
@@ -1325,11 +1351,13 @@ var require_ipfs = __commonJS({
           signer: options.workerSigner || options.signer || null,
           getAuth: options.workerGetAuth || null,
           address: options.workerAddress || env.SAGE_SANDBOX_ADDRESS || "",
-          discoveryEventsPath: options.workerDiscoveryEventsPath || env.SAGE_IPFS_WORKER_DISCOVERY_EVENTS_PATH || "/discover/events",
-          discoveryMcpPath: options.workerDiscoveryMcpPath || env.SAGE_IPFS_WORKER_DISCOVERY_MCP_PATH || "/discover/mcp",
-          discoveryLaunchPath: options.workerDiscoveryLaunchPath || env.SAGE_IPFS_WORKER_DISCOVERY_LAUNCH_PATH || "/discover/launch",
+          // All event types route to /trends/usage - worker tracks usage for trend scoring
+          discoveryEventsPath: options.workerDiscoveryEventsPath || env.SAGE_IPFS_WORKER_DISCOVERY_EVENTS_PATH || "/trends/usage",
+          discoveryMcpPath: options.workerDiscoveryMcpPath || env.SAGE_IPFS_WORKER_DISCOVERY_MCP_PATH || "/trends/usage",
+          discoveryLaunchPath: options.workerDiscoveryLaunchPath || env.SAGE_IPFS_WORKER_DISCOVERY_LAUNCH_PATH || "/trends/usage",
           discoveryFeedPath: options.workerDiscoveryFeedPath || env.SAGE_IPFS_WORKER_DISCOVERY_FEED_PATH || "/discover",
-          discoveryMetricsPath: options.workerDiscoveryMetricsPath || env.SAGE_IPFS_WORKER_DISCOVERY_METRICS_PATH || "/discover/metrics",
+          // Metrics uses /discover/stats which returns index statistics
+          discoveryMetricsPath: options.workerDiscoveryMetricsPath || env.SAGE_IPFS_WORKER_DISCOVERY_METRICS_PATH || "/discover/stats",
           governanceReportPath: options.workerGovernanceReportPath || env.SAGE_IPFS_WORKER_GOVERNANCE_REPORT_PATH || "/governance/report",
           governanceReportsPath: options.workerGovernanceReportsPath || env.SAGE_IPFS_WORKER_GOVERNANCE_REPORTS_PATH || "/governance/reports",
           governanceReviewPath: options.workerGovernanceReviewPath || env.SAGE_IPFS_WORKER_GOVERNANCE_REVIEW_PATH || "/governance/report/review",
@@ -1363,8 +1391,9 @@ var require_ipfs = __commonJS({
         const base = workerBaseUrl();
         const ensure = (path) => path.startsWith("/") ? path : `/${path}`;
         if (base) {
-          if (kind === "challenge") return `${base}${ensure(config.worker.challengePath || "/auth/challenge")}`;
+          if (kind === "challenge") return `${base}${ensure(config.worker.challengePath || "/ipfs/auth/challenge")}`;
           if (kind === "upload") return `${base}${ensure(config.worker.uploadPath || "/ipfs/upload")}`;
+          if (kind === "upload-raw") return `${base}${ensure(config.worker.uploadRawPath || "/ipfs/upload-raw")}`;
           if (kind === "pin") return `${base}${ensure(config.worker.pinPath || "/ipfs/pin")}`;
           if (kind === "warm") return `${base}${ensure(config.worker.warmPath || "/ipfs/warm")}`;
           if (kind === "status") return `${base}${ensure(config.worker.pinPath || "/ipfs/pin")}/${cid}`;
@@ -1399,6 +1428,26 @@ var require_ipfs = __commonJS({
         const response = await axiosInstance.get(url, { headers, params, timeout: config.timeoutMs });
         return response?.data;
       }
+      async function withRetry(fn, { retries = 2, baseMs = 500 } = {}) {
+        let attempt = 0;
+        let lastErr;
+        while (attempt <= retries) {
+          try {
+            return await fn();
+          } catch (e) {
+            lastErr = e;
+            const status = e?.response?.status;
+            if (status && status >= 400 && status < 500 && status !== 429) {
+              throw e;
+            }
+            if (attempt === retries) break;
+            const delay = baseMs * Math.pow(2, attempt);
+            await new Promise((r) => setTimeout(r, delay));
+            attempt++;
+          }
+        }
+        throw lastErr;
+      }
       async function buildWorkerAuthHeaders(extraHeaders = {}) {
         if (config.worker.token) {
           return { headers: { ...extraHeaders, Authorization: `Bearer ${config.worker.token}` }, auth: null };
@@ -1471,6 +1520,51 @@ var require_ipfs = __commonJS({
         if (warm || config.shouldWarm) await warmGateways(cid, { gateways });
         return { cid, provider: "worker", response: response?.data || null };
       }
+      async function uploadRawViaWorker(content, { name, warm, gateways } = {}) {
+        const { headers, auth } = await buildWorkerAuthHeaders({ "Content-Type": "application/json" });
+        const body = { content };
+        if (auth) body.auth = auth;
+        if (name) body.name = name;
+        const response = await axiosInstance.post(workerUrl("upload-raw"), body, { headers, timeout: config.timeoutMs });
+        const cid = response?.data?.cid || response?.data?.IpfsHash;
+        if (!cid) {
+          throw new Error("Worker response missing cid");
+        }
+        if (warm || config.shouldWarm) await warmGateways(cid, { gateways });
+        return { cid, provider: "worker", response: response?.data || null };
+      }
+      async function uploadRawJson(content, options2 = {}) {
+        if (!content || typeof content !== "object") {
+          throw new Error("content object required");
+        }
+        const { providers, provider, warm, gateways, name = "manifest.json" } = options2;
+        const order = resolveProviderOrder(providers || provider);
+        if (!order.length) {
+          throw new Error("No IPFS providers configured");
+        }
+        const errors = [];
+        for (const candidate of order) {
+          try {
+            if (candidate === "worker") {
+              return await uploadRawViaWorker(content, { name, warm, gateways });
+            }
+            if (candidate === "pinata") {
+              return await uploadToPinata(content, { filename: name, warm, gateways });
+            }
+            if (candidate === "web3") {
+              return await uploadToWeb3Storage(content, { warm, gateways });
+            }
+            if (candidate === "simulate") {
+              return await uploadSimulated(content, { warm, gateways });
+            }
+          } catch (error2) {
+            errors.push({ provider: candidate, error: error2 });
+          }
+        }
+        const error = new Error("All IPFS providers failed");
+        error.details = errors;
+        throw error;
+      }
       async function uploadToPinata(payload, { filename = "payload.json", metadata, warm, gateways } = {}) {
         if (!hasPinataCreds()) {
           throw new Error("Missing Pinata credentials");
@@ -1675,28 +1769,28 @@ var require_ipfs = __commonJS({
       }
       async function recordDiscoveryEvent(event = {}) {
         if (!event || typeof event !== "object") throw new Error("event required");
-        const promptId = typeof event.promptId === "string" ? event.promptId.trim() : "";
-        if (!promptId) throw new Error("promptId required");
-        const payload = { ...event, promptId };
-        return postWorkerJson("discoveryEventsPath", "/discover/events", payload);
-      }
-      async function recordMcpUsageEvent({ promptId, metadata, address } = {}) {
-        const id = typeof promptId === "string" ? promptId.trim() : "";
-        if (!id) throw new Error("promptId required");
-        const payload = { promptId: id };
+        const cid = typeof event.promptId === "string" ? event.promptId.trim() : typeof event.cid === "string" ? event.cid.trim() : "";
+        if (!cid) throw new Error("promptId or cid required");
+        const payload = { ...event, cid };
+        return withRetry(() => postWorkerJson("discoveryEventsPath", "/trends/usage", payload));
+      }
+      async function recordMcpUsageEvent({ promptId, cid, metadata, address } = {}) {
+        const id = typeof promptId === "string" ? promptId.trim() : typeof cid === "string" ? cid.trim() : "";
+        if (!id) throw new Error("promptId or cid required");
+        const payload = { cid: id };
         if (metadata && typeof metadata === "object") payload.metadata = metadata;
         const actor = address || config.worker.address;
         if (actor) payload.address = actor;
-        return postWorkerJson("discoveryMcpPath", "/discover/mcp", payload);
+        return withRetry(() => postWorkerJson("discoveryMcpPath", "/trends/usage", payload));
       }
-      async function recordLaunchEvent({ promptId, metadata, address } = {}) {
-        const id = typeof promptId === "string" ? promptId.trim() : "";
-        if (!id) throw new Error("promptId required");
-        const payload = { promptId: id };
+      async function recordLaunchEvent({ promptId, cid, metadata, address } = {}) {
+        const id = typeof promptId === "string" ? promptId.trim() : typeof cid === "string" ? cid.trim() : "";
+        if (!id) throw new Error("promptId or cid required");
+        const payload = { cid: id };
         if (metadata && typeof metadata === "object") payload.metadata = metadata;
         const actor = address || config.worker.address;
         if (actor) payload.address = actor;
-        return postWorkerJson("discoveryLaunchPath", "/discover/launch", payload);
+        return withRetry(() => postWorkerJson("discoveryLaunchPath", "/trends/usage", payload));
       }
       async function submitGovernanceReport(payload = {}) {
         if (!payload || typeof payload !== "object") throw new Error("payload required");
@@ -1758,6 +1852,7 @@ var require_ipfs = __commonJS({
         uploadPrompt,
         uploadJson,
         uploadText,
+        uploadRawJson,
         downloadJson,
         warmGateways,
         buildGatewayUrls: (cid, extra) => buildGatewayUrls(cid, config.gateway, extra),
@@ -1784,7 +1879,7 @@ var require_ipfs = __commonJS({
       const timeoutMs = Number(options.timeoutMs ?? env.SAGE_IPFS_TIMEOUT_MS ?? 15e3);
       const challengePath = ensureLeadingSlash(
         options.workerChallengePath || env.SAGE_IPFS_WORKER_CHALLENGE_PATH,
-        "/auth/challenge"
+        "/ipfs/auth/challenge"
       );
       const warmPath = ensureLeadingSlash(
         options.workerWarmPath || env.SAGE_IPFS_WORKER_WARM_PATH,
@@ -1851,6 +1946,335 @@ var require_ipfs = __commonJS({
   }
 });
 
+// src/browser/reputation.js
+var require_reputation = __commonJS({
+  "src/browser/reputation.js"(exports, module) {
+    var { getAddress } = require_utils();
+    var subgraph = require_subgraph();
+    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 id = toBigIntString(item, "");
+        if (id) out.push(id);
+      }
+      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 req of requiredBadges) {
+          if (!have.has(req)) reasons.push(`missingBadge:${req}`);
+        }
+      }
+      return { ok: reasons.length === 0, reasons };
+    }
+    module.exports = {
+      getByAddress,
+      evaluate,
+      // Expose lower-level functions for advanced usage
+      getBadgesByRecipient,
+      listContributions,
+      computeAggregates
+    };
+  }
+});
+
 // src/errors/index.js
 var require_errors = __commonJS({
   "src/errors/index.js"(exports, module) {
@@ -2256,6 +2680,7 @@ var require_browser = __commonJS({
     var governance = require_governance();
     var subgraph = require_subgraph();
     var ipfs = require_ipfs();
+    var reputation = require_reputation();
     var serviceErrors = require_errors();
     var { SimpleCache } = require_cache();
     var { retryWithBackoff } = require_retry();
@@ -2276,6 +2701,7 @@ var require_browser = __commonJS({
       // Browser-safe modules (no ethers dependencies)
       subgraph,
       ipfs,
+      reputation,
       // Service utilities
       utils: {
         SimpleCache,