@sage-protocol/sdk 0.1.11 → 0.1.14

package/dist/index.mjs

@@ -20,7 +20,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.10",
+      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",
@@ -76,6 +76,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",
@@ -149,11 +150,22 @@ var require_abi = __commonJS({
       "function stats() view returns (uint128 totalSubDAOsCreated, uint128 totalBurnedForCreation)",
       // On-chain enumeration fallback (naming follows FactoryCoreFacet)
       "function getSubDAOCount() view returns (uint256)",
-      "function subDaos(uint256) view returns (address)"
+      "function subDaos(uint256) view returns (address)",
+      // ISubDAOFactory interface functions
+      "function getAllSubDAOs() view returns (address[])",
+      "function getSubDAORegistry(address subdaoAddress) view returns (address)",
+      "function getRegistrySubDAO(address registryAddress) view returns (address)",
+      "function getFactoryStats() view returns (uint256 totalSubDAOs, uint256 totalBurned, uint256 averageBurnPerSubDAO)",
+      "function isSubDAO(address subdaoAddress) view returns (bool)"
     ];
     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 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)",
+      "function createSubDAOOperatorAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer) returns (address subDAO, address registry)",
       "function createForkedSubDAO(string newName, string newDescription, string originalName, address originalSubDAO, address forker) returns (address subDAO, address registry)",
       "function createForkedSubDAOWithStable(string newName, string newDescription, string originalName, address originalSubDAO, address forker, uint64 authorizationNonce, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)"
     ];
