@sage-protocol/sdk 0.1.13 → 0.1.14

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.12",
+      version: "0.1.14",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -70,6 +70,7 @@ var require_package = __commonJS({
         release: "yarn build && npm publish --workspace @sage-protocol/sdk"
       },
       dependencies: {
+        "content-hash": "^2.5.2",
         "@merit-systems/echo-typescript-sdk": "^1.0.17",
         "@whetstone-research/doppler-sdk": "^0.0.1-alpha.40",
         ai: "^3.2.3",
@@ -389,6 +390,32 @@ var require_utils = __commonJS({
 var require_subgraph = __commonJS({
   "src/browser/subgraph.js"(exports, module) {
     var { getAddress } = require_utils();
+    function sanitizeOrderBy(orderBy, allowed, fallback) {
+      const value = (orderBy || "").toString();
+      return allowed.includes(value) ? value : fallback;
+    }
+    function sanitizeOrderDirection(direction, fallback = "desc") {
+      const v = (direction || "").toString().toLowerCase();
+      return v === "asc" ? "asc" : "desc";
+    }
+    function safeGetAddress(value) {
+      try {
+        return getAddress(value);
+      } catch {
+        return null;
+      }
+    }
+    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 query(url, document, variables) {
       if (!url) throw new Error("subgraph url required");
       const controller = new AbortController();
@@ -428,15 +455,21 @@ var require_subgraph = __commonJS({
       }
     }
   `, { governor: String(governor).toLowerCase(), first, skip });
-      return (data?.proposals || []).map((p) => ({
-        id: BigInt(p.id),
-        proposer: getAddress(p.proposer),
-        description: p.description,
-        createdAt: Number(p.createdAt || 0),
-        targets: (p.targets || []).map(getAddress),
-        values: (p.values || []).map((value) => BigInt(String(value))),
-        calldatas: p.calldatas || []
-      }));
+      return mapSafe(data?.proposals, (p) => {
+        const proposer = safeGetAddress(p.proposer);
+        if (!proposer) return null;
+        const targets = (p.targets || []).map((t) => safeGetAddress(t)).filter(Boolean);
+        if (!targets.length && (p.targets || []).length) return null;
+        return {
+          id: BigInt(p.id),
+          proposer,
+          description: p.description,
+          createdAt: Number(p.createdAt || 0),
+          targets,
+          values: (p.values || []).map((value) => BigInt(String(value))),
+          calldatas: p.calldatas || []
+        };
+      });
     }
     var STATE_STRING_TO_NUMBER = {
       PENDING: 0,
@@ -453,6 +486,8 @@ var require_subgraph = __commonJS({
     async function listProposalsFiltered({ url, governor, states, fromTimestamp, toTimestamp, first = 20, skip = 0, orderBy = "createdAt", orderDirection = "desc" }) {
       const govLower = governor ? String(governor).toLowerCase() : null;
       const statesUpper = Array.isArray(states) && states.length ? states.map((s) => String(s).toUpperCase()) : null;
+      const safeOrderBy = sanitizeOrderBy(orderBy, ["createdAt", "updatedAt", "eta"], "createdAt");
+      const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
       const doc = `
     query($first: Int!, $skip: Int!, $governor: Bytes, $states: [String!], $from: Int, $to: Int) {
       proposals(
@@ -464,8 +499,8 @@ var require_subgraph = __commonJS({
         }
         first: $first
         skip: $skip
-        orderBy: ${orderBy}
-        orderDirection: ${orderDirection}
+        orderBy: ${safeOrderBy}
+        orderDirection: ${safeOrderDirection}
       ) {
         id
         proposer
@@ -486,19 +521,23 @@ var require_subgraph = __commonJS({
       if (fromTimestamp !== void 0) variables.from = Number(fromTimestamp);
       if (toTimestamp !== void 0) variables.to = Number(toTimestamp);
       const data = await query(url, doc, variables);
-      return (data?.proposals || []).map((p) => {
+      return mapSafe(data?.proposals, (p) => {
         const stateStr = String(p.state || "").toUpperCase();
         const stateNum = STATE_STRING_TO_NUMBER[stateStr] != null ? STATE_STRING_TO_NUMBER[stateStr] : null;
+        const proposer = safeGetAddress(p.proposer);
+        if (!proposer) return null;
+        const targets = (p.targets || []).map((t) => safeGetAddress(t)).filter(Boolean);
+        if (!targets.length && (p.targets || []).length) return null;
         return {
           id: BigInt(p.id),
-          proposer: getAddress(p.proposer),
+          proposer,
           description: p.description || "",
           createdAt: Number(p.createdAt || 0),
           updatedAt: Number(p.updatedAt || 0),
           state: stateStr,
           stateNum,
           eta: p.eta ? BigInt(String(p.eta)) : null,
-          targets: (p.targets || []).map(getAddress),
+          targets,
           values: (p.values || []).map((value) => BigInt(String(value))),
           calldatas: p.calldatas || []
         };
@@ -517,19 +556,120 @@ var require_subgraph = __commonJS({
       }
     }
   `, { first, skip });
-      return (data?.libraries || []).map((lib) => ({
-        id: lib.id,
-        manifestCID: lib.manifestCID,
-        subdao: getAddress(lib.subDAO),
-        proposer: getAddress(lib.proposer),
-        createdAt: Number(lib.createdAt || 0)
-      }));
+      return mapSafe(data?.libraries, (lib) => {
+        const sub = safeGetAddress(lib.subDAO);
+        const proposer = safeGetAddress(lib.proposer);
+        if (!sub || !proposer) return null;
+        return {
+          id: lib.id,
+          manifestCID: lib.manifestCID,
+          subdao: sub,
+          proposer,
+          createdAt: Number(lib.createdAt || 0)
+        };
+      });
+    }
+    async function getSubdaoLibraries({ url, subdao, first = 20, skip = 0 }) {
+      if (!url) throw new Error("subgraph url required");
+      const hasFilter = !!subdao;
+      const whereClause = hasFilter ? "where:{ subdao:$subdao }" : "";
+      const doc = `
+    query($subdao:Bytes,$first:Int!,$skip:Int!){
+      subDAOLibraryPointers(
+        ${whereClause}
+        first:$first,
+        skip:$skip,
+        orderBy: updatedAt,
+        orderDirection: desc
+      ){
+        id
+        subdao
+        libraryId
+        manifestCID
+        previousCID
+        promptCount
+        updatedAt
+      }
+    }
+  `;
+      const variables = {
+        first: Math.min(Math.max(1, Number(first || 20)), 100),
+        skip
+      };
+      if (hasFilter) {
+        const addr = safeGetAddress(subdao);
+        if (!addr) throw new Error("invalid subdao address");
+        variables.subdao = addr.toLowerCase();
+      }
+      const data = await query(url, doc, variables);
+      return mapSafe(data?.subDAOLibraryPointers, (row) => {
+        const id = row?.id;
+        const manifestCID = row?.manifestCID;
+        const sub = safeGetAddress(row?.subdao);
+        if (!id || !manifestCID || !sub) return null;
+        return {
+          id: String(id),
+          subdao: sub,
+          libraryId: String(row.libraryId || "main"),
+          manifestCID: String(manifestCID),
+          previousCID: row.previousCID || null,
+          promptCount: row.promptCount != null ? Number(row.promptCount) : null,
+          updatedAt: row.updatedAt != null ? Number(row.updatedAt) : null
+        };
+      });
+    }
+    async function getSubdaoPrompts({ url, registry, first = 50, skip = 0, orderBy = "updatedAt", orderDirection = "desc" }) {
+      if (!url) throw new Error("subgraph url required");
+      const reg = safeGetAddress(registry);
+      if (!reg) throw new Error("invalid registry address");
+      const safeOrderBy = sanitizeOrderBy(orderBy, ["updatedAt"], "updatedAt");
+      const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
+      const doc = `
+    query($registry:Bytes!,$first:Int!,$skip:Int!){
+      prompts(
+        where:{ registry:$registry },
+        first:$first,
+        skip:$skip,
+        orderBy: ${safeOrderBy},
+        orderDirection: ${safeOrderDirection}
+      ){
+        id
+        key
+        cid
+        version
+        author
+        registry
+        updatedAt
+      }
+    }
+  `;
+      const data = await query(url, doc, {
+        registry: reg.toLowerCase(),
+        first: Math.min(Math.max(1, Number(first || 50)), 100),
+        skip
+      });
+      return mapSafe(data?.prompts, (p) => {
+        const author = safeGetAddress(p.author);
+        const regAddr = safeGetAddress(p.registry);
+        if (!author || !regAddr) return null;
+        return {
+          id: String(p.id),
+          key: String(p.key),
+          cid: String(p.cid),
+          version: BigInt(p.version || "0"),
+          author,
+          registry: regAddr,
+          updatedAt: Number(p.updatedAt || 0)
+        };
+      });
     }
     module.exports = {
       query,
       listProposals,
       listProposalsFiltered,
       listLibraries,
+      getSubdaoLibraries,
+      getSubdaoPrompts,
       /**
        * Canonical proposal timeline. Tries common fields first, then event-style fallbacks.
        * Returns { id, createdAt, queuedAt, executedAt, canceledAt, eta, state } (numbers/strings may be null when unavailable).
@@ -595,86 +735,127 @@ var require_subgraph = __commonJS({
       async listLiquidityAddPlans({ url, subdao = null, first = 50, skip = 0, orderBy = "blockTimestamp", orderDirection = "desc" }) {
         if (!url) throw new Error("subgraph url required");
         const filters = [];
-        if (subdao) filters.push(`subdao: "${String(getAddress(subdao)).toLowerCase()}"`);
+        if (subdao) {
+          const addr = safeGetAddress(subdao);
+          if (!addr) throw new Error("invalid subdao address");
+          filters.push(`subdao: "${addr.toLowerCase()}"`);
+        }
         const where = filters.length ? `where: { ${filters.join(", ")} }` : "";
+        const safeOrderBy = sanitizeOrderBy(orderBy, ["blockTimestamp", "blockNumber"], "blockTimestamp");
+        const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
         const doc = `
       query($first:Int!,$skip:Int!){
-        liquidityAddPlans(${where} first:$first, skip:$skip, orderBy: ${orderBy}, orderDirection: ${orderDirection}){
+        liquidityAddPlans(${where} first:$first, skip:$skip, orderBy: ${safeOrderBy}, orderDirection: ${safeOrderDirection}){
           id subdao pool sxxxToken stableToken sxxxAmount stableAmount lpRecipient blockNumber blockTimestamp transactionHash
 }
       }
     `;
         const data = await query(url, doc, { first, skip });
-        return (data?.liquidityAddPlans || []).map((e) => ({
-          id: String(e.id),
-          subdao: getAddress(e.subdao),
-          pool: getAddress(e.pool),
-          sxxxToken: getAddress(e.sxxxToken),
-          stableToken: getAddress(e.stableToken),
-          sxxxAmount: BigInt(String(e.sxxxAmount)),
-          stableAmount: BigInt(String(e.stableAmount)),
-          lpRecipient: getAddress(e.lpRecipient),
-          blockNumber: Number(e.blockNumber || 0),
-          blockTimestamp: Number(e.blockTimestamp || 0),
-          transactionHash: e.transactionHash
-        }));
+        return mapSafe(data?.liquidityAddPlans, (e) => {
+          const sub = safeGetAddress(e.subdao);
+          const pool = safeGetAddress(e.pool);
+          const sxxxToken = safeGetAddress(e.sxxxToken);
+          const stableToken = safeGetAddress(e.stableToken);
+          const lpRecipient = safeGetAddress(e.lpRecipient);
+          if (!sub || !pool || !sxxxToken || !stableToken || !lpRecipient) return null;
+          return {
+            id: String(e.id),
+            subdao: sub,
+            pool,
+            sxxxToken,
+            stableToken,
+            sxxxAmount: BigInt(String(e.sxxxAmount)),
+            stableAmount: BigInt(String(e.stableAmount)),
+            lpRecipient,
+            blockNumber: Number(e.blockNumber || 0),
+            blockTimestamp: Number(e.blockTimestamp || 0),
+            transactionHash: e.transactionHash
+          };
+        });
       },
       async listLiquidityRemovePlans({ url, subdao = null, first = 50, skip = 0, orderBy = "blockTimestamp", orderDirection = "desc" }) {
         if (!url) throw new Error("subgraph url required");
         const filters = [];
-        if (subdao) filters.push(`subdao: "${String(getAddress(subdao)).toLowerCase()}"`);
+        if (subdao) {
+          const addr = safeGetAddress(subdao);
+          if (!addr) throw new Error("invalid subdao address");
+          filters.push(`subdao: "${addr.toLowerCase()}"`);
+        }
         const where = filters.length ? `where: { ${filters.join(", ")} }` : "";
+        const safeOrderBy = sanitizeOrderBy(orderBy, ["blockTimestamp", "blockNumber"], "blockTimestamp");
+        const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
         const doc = `
       query($first:Int!,$skip:Int!){
-        liquidityRemovePlans(${where} first:$first, skip:$skip, orderBy: ${orderBy}, orderDirection: ${orderDirection}){
+        liquidityRemovePlans(${where} first:$first, skip:$skip, orderBy: ${safeOrderBy}, orderDirection: ${safeOrderDirection}){
           id subdao pool lpToken lpAmount recipient blockNumber blockTimestamp transactionHash
         }
       }
     `;
         const data = await query(url, doc, { first, skip });
-        return (data?.liquidityRemovePlans || []).map((e) => ({
-          id: String(e.id),
-          subdao: getAddress(e.subdao),
-          pool: getAddress(e.pool),
-          lpToken: getAddress(e.lpToken),
-          lpAmount: BigInt(String(e.lpAmount)),
-          recipient: getAddress(e.recipient),
-          blockNumber: Number(e.blockNumber || 0),
-          blockTimestamp: Number(e.blockTimestamp || 0),
-          transactionHash: e.transactionHash
-        }));
+        return mapSafe(data?.liquidityRemovePlans, (e) => {
+          const sub = safeGetAddress(e.subdao);
+          const pool = safeGetAddress(e.pool);
+          const lpToken = safeGetAddress(e.lpToken);
+          const recipient = safeGetAddress(e.recipient);
+          if (!sub || !pool || !lpToken || !recipient) return null;
+          return {
+            id: String(e.id),
+            subdao: sub,
+            pool,
+            lpToken,
+            lpAmount: BigInt(String(e.lpAmount)),
+            recipient,
+            blockNumber: Number(e.blockNumber || 0),
+            blockTimestamp: Number(e.blockTimestamp || 0),
+            transactionHash: e.transactionHash
+          };
+        });
       },
       async listPromptsByTag({ url, tagsHash, registry = null, first = 50, skip = 0, orderBy = "updatedAt", orderDirection = "desc" }) {
         if (!url) throw new Error("subgraph url required");
         const clauses = [`tagsHash: "${String(tagsHash)}"`];
-        if (registry) clauses.push(`registry: "${String(getAddress(registry)).toLowerCase()}"`);
+        if (registry) {
+          const addr = safeGetAddress(registry);
+          if (!addr) throw new Error("invalid registry address");
+          clauses.push(`registry: "${addr.toLowerCase()}"`);
+        }
         const where = `where: { ${clauses.join(", ")} }`;
+        const safeOrderBy = sanitizeOrderBy(orderBy, ["updatedAt"], "updatedAt");
+        const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
         const doc = `
       query($first:Int!,$skip:Int!) {
-        prompts(${where} first:$first, skip:$skip, orderBy: ${orderBy}, orderDirection: ${orderDirection}) {
+        prompts(${where} first:$first, skip:$skip, orderBy: ${safeOrderBy}, orderDirection: ${safeOrderDirection}) {
           id key cid version author registry updatedAt tagsHash
         }
       }
     `;
         const data = await query(url, doc, { first, skip });
-        return (data?.prompts || []).map((p) => ({
-          id: String(p.id),
-          key: String(p.key),
-          cid: String(p.cid),
-          version: BigInt(p.version || "0"),
-          author: getAddress(p.author),
-          registry: getAddress(p.registry),
-          updatedAt: Number(p.updatedAt || 0),
-          tagsHash: String(p.tagsHash || "")
-        }));
+        return mapSafe(data?.prompts, (p) => {
+          const author = safeGetAddress(p.author);
+          const regAddr = safeGetAddress(p.registry);
+          if (!author || !regAddr) return null;
+          return {
+            id: String(p.id),
+            key: String(p.key),
+            cid: String(p.cid),
+            version: BigInt(p.version || "0"),
+            author,
+            registry: regAddr,
+            updatedAt: Number(p.updatedAt || 0),
+            tagsHash: String(p.tagsHash || "")
+          };
+        });
       },
       // Prompt helpers (registry scoped)
       async listRegistryPrompts({ url, registry, first = 50, skip = 0, orderBy = "updatedAt", orderDirection = "desc" }) {
         if (!url) throw new Error("subgraph url required");
-        const reg = getAddress(registry);
+        const reg = safeGetAddress(registry);
+        if (!reg) throw new Error("invalid registry address");
+        const safeOrderBy = sanitizeOrderBy(orderBy, ["updatedAt"], "updatedAt");
+        const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
         const doc = `
       query($first:Int!,$skip:Int!,$registry:Bytes!) {
-        prompts(where:{ registry: $registry }, first:$first, skip:$skip, orderBy: ${orderBy}, orderDirection: ${orderDirection}) {
+        prompts(where:{ registry: $registry }, first:$first, skip:$skip, orderBy: ${safeOrderBy}, orderDirection: ${safeOrderDirection}) {
           id
           key
           cid
@@ -686,19 +867,25 @@ var require_subgraph = __commonJS({
       }
     `;
         const data = await query(url, doc, { first, skip, registry: reg.toLowerCase() });
-        return (data?.prompts || []).map((p) => ({
-          id: String(p.id),
-          key: String(p.key),
-          cid: String(p.cid),
-          version: BigInt(p.version || "0"),
-          author: getAddress(p.author),
-          registry: getAddress(p.registry),
-          updatedAt: Number(p.updatedAt || 0)
-        }));
+        return mapSafe(data?.prompts, (p) => {
+          const author = safeGetAddress(p.author);
+          const regAddr = safeGetAddress(p.registry);
+          if (!author || !regAddr) return null;
+          return {
+            id: String(p.id),
+            key: String(p.key),
+            cid: String(p.cid),
+            version: BigInt(p.version || "0"),
+            author,
+            registry: regAddr,
+            updatedAt: Number(p.updatedAt || 0)
+          };
+        });
       },
       async getPromptByKey({ url, registry, key }) {
         if (!url) throw new Error("subgraph url required");
-        const reg = getAddress(registry);
+        const reg = safeGetAddress(registry);
+        if (!reg) throw new Error("invalid registry address");
         const doc = `
       query($registry:Bytes!,$key:String!) {
         prompts(where:{ registry: $registry, key: $key }, first:1) {
@@ -714,15 +901,19 @@ var require_subgraph = __commonJS({
     `;
         const data = await query(url, doc, { registry: reg.toLowerCase(), key: String(key) });
         const p = (data?.prompts || [])[0];
-        return p ? {
+        if (!p) return null;
+        const author = safeGetAddress(p.author);
+        const regAddr = safeGetAddress(p.registry);
+        if (!author || !regAddr) return null;
+        return {
           id: String(p.id),
           key: String(p.key),
           cid: String(p.cid),
           version: BigInt(p.version || "0"),
-          author: getAddress(p.author),
-          registry: getAddress(p.registry),
+          author,
+          registry: regAddr,
           updatedAt: Number(p.updatedAt || 0)
-        } : null;
+        };
       },
       async getProposalById({ url, id }) {
         if (!url) throw new Error("subgraph url required");
@@ -730,18 +921,26 @@ var require_subgraph = __commonJS({
         const data = await query(url, doc, { id: String(id) });
         const p = data?.proposal;
         if (!p) return null;
-        return {
-          id: BigInt(p.id),
-          proposer: getAddress(p.proposer),
-          description: p.description || "",
-          createdAt: Number(p.createdAt || 0),
-          updatedAt: Number(p.updatedAt || 0),
-          state: String(p.state || ""),
-          eta: p.eta ? BigInt(String(p.eta)) : null,
-          targets: (p.targets || []).map(getAddress),
-          values: (p.values || []).map((v) => BigInt(String(v))),
-          calldatas: p.calldatas || []
-        };
+        try {
+          const proposer = safeGetAddress(p.proposer);
+          if (!proposer) return null;
+          const targets = (p.targets || []).map((t) => safeGetAddress(t)).filter(Boolean);
+          if (!targets.length && (p.targets || []).length) return null;
+          return {
+            id: BigInt(p.id),
+            proposer,
+            description: p.description || "",
+            createdAt: Number(p.createdAt || 0),
+            updatedAt: Number(p.updatedAt || 0),
+            state: String(p.state || ""),
+            eta: p.eta ? BigInt(String(p.eta)) : null,
+            targets,
+            values: (p.values || []).map((v) => BigInt(String(v))),
+            calldatas: p.calldatas || []
+          };
+        } catch {
+          return null;
+        }
       }
     };
   }