@@ -395,6 +407,32 @@ var require_subgraph = __commonJS({
     var axios = __require("axios");
     var { getAddress } = __require("ethers");
     var { keccak256, toUtf8Bytes } = __require("ethers");
+    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 resp = await axios.post(url, { query: document, variables }, { timeout: 1e4 });
@@ -417,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,
@@ -442,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(
@@ -453,8 +499,8 @@ var require_subgraph = __commonJS({
         }
         first: $first
         skip: $skip
-        orderBy: ${orderBy}
-        orderDirection: ${orderDirection}
+        orderBy: ${safeOrderBy}
+        orderDirection: ${safeOrderDirection}
       ) {
         id
         proposer
@@ -475,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 || []
         };
@@ -506,19 +556,127 @@ 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
+        createdAt
+        blockNumber
+        blockTimestamp
+      }
+    }
+  `;
+      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 id2 = row?.id;
+        const manifestCID = row?.manifestCID;
+        const sub = safeGetAddress(row?.subdao);
+        if (!id2 || !manifestCID || !sub) return null;
+        const timestamp = (row.updatedAt != null ? Number(row.updatedAt) : null) || (row.createdAt != null ? Number(row.createdAt) : null) || (row.blockTimestamp != null ? Number(row.blockTimestamp) : null);
+        return {
+          id: String(id2),
+          subdao: sub,
+          libraryId: String(row.libraryId || "main"),
+          manifestCID: String(manifestCID),
+          previousCID: row.previousCID || null,
+          promptCount: row.promptCount != null ? Number(row.promptCount) : null,
+          updatedAt: timestamp,
+          createdAt: row.createdAt != null ? Number(row.createdAt) : null,
+          blockNumber: row.blockNumber != null ? Number(row.blockNumber) : null,
+          blockTimestamp: row.blockTimestamp != null ? Number(row.blockTimestamp) : 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)
+        };
+      });
     }
     module2.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).
@@ -584,86 +742,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
@@ -675,19 +874,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) {
@@ -703,15 +908,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: id2 }) {
         if (!url) throw new Error("subgraph url required");
@@ -719,18 +928,26 @@ var require_subgraph = __commonJS({
         const data = await query(url, doc, { id: String(id2) });
         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;
+        }
       }
     };
   }
@@ -3981,7 +4198,17 @@ var require_factory = __commonJS({
       ] = await Promise.all([
         contract.stableFeeToken().catch(() => null),
         contract.stableCreationFee().catch(() => null),
-        contract.feeReceiver().catch(() => null),
+        (async () => {
+          try {
+            return await contract.stableFeeReceiver();
+          } catch (_) {
+            try {
+              return await contract.feeReceiver();
+            } catch {
+              return null;
+            }
+          }
+        })(),
         contract.allowStableFee().catch(() => null),
         contract.stablePromptForkFee().catch(() => null),
         contract.allowStablePromptForkFee().catch(() => null),
@@ -4148,6 +4375,102 @@ var require_factory = __commonJS({
       ]);
       return { to: addr, data: payload, value: 0n };
     }
+    function buildCreateSubDAOWithParamsTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      burnAmount,
+      votingDelay,
+      votingPeriod,
+      proposalThreshold,
+      quorumPercentage,
+      initialForkPolicy,
+      initialMembershipPolicy,
+      profileCID
+    }) {
+      const addr = normalise(factory, "factory");
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOWithParams", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        BigInt(burnAmount),
+        BigInt(votingDelay),
+        BigInt(votingPeriod),
+        BigInt(proposalThreshold),
+        BigInt(quorumPercentage),
+        Number(initialForkPolicy),
+        Number(initialMembershipPolicy),
+        String(profileCID ?? "")
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      permit
+    }) {
+      const addr = normalise(factory, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStable", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableAdvancedTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      anyoneExec = false,
+      governorProposer = false,
+      permit
+    }) {
+      const addr = normalise(factory, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStableAdvanced", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        Boolean(anyoneExec),
+        Boolean(governorProposer),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
     async function listSubDAOs({ provider, factory }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(factory, "factory");
@@ -4228,6 +4551,9 @@ var require_factory = __commonJS({
       getTemplateDetails,
       buildCreateSubDAOTx,
       buildCreateSubDAOWithStableTx,
+      buildCreateSubDAOWithParamsTx,
+      buildCreateOperatorSubDAOWithStableTx,
+      buildCreateOperatorSubDAOWithStableAdvancedTx,
       buildCreateForkedSubDAOTx,
       buildCreateForkedSubDAOWithStableTx
     };
@@ -5510,6 +5836,58 @@ var require_safe = __commonJS({
   }
 });
 
+// src/utils/time.js
+var require_time = __commonJS({
+  "src/utils/time.js"(exports2, module2) {
+    function relativeTime(ts) {
+      if (!ts || typeof ts !== "number") return "\u2014";
+      try {
+        const ms = ts < 1e12 ? ts * 1e3 : ts;
+        const diff = Date.now() - ms;
+        if (diff < 0) return "just now";
+        const minutes = Math.round(diff / 6e4);
+        if (minutes < 1) return "just now";
+        if (minutes < 60) return `${minutes}m ago`;
+        const hours = Math.round(minutes / 60);
+        if (hours < 24) return `${hours}h ago`;
+        const days = Math.round(hours / 24);
+        if (days < 30) return `${days}d ago`;
+        const months = Math.round(days / 30);
+        if (months < 12) return `${months}mo ago`;
+        const years = Math.round(months / 12);
+        return `${years}y ago`;
+      } catch {
+        return "\u2014";
+      }
+    }
+    function formatDate(ts) {
+      if (!ts || typeof ts !== "number") return null;
+      try {
+        const ms = ts < 1e12 ? ts * 1e3 : ts;
+        const d = new Date(ms);
+        return d.toLocaleDateString();
+      } catch {
+        return null;
+      }
+    }
+    function formatDateTime(ts) {
+      if (!ts || typeof ts !== "number") return null;
+      try {
+        const ms = ts < 1e12 ? ts * 1e3 : ts;
+        const d = new Date(ms);
+        return d.toLocaleString();
+      } catch {
+        return null;
+      }
+    }
+    module2.exports = {
+      relativeTime,
+      formatDate,
+      formatDateTime
+    };
+  }
+});
+
 // src/treasury/index.js
 var require_treasury = __commonJS({
   "src/treasury/index.js"(exports2, module2) {
@@ -9074,6 +9452,7 @@ var require_src = __commonJS({
     var subgraph = require_subgraph();
     var privateTx = require_privateTx();
     var safe = require_safe();
+    var time = require_time();
     var treasury = require_treasury();
     var boost = require_boost();
     var bounty = require_bounty();
@@ -9121,7 +9500,7 @@ var require_src = __commonJS({
       boost,
       // bond module removed; bonds deprecated in CLI/SDK
       subgraph,
-      utils: { ...utils, privateTx, safe },
+      utils: { ...utils, privateTx, safe, time },
       bounty,
       wallet: Object.assign(wallet, {
         cast: walletCastManager,