@sage-protocol/sdk 0.1.14 → 0.1.16

package/README.md

@@ -32,8 +32,9 @@ const subdaos = await sdk.subdao.discoverSubDAOs({
   fromBlock: 0,
 });
 
-// Fetch governance metadata for a SubDAO governor
-const info = await sdk.governance.getGovernorInfo({ provider, governor: subdaos[0].governor });
+// Fetch governance + profile metadata for a SubDAO
+const info = await sdk.subdao.getSubDAOInfo({ provider, subdao: subdaos[0].subdao });
+// info.profileCID points at an IPFS JSON profile/playbook document (name, description, avatar, social links, etc.)
 ```
 
 **CommonJS usage**
@@ -641,6 +642,12 @@ await sdk.subdao.makeOperator({ signer, subdao: res.subdao, operator: '0xSafeOrE
 
 // Ensure SXXX approval for factory burn if needed
 await sdk.subdao.ensureSxxxBurnAllowance({ signer, sxxx: SXXX, spender: FACTORY, amount: 1500n * 10n**18n });
+
+// (Optional) Build a setProfileCid tx for newer SubDAO implementations that expose setProfileCid(string)
+// Use this in a Governor/Timelock proposal or Safe Transaction Builder, not as a direct EOA call.
+const profileCid = 'bafy...'; // CID of dao-profile.json on IPFS
+const { to, data, value } = sdk.subdao.buildSetProfileCidTx({ subdao: res.subdao, profileCid });
+// Example: schedule via timelock or propose via Governor, depending on your governance mode
 ```
 # Governance Adapter (OpenZeppelin)
 

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.14",
+      version: "0.1.16",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -172,12 +172,13 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function getManifestCIDCount() view returns (uint256)",
-      "function getManifestCIDs(uint256 offset, uint256 limit) view returns (string[] memory, uint256 total)",
-      "function getManifestCID(uint256 index) view returns (string)",
-      "function libraries(string manifestCID) view returns (string previousCID, uint256 timestamp, address proposer, uint256 promptCount)",
-      "function subdaoLibraryLatest(bytes32 key) view returns (string)",
-      "function hasScopedOwnership(address subdao, string manifestCID) view returns (bool)"
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version)",
+      "function daoTimelock(address) view returns (address)",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version))",
+      "function updateLibrary(address dao, string manifestCID, string version)",
+      "function registerDAO(address dao, address timelock)",
+      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version)",
+      "event DAORegistered(address indexed dao, address indexed timelock)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",

package/dist/index.cjs

@@ -14,7 +14,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.14",
+      version: "0.1.16",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -172,12 +172,13 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function getManifestCIDCount() view returns (uint256)",
-      "function getManifestCIDs(uint256 offset, uint256 limit) view returns (string[] memory, uint256 total)",
-      "function getManifestCID(uint256 index) view returns (string)",
-      "function libraries(string manifestCID) view returns (string previousCID, uint256 timestamp, address proposer, uint256 promptCount)",
-      "function subdaoLibraryLatest(bytes32 key) view returns (string)",
-      "function hasScopedOwnership(address subdao, string manifestCID) view returns (bool)"
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version)",
+      "function daoTimelock(address) view returns (address)",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version))",
+      "function updateLibrary(address dao, string manifestCID, string version)",
+      "function registerDAO(address dao, address timelock)",
+      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version)",
+      "event DAORegistered(address indexed dao, address indexed timelock)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",
@@ -1231,15 +1232,35 @@ var require_ipfs = __commonJS({
         if (metadata) {
           formData.append("pinataMetadata", JSON.stringify(metadata));
         }
-        const headers = { ...formData.getHeaders() };
+        const endpoint = `${config.pinata.apiUrl}/pinning/pinFileToIPFS`;
+        const sendWithAuthMode = async (mode) => {
+          const headers = { ...formData.getHeaders() };
+          if (mode === "jwt") {
+            headers.Authorization = `Bearer ${config.pinata.jwt}`;
+          } else {
+            headers.pinata_api_key = config.pinata.apiKey;
+            headers.pinata_secret_api_key = config.pinata.secretKey;
+          }
+          return axiosInstance.post(endpoint, formData, { headers, timeout: config.timeoutMs });
+        };
+        let response;
+        let lastError;
         if (config.pinata.jwt) {
-          headers.Authorization = `Bearer ${config.pinata.jwt}`;
+          try {
+            response = await sendWithAuthMode("jwt");
+          } catch (error) {
+            lastError = error;
+            const status = error?.response?.status;
+            const reason = error?.response?.data?.error?.reason || "";
+            const isInvalidJwt = status === 401 && typeof reason === "string" && reason.toUpperCase().includes("INVALID_CREDENTIALS");
+            if (!config.pinata.apiKey || !config.pinata.secretKey || !isInvalidJwt) {
+              throw error;
+            }
+            response = await sendWithAuthMode("keys");
+          }
         } else {
-          headers.pinata_api_key = config.pinata.apiKey;
-          headers.pinata_secret_api_key = config.pinata.secretKey;
+          response = await sendWithAuthMode("keys");
         }
-        const endpoint = `${config.pinata.apiUrl}/pinning/pinFileToIPFS`;
-        const response = await axiosInstance.post(endpoint, formData, { headers, timeout: config.timeoutMs });
         const cid = response?.data?.IpfsHash || response?.data?.cid || response?.data?.Hash;
         if (!cid) {
           throw new Error("Pinata upload did not return IpfsHash");
@@ -1875,7 +1896,7 @@ var require_validation = __commonJS({
             schemaPath: null,
             errors: [{ keyword: "schema", instancePath: "/", message: "manifest schema not found" }],
             hints: [
-              'Ensure docs/schemas/manifest.schema.json exists (run "sage library scaffold" to regenerate)'
+              'Ensure docs/schemas/manifest.schema.json exists (run "sage project scaffold" to regenerate)'
             ],
             manifestPath
           };
@@ -2016,93 +2037,95 @@ var require_library = __commonJS({
         throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
       }
     }
-    async function listManifests({ provider, registry, offset = 0, limit = 50 }) {
+    async function listManifests({ provider, registry, factoryAddress, offset = 0, limit = 50 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const [cids, total] = await contract.getManifestCIDs(offset, limit);
+      if (!factoryAddress) throw new SageSDKError(CODES.INVALID_ARGS, "factoryAddress required for V4 listing");
+      const factory2 = new Contract(factoryAddress, ABI.FactoryRead, provider);
+      const totalSubDAOs = await factory2.getSubDAOCount();
       const manifests = [];
-      for (const cid of cids) {
-        manifests.push(await getManifestInfo({ provider, registry: addr, manifestCID: cid }));
+      const start = Number(offset);
+      const end = Math.min(start + Number(limit), Number(totalSubDAOs));
+      for (let i = start; i < end; i++) {
+        const subdao2 = await factory2.subDaos(i);
+        const info = await getLatestLibrary({ provider, registry, subdao: subdao2 });
+        if (info && info.manifestCID) {
+          manifests.push(info);
+        }
       }
-      return { total: BigInt(total.toString()), manifests };
+      return { total: BigInt(totalSubDAOs), manifests };
     }
-    async function getManifestInfo({ provider, registry, manifestCID }) {
+    async function getLibraryInfo({ provider, registry, subdao: subdao2 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
+      if (!subdao2) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
       const addr = normalise(registry, "registry");
+      const dao = normalise(subdao2, "subdao");
       const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const [previousCID, timestamp, proposer, promptCount] = await contract.libraries(manifestCID);
+      const info = await contract.getLibrary(dao);
       return {
-        manifestCID,
-        previousCID,
-        timestamp: BigInt(timestamp.toString()),
-        proposer: getAddress(proposer),
-        promptCount: Number(promptCount)
+        manifestCID: info.manifestCID,
+        previousCID: "",
+        // Not tracked on-chain in V4 (history is in events/subgraph)
+        timestamp: BigInt(info.lastUpdated.toString()),
+        proposer: getAddress(info.lastUpdater),
+        promptCount: 0,
+        // Not tracked on-chain in V4
+        version: info.version
       };
     }
+    async function getManifestInfo({ provider, registry, manifestCID }) {
+      throw new SageSDKError(CODES.UNSUPPORTED_OPERATION, "getManifestInfo(cid) is not supported in V4. Use getLibraryInfo(subdao).");
+    }
     function _computeLibraryKey(subdao2, libraryId) {
-      const coder = AbiCoder.defaultAbiCoder ? AbiCoder.defaultAbiCoder() : new AbiCoder();
-      const encoded = coder.encode(["address", "string"], [getAddress(subdao2), String(libraryId)]);
-      return keccak256(encoded);
+      return getAddress(subdao2);
     }
-    async function getLatestLibrary({ provider, registry, subdao: subdao2, libraryId = "main" }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao2, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = _computeLibraryKey(sub, libraryId);
-      const latestCID = await contract.subdaoLibraryLatest(key).catch(() => "");
-      if (!latestCID || latestCID.length === 0) return null;
-      const info = await getManifestInfo({ provider, registry: addr, manifestCID: latestCID });
-      return info;
+    async function getLatestLibrary({ provider, registry, subdao: subdao2 }) {
+      return getLibraryInfo({ provider, registry, subdao: subdao2 });
     }
-    async function getBeforeAfterForUpdate({ provider, registry, subdao: subdao2, libraryId = "main", newCid }) {
+    async function getBeforeAfterForUpdate({ provider, registry, subdao: subdao2, newCid }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao2, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = _computeLibraryKey(sub, libraryId);
-      const prev = await contract.subdaoLibraryLatest(key).catch(() => "");
-      return { previousCID: prev || null, newCID: String(newCid), libraryId: String(libraryId) };
+      const info = await getLatestLibrary({ provider, registry, subdao: subdao2 });
+      return {
+        previousCID: info ? info.manifestCID : null,
+        newCID: String(newCid),
+        version: info ? info.version : "0.0.0"
+      };
     }
     async function hasScopedOwnership({ provider, registry, subdao: subdao2, manifestCID }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao2, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      return contract.hasScopedOwnership(sub, manifestCID);
+      const info = await getLatestLibrary({ provider, registry, subdao: subdao2 });
+      return info && info.manifestCID === manifestCID;
     }
-    function buildUpdateLibraryForSubDAOTx({ registry, subdao: subdao2, manifestCID, promptCount, libraryId = "main" }) {
+    function buildUpdateLibraryTx({ registry, subdao: subdao2, manifestCID, version = "1.0.0" }) {
       const to = normalise(registry, "registry");
       if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
-      const iface = new Interface(["function updateLibraryForSubDAO(address,string,string,uint256)"]);
-      const data = iface.encodeFunctionData("updateLibraryForSubDAO", [
+      const iface = new Interface(["function updateLibrary(address,string,string)"]);
+      const data = iface.encodeFunctionData("updateLibrary", [
         normalise(subdao2, "subdao"),
-        String(libraryId || "main"),
         String(manifestCID),
-        BigInt(promptCount ?? 0n)
+        String(version)
       ]);
       return { to, data, value: 0n };
     }
+    var buildUpdateLibraryForSubDAOTx = buildUpdateLibraryTx;
     module2.exports = {
       listManifests,
       getManifestInfo,
+      getLibraryInfo,
       getLatestLibrary,
       hasScopedOwnership,
+      buildUpdateLibraryTx,
       buildUpdateLibraryForSubDAOTx,
       _computeLibraryKey,
       getBeforeAfterForUpdate,
       /** Build an authorizeTimelock(timelock, subdao) call for a LibraryRegistry. */
       buildAuthorizeTimelockTx: function buildAuthorizeTimelockTx({ registry, timelock: timelock2, subdao: subdao2 }) {
         const to = normalise(registry, "registry");
-        const iface = new Interface(["function authorizeTimelock(address,address)"]);
-        const data = iface.encodeFunctionData("authorizeTimelock", [normalise(timelock2, "timelock"), normalise(subdao2, "subdao")]);
+        const iface = new Interface(["function registerDAO(address,address)"]);
+        const data = iface.encodeFunctionData("registerDAO", [normalise(subdao2, "subdao"), normalise(timelock2, "timelock")]);
         return { to, data, value: 0n };
       },
       searchRegistry,
       validation,
-      /** Simulate calling a registry function as the timelock to verify authority/roles */
+      /** Simulate as timelock */
       simulateAsTimelock: async function simulateAsTimelock({ provider, registry, to, data, timelock: timelock2 }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         const reg = normalise(registry, "registry");
@@ -2115,10 +2138,9 @@ var require_library = __commonJS({
           return { ok: false, error: { type: "Revert", message: String(err && err.message || err) } };
         }
       },
-      /** Best-effort execution readiness for updateLibraryForSubDAO by simulating as timelock. */
-      executionReadiness: async function executionReadiness({ provider, registry, timelock: timelock2, subdao: subdao2, libraryId = "main", manifestCID = "", promptCount = 0 }) {
+      executionReadiness: async function executionReadiness({ provider, registry, timelock: timelock2, subdao: subdao2, manifestCID = "", version = "1.0.0" }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-        const payload = buildUpdateLibraryForSubDAOTx({ registry, subdao: subdao2, manifestCID, promptCount, libraryId });
+        const payload = buildUpdateLibraryTx({ registry, subdao: subdao2, manifestCID, version });
         const sim = await this.simulateAsTimelock({ provider, registry, to: payload.to, data: payload.data, timelock: timelock2 });
         const out = { ok: !!sim.ok, error: sim.ok ? null : sim.error?.message || "revert", missingRole: null };
         return out;
@@ -2931,7 +2953,9 @@ var require_subdao = __commonJS({
     }
     var SubDAOInterface = new Interface([
       "function stake(uint256)",
-      "function unstake(uint256)"
+      "function unstake(uint256)",
+      // Optional on newer SubDAO implementations; provided for tx building only.
+      "function setProfileCid(string)"
     ]);
     function buildStakeTx({ subdao: subdao2, amount }) {
       const addr = normalise(subdao2, "subdao");
@@ -2943,12 +2967,21 @@ var require_subdao = __commonJS({
       const data = SubDAOInterface.encodeFunctionData("unstake", [BigInt(amount)]);
       return { to: addr, data, value: 0n };
     }
+    function buildSetProfileCidTx({ subdao: subdao2, profileCid }) {
+      const addr = normalise(subdao2, "subdao");
+      if (!profileCid || typeof profileCid !== "string" || !profileCid.trim()) {
+        throw new SageSDKError(CODES.INVALID_ARGS, "profileCid (CID string) required");
+      }
+      const data = SubDAOInterface.encodeFunctionData("setProfileCid", [String(profileCid)]);
+      return { to: addr, data, value: 0n };
+    }
     module2.exports = {
       discoverSubDAOs,
       getSubDAOInfo,
       getSubDAOUserStats,
       buildStakeTx,
-      buildUnstakeTx
+      buildUnstakeTx,
+      buildSetProfileCidTx
     };
     async function ensureSxxxBurnAllowance({ signer, sxxx, owner, spender, amount }) {
       if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");

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.14",
+      version: "0.1.16",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -178,12 +178,13 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function getManifestCIDCount() view returns (uint256)",
-      "function getManifestCIDs(uint256 offset, uint256 limit) view returns (string[] memory, uint256 total)",
-      "function getManifestCID(uint256 index) view returns (string)",
-      "function libraries(string manifestCID) view returns (string previousCID, uint256 timestamp, address proposer, uint256 promptCount)",
-      "function subdaoLibraryLatest(bytes32 key) view returns (string)",
-      "function hasScopedOwnership(address subdao, string manifestCID) view returns (bool)"
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version)",
+      "function daoTimelock(address) view returns (address)",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version))",
+      "function updateLibrary(address dao, string manifestCID, string version)",
+      "function registerDAO(address dao, address timelock)",
+      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version)",
+      "event DAORegistered(address indexed dao, address indexed timelock)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",
@@ -1237,15 +1238,35 @@ var require_ipfs = __commonJS({
         if (metadata) {
           formData.append("pinataMetadata", JSON.stringify(metadata));
         }
-        const headers = { ...formData.getHeaders() };
+        const endpoint = `${config.pinata.apiUrl}/pinning/pinFileToIPFS`;
+        const sendWithAuthMode = async (mode) => {
+          const headers = { ...formData.getHeaders() };
+          if (mode === "jwt") {
+            headers.Authorization = `Bearer ${config.pinata.jwt}`;
+          } else {
+            headers.pinata_api_key = config.pinata.apiKey;
+            headers.pinata_secret_api_key = config.pinata.secretKey;
+          }
+          return axiosInstance.post(endpoint, formData, { headers, timeout: config.timeoutMs });
+        };
+        let response;
+        let lastError;
         if (config.pinata.jwt) {
-          headers.Authorization = `Bearer ${config.pinata.jwt}`;
+          try {
+            response = await sendWithAuthMode("jwt");
+          } catch (error) {
+            lastError = error;
+            const status = error?.response?.status;
+            const reason = error?.response?.data?.error?.reason || "";
+            const isInvalidJwt = status === 401 && typeof reason === "string" && reason.toUpperCase().includes("INVALID_CREDENTIALS");
+            if (!config.pinata.apiKey || !config.pinata.secretKey || !isInvalidJwt) {
+              throw error;
+            }
+            response = await sendWithAuthMode("keys");
+          }
         } else {
-          headers.pinata_api_key = config.pinata.apiKey;
-          headers.pinata_secret_api_key = config.pinata.secretKey;
+          response = await sendWithAuthMode("keys");
         }
-        const endpoint = `${config.pinata.apiUrl}/pinning/pinFileToIPFS`;
-        const response = await axiosInstance.post(endpoint, formData, { headers, timeout: config.timeoutMs });
         const cid = response?.data?.IpfsHash || response?.data?.cid || response?.data?.Hash;
         if (!cid) {
           throw new Error("Pinata upload did not return IpfsHash");
@@ -1881,7 +1902,7 @@ var require_validation = __commonJS({
             schemaPath: null,
             errors: [{ keyword: "schema", instancePath: "/", message: "manifest schema not found" }],
             hints: [
-              'Ensure docs/schemas/manifest.schema.json exists (run "sage library scaffold" to regenerate)'
+              'Ensure docs/schemas/manifest.schema.json exists (run "sage project scaffold" to regenerate)'
             ],
             manifestPath
           };
@@ -2022,93 +2043,95 @@ var require_library = __commonJS({
         throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
       }
     }
-    async function listManifests({ provider, registry, offset = 0, limit = 50 }) {
+    async function listManifests({ provider, registry, factoryAddress, offset = 0, limit = 50 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const [cids, total] = await contract.getManifestCIDs(offset, limit);
+      if (!factoryAddress) throw new SageSDKError(CODES.INVALID_ARGS, "factoryAddress required for V4 listing");
+      const factory = new Contract(factoryAddress, ABI.FactoryRead, provider);
+      const totalSubDAOs = await factory.getSubDAOCount();
       const manifests = [];
-      for (const cid of cids) {
-        manifests.push(await getManifestInfo({ provider, registry: addr, manifestCID: cid }));
+      const start = Number(offset);
+      const end = Math.min(start + Number(limit), Number(totalSubDAOs));
+      for (let i = start; i < end; i++) {
+        const subdao = await factory.subDaos(i);
+        const info = await getLatestLibrary({ provider, registry, subdao });
+        if (info && info.manifestCID) {
+          manifests.push(info);
+        }
       }
-      return { total: BigInt(total.toString()), manifests };
+      return { total: BigInt(totalSubDAOs), manifests };
     }
-    async function getManifestInfo({ provider, registry, manifestCID }) {
+    async function getLibraryInfo({ provider, registry, subdao }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
       const addr = normalise(registry, "registry");
+      const dao = normalise(subdao, "subdao");
       const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const [previousCID, timestamp, proposer, promptCount] = await contract.libraries(manifestCID);
+      const info = await contract.getLibrary(dao);
       return {
-        manifestCID,
-        previousCID,
-        timestamp: BigInt(timestamp.toString()),
-        proposer: getAddress(proposer),
-        promptCount: Number(promptCount)
+        manifestCID: info.manifestCID,
+        previousCID: "",
+        // Not tracked on-chain in V4 (history is in events/subgraph)
+        timestamp: BigInt(info.lastUpdated.toString()),
+        proposer: getAddress(info.lastUpdater),
+        promptCount: 0,
+        // Not tracked on-chain in V4
+        version: info.version
       };
     }
+    async function getManifestInfo({ provider, registry, manifestCID }) {
+      throw new SageSDKError(CODES.UNSUPPORTED_OPERATION, "getManifestInfo(cid) is not supported in V4. Use getLibraryInfo(subdao).");
+    }
     function _computeLibraryKey(subdao, libraryId) {
-      const coder = AbiCoder.defaultAbiCoder ? AbiCoder.defaultAbiCoder() : new AbiCoder();
-      const encoded = coder.encode(["address", "string"], [getAddress(subdao), String(libraryId)]);
-      return keccak256(encoded);
+      return getAddress(subdao);
     }
-    async function getLatestLibrary({ provider, registry, subdao, libraryId = "main" }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = _computeLibraryKey(sub, libraryId);
-      const latestCID = await contract.subdaoLibraryLatest(key).catch(() => "");
-      if (!latestCID || latestCID.length === 0) return null;
-      const info = await getManifestInfo({ provider, registry: addr, manifestCID: latestCID });
-      return info;
+    async function getLatestLibrary({ provider, registry, subdao }) {
+      return getLibraryInfo({ provider, registry, subdao });
     }
-    async function getBeforeAfterForUpdate({ provider, registry, subdao, libraryId = "main", newCid }) {
+    async function getBeforeAfterForUpdate({ provider, registry, subdao, newCid }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = _computeLibraryKey(sub, libraryId);
-      const prev = await contract.subdaoLibraryLatest(key).catch(() => "");
-      return { previousCID: prev || null, newCID: String(newCid), libraryId: String(libraryId) };
+      const info = await getLatestLibrary({ provider, registry, subdao });
+      return {
+        previousCID: info ? info.manifestCID : null,
+        newCID: String(newCid),
+        version: info ? info.version : "0.0.0"
+      };
     }
     async function hasScopedOwnership({ provider, registry, subdao, manifestCID }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      return contract.hasScopedOwnership(sub, manifestCID);
+      const info = await getLatestLibrary({ provider, registry, subdao });
+      return info && info.manifestCID === manifestCID;
     }
-    function buildUpdateLibraryForSubDAOTx({ registry, subdao, manifestCID, promptCount, libraryId = "main" }) {
+    function buildUpdateLibraryTx({ registry, subdao, manifestCID, version = "1.0.0" }) {
       const to = normalise(registry, "registry");
       if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
-      const iface = new Interface(["function updateLibraryForSubDAO(address,string,string,uint256)"]);
-      const data = iface.encodeFunctionData("updateLibraryForSubDAO", [
+      const iface = new Interface(["function updateLibrary(address,string,string)"]);
+      const data = iface.encodeFunctionData("updateLibrary", [
         normalise(subdao, "subdao"),
-        String(libraryId || "main"),
         String(manifestCID),
-        BigInt(promptCount ?? 0n)
+        String(version)
       ]);
       return { to, data, value: 0n };
     }
+    var buildUpdateLibraryForSubDAOTx = buildUpdateLibraryTx;
     module2.exports = {
       listManifests,
       getManifestInfo,
+      getLibraryInfo,
       getLatestLibrary,
       hasScopedOwnership,
+      buildUpdateLibraryTx,
       buildUpdateLibraryForSubDAOTx,
       _computeLibraryKey,
       getBeforeAfterForUpdate,
       /** Build an authorizeTimelock(timelock, subdao) call for a LibraryRegistry. */
       buildAuthorizeTimelockTx: function buildAuthorizeTimelockTx({ registry, timelock, subdao }) {
         const to = normalise(registry, "registry");
-        const iface = new Interface(["function authorizeTimelock(address,address)"]);
-        const data = iface.encodeFunctionData("authorizeTimelock", [normalise(timelock, "timelock"), normalise(subdao, "subdao")]);
+        const iface = new Interface(["function registerDAO(address,address)"]);
+        const data = iface.encodeFunctionData("registerDAO", [normalise(subdao, "subdao"), normalise(timelock, "timelock")]);
         return { to, data, value: 0n };
       },
       searchRegistry,
       validation,
-      /** Simulate calling a registry function as the timelock to verify authority/roles */
+      /** Simulate as timelock */
       simulateAsTimelock: async function simulateAsTimelock({ provider, registry, to, data, timelock }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         const reg = normalise(registry, "registry");
@@ -2121,10 +2144,9 @@ var require_library = __commonJS({
           return { ok: false, error: { type: "Revert", message: String(err && err.message || err) } };
         }
       },
-      /** Best-effort execution readiness for updateLibraryForSubDAO by simulating as timelock. */
-      executionReadiness: async function executionReadiness({ provider, registry, timelock, subdao, libraryId = "main", manifestCID = "", promptCount = 0 }) {
+      executionReadiness: async function executionReadiness({ provider, registry, timelock, subdao, manifestCID = "", version = "1.0.0" }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-        const payload = buildUpdateLibraryForSubDAOTx({ registry, subdao, manifestCID, promptCount, libraryId });
+        const payload = buildUpdateLibraryTx({ registry, subdao, manifestCID, version });
         const sim = await this.simulateAsTimelock({ provider, registry, to: payload.to, data: payload.data, timelock });
         const out = { ok: !!sim.ok, error: sim.ok ? null : sim.error?.message || "revert", missingRole: null };
         return out;
@@ -2937,7 +2959,9 @@ var require_subdao = __commonJS({
     }
     var SubDAOInterface = new Interface([
       "function stake(uint256)",
-      "function unstake(uint256)"
+      "function unstake(uint256)",
+      // Optional on newer SubDAO implementations; provided for tx building only.
+      "function setProfileCid(string)"
     ]);
     function buildStakeTx({ subdao, amount }) {
       const addr = normalise(subdao, "subdao");
@@ -2949,12 +2973,21 @@ var require_subdao = __commonJS({
       const data = SubDAOInterface.encodeFunctionData("unstake", [BigInt(amount)]);
       return { to: addr, data, value: 0n };
     }
+    function buildSetProfileCidTx({ subdao, profileCid }) {
+      const addr = normalise(subdao, "subdao");
+      if (!profileCid || typeof profileCid !== "string" || !profileCid.trim()) {
+        throw new SageSDKError(CODES.INVALID_ARGS, "profileCid (CID string) required");
+      }
+      const data = SubDAOInterface.encodeFunctionData("setProfileCid", [String(profileCid)]);
+      return { to: addr, data, value: 0n };
+    }
     module2.exports = {
       discoverSubDAOs,
       getSubDAOInfo,
       getSubDAOUserStats,
       buildStakeTx,
-      buildUnstakeTx
+      buildUnstakeTx,
+      buildSetProfileCidTx
     };
     async function ensureSxxxBurnAllowance({ signer, sxxx, owner, spender, amount }) {
       if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");

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.14",
+      version: "0.1.16",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -172,12 +172,13 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function getManifestCIDCount() view returns (uint256)",
-      "function getManifestCIDs(uint256 offset, uint256 limit) view returns (string[] memory, uint256 total)",
-      "function getManifestCID(uint256 index) view returns (string)",
-      "function libraries(string manifestCID) view returns (string previousCID, uint256 timestamp, address proposer, uint256 promptCount)",
-      "function subdaoLibraryLatest(bytes32 key) view returns (string)",
-      "function hasScopedOwnership(address subdao, string manifestCID) view returns (bool)"
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version)",
+      "function daoTimelock(address) view returns (address)",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version))",
+      "function updateLibrary(address dao, string manifestCID, string version)",
+      "function registerDAO(address dao, address timelock)",
+      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version)",
+      "event DAORegistered(address indexed dao, address indexed timelock)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",
@@ -1231,15 +1232,35 @@ var require_ipfs = __commonJS({
         if (metadata) {
           formData.append("pinataMetadata", JSON.stringify(metadata));
         }
-        const headers = { ...formData.getHeaders() };
+        const endpoint = `${config.pinata.apiUrl}/pinning/pinFileToIPFS`;
+        const sendWithAuthMode = async (mode) => {
+          const headers = { ...formData.getHeaders() };
+          if (mode === "jwt") {
+            headers.Authorization = `Bearer ${config.pinata.jwt}`;
+          } else {
+            headers.pinata_api_key = config.pinata.apiKey;
+            headers.pinata_secret_api_key = config.pinata.secretKey;
+          }
+          return axiosInstance.post(endpoint, formData, { headers, timeout: config.timeoutMs });
+        };
+        let response;
+        let lastError;
         if (config.pinata.jwt) {
-          headers.Authorization = `Bearer ${config.pinata.jwt}`;
+          try {
+            response = await sendWithAuthMode("jwt");
+          } catch (error) {
+            lastError = error;
+            const status = error?.response?.status;
+            const reason = error?.response?.data?.error?.reason || "";
+            const isInvalidJwt = status === 401 && typeof reason === "string" && reason.toUpperCase().includes("INVALID_CREDENTIALS");
+            if (!config.pinata.apiKey || !config.pinata.secretKey || !isInvalidJwt) {
+              throw error;
+            }
+            response = await sendWithAuthMode("keys");
+          }
         } else {
-          headers.pinata_api_key = config.pinata.apiKey;
-          headers.pinata_secret_api_key = config.pinata.secretKey;
+          response = await sendWithAuthMode("keys");
         }
-        const endpoint = `${config.pinata.apiUrl}/pinning/pinFileToIPFS`;
-        const response = await axiosInstance.post(endpoint, formData, { headers, timeout: config.timeoutMs });
         const cid = response?.data?.IpfsHash || response?.data?.cid || response?.data?.Hash;
         if (!cid) {
           throw new Error("Pinata upload did not return IpfsHash");
@@ -1875,7 +1896,7 @@ var require_validation = __commonJS({
             schemaPath: null,
             errors: [{ keyword: "schema", instancePath: "/", message: "manifest schema not found" }],
             hints: [
-              'Ensure docs/schemas/manifest.schema.json exists (run "sage library scaffold" to regenerate)'
+              'Ensure docs/schemas/manifest.schema.json exists (run "sage project scaffold" to regenerate)'
             ],
             manifestPath
           };
@@ -2016,93 +2037,95 @@ var require_library = __commonJS({
         throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
       }
     }
-    async function listManifests({ provider, registry, offset = 0, limit = 50 }) {
+    async function listManifests({ provider, registry, factoryAddress, offset = 0, limit = 50 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const [cids, total] = await contract.getManifestCIDs(offset, limit);
+      if (!factoryAddress) throw new SageSDKError(CODES.INVALID_ARGS, "factoryAddress required for V4 listing");
+      const factory = new Contract(factoryAddress, ABI.FactoryRead, provider);
+      const totalSubDAOs = await factory.getSubDAOCount();
       const manifests = [];
-      for (const cid of cids) {
-        manifests.push(await getManifestInfo({ provider, registry: addr, manifestCID: cid }));
+      const start = Number(offset);
+      const end = Math.min(start + Number(limit), Number(totalSubDAOs));
+      for (let i = start; i < end; i++) {
+        const subdao = await factory.subDaos(i);
+        const info = await getLatestLibrary({ provider, registry, subdao });
+        if (info && info.manifestCID) {
+          manifests.push(info);
+        }
       }
-      return { total: BigInt(total.toString()), manifests };
+      return { total: BigInt(totalSubDAOs), manifests };
     }
-    async function getManifestInfo({ provider, registry, manifestCID }) {
+    async function getLibraryInfo({ provider, registry, subdao }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
       const addr = normalise(registry, "registry");
+      const dao = normalise(subdao, "subdao");
       const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const [previousCID, timestamp, proposer, promptCount] = await contract.libraries(manifestCID);
+      const info = await contract.getLibrary(dao);
       return {
-        manifestCID,
-        previousCID,
-        timestamp: BigInt(timestamp.toString()),
-        proposer: getAddress(proposer),
-        promptCount: Number(promptCount)
+        manifestCID: info.manifestCID,
+        previousCID: "",
+        // Not tracked on-chain in V4 (history is in events/subgraph)
+        timestamp: BigInt(info.lastUpdated.toString()),
+        proposer: getAddress(info.lastUpdater),
+        promptCount: 0,
+        // Not tracked on-chain in V4
+        version: info.version
       };
     }
+    async function getManifestInfo({ provider, registry, manifestCID }) {
+      throw new SageSDKError(CODES.UNSUPPORTED_OPERATION, "getManifestInfo(cid) is not supported in V4. Use getLibraryInfo(subdao).");
+    }
     function _computeLibraryKey(subdao, libraryId) {
-      const coder = AbiCoder.defaultAbiCoder ? AbiCoder.defaultAbiCoder() : new AbiCoder();
-      const encoded = coder.encode(["address", "string"], [getAddress(subdao), String(libraryId)]);
-      return keccak256(encoded);
+      return getAddress(subdao);
     }
-    async function getLatestLibrary({ provider, registry, subdao, libraryId = "main" }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = _computeLibraryKey(sub, libraryId);
-      const latestCID = await contract.subdaoLibraryLatest(key).catch(() => "");
-      if (!latestCID || latestCID.length === 0) return null;
-      const info = await getManifestInfo({ provider, registry: addr, manifestCID: latestCID });
-      return info;
+    async function getLatestLibrary({ provider, registry, subdao }) {
+      return getLibraryInfo({ provider, registry, subdao });
     }
-    async function getBeforeAfterForUpdate({ provider, registry, subdao, libraryId = "main", newCid }) {
+    async function getBeforeAfterForUpdate({ provider, registry, subdao, newCid }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = _computeLibraryKey(sub, libraryId);
-      const prev = await contract.subdaoLibraryLatest(key).catch(() => "");
-      return { previousCID: prev || null, newCID: String(newCid), libraryId: String(libraryId) };
+      const info = await getLatestLibrary({ provider, registry, subdao });
+      return {
+        previousCID: info ? info.manifestCID : null,
+        newCID: String(newCid),
+        version: info ? info.version : "0.0.0"
+      };
     }
     async function hasScopedOwnership({ provider, registry, subdao, manifestCID }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      return contract.hasScopedOwnership(sub, manifestCID);
+      const info = await getLatestLibrary({ provider, registry, subdao });
+      return info && info.manifestCID === manifestCID;
     }
-    function buildUpdateLibraryForSubDAOTx({ registry, subdao, manifestCID, promptCount, libraryId = "main" }) {
+    function buildUpdateLibraryTx({ registry, subdao, manifestCID, version = "1.0.0" }) {
       const to = normalise(registry, "registry");
       if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
-      const iface = new Interface(["function updateLibraryForSubDAO(address,string,string,uint256)"]);
-      const data = iface.encodeFunctionData("updateLibraryForSubDAO", [
+      const iface = new Interface(["function updateLibrary(address,string,string)"]);
+      const data = iface.encodeFunctionData("updateLibrary", [
         normalise(subdao, "subdao"),
-        String(libraryId || "main"),
         String(manifestCID),
-        BigInt(promptCount ?? 0n)
+        String(version)
       ]);
       return { to, data, value: 0n };
     }
+    var buildUpdateLibraryForSubDAOTx = buildUpdateLibraryTx;
     module2.exports = {
       listManifests,
       getManifestInfo,
+      getLibraryInfo,
       getLatestLibrary,
       hasScopedOwnership,
+      buildUpdateLibraryTx,
       buildUpdateLibraryForSubDAOTx,
       _computeLibraryKey,
       getBeforeAfterForUpdate,
       /** Build an authorizeTimelock(timelock, subdao) call for a LibraryRegistry. */
       buildAuthorizeTimelockTx: function buildAuthorizeTimelockTx({ registry, timelock, subdao }) {
         const to = normalise(registry, "registry");
-        const iface = new Interface(["function authorizeTimelock(address,address)"]);
-        const data = iface.encodeFunctionData("authorizeTimelock", [normalise(timelock, "timelock"), normalise(subdao, "subdao")]);
+        const iface = new Interface(["function registerDAO(address,address)"]);
+        const data = iface.encodeFunctionData("registerDAO", [normalise(subdao, "subdao"), normalise(timelock, "timelock")]);
         return { to, data, value: 0n };
       },
       searchRegistry,
       validation,
-      /** Simulate calling a registry function as the timelock to verify authority/roles */
+      /** Simulate as timelock */
       simulateAsTimelock: async function simulateAsTimelock({ provider, registry, to, data, timelock }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         const reg = normalise(registry, "registry");
@@ -2115,10 +2138,9 @@ var require_library = __commonJS({
           return { ok: false, error: { type: "Revert", message: String(err && err.message || err) } };
         }
       },
-      /** Best-effort execution readiness for updateLibraryForSubDAO by simulating as timelock. */
-      executionReadiness: async function executionReadiness({ provider, registry, timelock, subdao, libraryId = "main", manifestCID = "", promptCount = 0 }) {
+      executionReadiness: async function executionReadiness({ provider, registry, timelock, subdao, manifestCID = "", version = "1.0.0" }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-        const payload = buildUpdateLibraryForSubDAOTx({ registry, subdao, manifestCID, promptCount, libraryId });
+        const payload = buildUpdateLibraryTx({ registry, subdao, manifestCID, version });
         const sim = await this.simulateAsTimelock({ provider, registry, to: payload.to, data: payload.data, timelock });
         const out = { ok: !!sim.ok, error: sim.ok ? null : sim.error?.message || "revert", missingRole: null };
         return out;
@@ -2931,7 +2953,9 @@ var require_subdao = __commonJS({
     }
     var SubDAOInterface = new Interface([
       "function stake(uint256)",
-      "function unstake(uint256)"
+      "function unstake(uint256)",
+      // Optional on newer SubDAO implementations; provided for tx building only.
+      "function setProfileCid(string)"
     ]);
     function buildStakeTx({ subdao, amount }) {
       const addr = normalise(subdao, "subdao");
@@ -2943,12 +2967,21 @@ var require_subdao = __commonJS({
       const data = SubDAOInterface.encodeFunctionData("unstake", [BigInt(amount)]);
       return { to: addr, data, value: 0n };
     }
+    function buildSetProfileCidTx({ subdao, profileCid }) {
+      const addr = normalise(subdao, "subdao");
+      if (!profileCid || typeof profileCid !== "string" || !profileCid.trim()) {
+        throw new SageSDKError(CODES.INVALID_ARGS, "profileCid (CID string) required");
+      }
+      const data = SubDAOInterface.encodeFunctionData("setProfileCid", [String(profileCid)]);
+      return { to: addr, data, value: 0n };
+    }
     module2.exports = {
       discoverSubDAOs,
       getSubDAOInfo,
       getSubDAOUserStats,
       buildStakeTx,
-      buildUnstakeTx
+      buildUnstakeTx,
+      buildSetProfileCidTx
     };
     async function ensureSxxxBurnAllowance({ signer, sxxx, owner, spender, amount }) {
       if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");

package/dist/node/index.mjs

@@ -20,7 +20,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.14",
+      version: "0.1.16",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -178,12 +178,13 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function getManifestCIDCount() view returns (uint256)",
-      "function getManifestCIDs(uint256 offset, uint256 limit) view returns (string[] memory, uint256 total)",
-      "function getManifestCID(uint256 index) view returns (string)",
-      "function libraries(string manifestCID) view returns (string previousCID, uint256 timestamp, address proposer, uint256 promptCount)",
-      "function subdaoLibraryLatest(bytes32 key) view returns (string)",
-      "function hasScopedOwnership(address subdao, string manifestCID) view returns (bool)"
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version)",
+      "function daoTimelock(address) view returns (address)",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version))",
+      "function updateLibrary(address dao, string manifestCID, string version)",
+      "function registerDAO(address dao, address timelock)",
+      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version)",
+      "event DAORegistered(address indexed dao, address indexed timelock)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",
@@ -1237,15 +1238,35 @@ var require_ipfs = __commonJS({
         if (metadata) {
           formData.append("pinataMetadata", JSON.stringify(metadata));
         }
-        const headers = { ...formData.getHeaders() };
+        const endpoint = `${config.pinata.apiUrl}/pinning/pinFileToIPFS`;
+        const sendWithAuthMode = async (mode) => {
+          const headers = { ...formData.getHeaders() };
+          if (mode === "jwt") {
+            headers.Authorization = `Bearer ${config.pinata.jwt}`;
+          } else {
+            headers.pinata_api_key = config.pinata.apiKey;
+            headers.pinata_secret_api_key = config.pinata.secretKey;
+          }
+          return axiosInstance.post(endpoint, formData, { headers, timeout: config.timeoutMs });
+        };
+        let response;
+        let lastError;
         if (config.pinata.jwt) {
-          headers.Authorization = `Bearer ${config.pinata.jwt}`;
+          try {
+            response = await sendWithAuthMode("jwt");
+          } catch (error) {
+            lastError = error;
+            const status = error?.response?.status;
+            const reason = error?.response?.data?.error?.reason || "";
+            const isInvalidJwt = status === 401 && typeof reason === "string" && reason.toUpperCase().includes("INVALID_CREDENTIALS");
+            if (!config.pinata.apiKey || !config.pinata.secretKey || !isInvalidJwt) {
+              throw error;
+            }
+            response = await sendWithAuthMode("keys");
+          }
         } else {
-          headers.pinata_api_key = config.pinata.apiKey;
-          headers.pinata_secret_api_key = config.pinata.secretKey;
+          response = await sendWithAuthMode("keys");
         }
-        const endpoint = `${config.pinata.apiUrl}/pinning/pinFileToIPFS`;
-        const response = await axiosInstance.post(endpoint, formData, { headers, timeout: config.timeoutMs });
         const cid = response?.data?.IpfsHash || response?.data?.cid || response?.data?.Hash;
         if (!cid) {
           throw new Error("Pinata upload did not return IpfsHash");
@@ -1881,7 +1902,7 @@ var require_validation = __commonJS({
             schemaPath: null,
             errors: [{ keyword: "schema", instancePath: "/", message: "manifest schema not found" }],
             hints: [
-              'Ensure docs/schemas/manifest.schema.json exists (run "sage library scaffold" to regenerate)'
+              'Ensure docs/schemas/manifest.schema.json exists (run "sage project scaffold" to regenerate)'
             ],
             manifestPath
           };
@@ -2022,93 +2043,95 @@ var require_library = __commonJS({
         throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
       }
     }
-    async function listManifests({ provider, registry, offset = 0, limit = 50 }) {
+    async function listManifests({ provider, registry, factoryAddress, offset = 0, limit = 50 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const [cids, total] = await contract.getManifestCIDs(offset, limit);
+      if (!factoryAddress) throw new SageSDKError(CODES.INVALID_ARGS, "factoryAddress required for V4 listing");
+      const factory = new Contract(factoryAddress, ABI.FactoryRead, provider);
+      const totalSubDAOs = await factory.getSubDAOCount();
       const manifests = [];
-      for (const cid of cids) {
-        manifests.push(await getManifestInfo({ provider, registry: addr, manifestCID: cid }));
+      const start = Number(offset);
+      const end = Math.min(start + Number(limit), Number(totalSubDAOs));
+      for (let i = start; i < end; i++) {
+        const subdao = await factory.subDaos(i);
+        const info = await getLatestLibrary({ provider, registry, subdao });
+        if (info && info.manifestCID) {
+          manifests.push(info);
+        }
       }
-      return { total: BigInt(total.toString()), manifests };
+      return { total: BigInt(totalSubDAOs), manifests };
     }
-    async function getManifestInfo({ provider, registry, manifestCID }) {
+    async function getLibraryInfo({ provider, registry, subdao }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
       const addr = normalise(registry, "registry");
+      const dao = normalise(subdao, "subdao");
       const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const [previousCID, timestamp, proposer, promptCount] = await contract.libraries(manifestCID);
+      const info = await contract.getLibrary(dao);
       return {
-        manifestCID,
-        previousCID,
-        timestamp: BigInt(timestamp.toString()),
-        proposer: getAddress(proposer),
-        promptCount: Number(promptCount)
+        manifestCID: info.manifestCID,
+        previousCID: "",
+        // Not tracked on-chain in V4 (history is in events/subgraph)
+        timestamp: BigInt(info.lastUpdated.toString()),
+        proposer: getAddress(info.lastUpdater),
+        promptCount: 0,
+        // Not tracked on-chain in V4
+        version: info.version
       };
     }
+    async function getManifestInfo({ provider, registry, manifestCID }) {
+      throw new SageSDKError(CODES.UNSUPPORTED_OPERATION, "getManifestInfo(cid) is not supported in V4. Use getLibraryInfo(subdao).");
+    }
     function _computeLibraryKey(subdao, libraryId) {
-      const coder = AbiCoder.defaultAbiCoder ? AbiCoder.defaultAbiCoder() : new AbiCoder();
-      const encoded = coder.encode(["address", "string"], [getAddress(subdao), String(libraryId)]);
-      return keccak256(encoded);
+      return getAddress(subdao);
     }
-    async function getLatestLibrary({ provider, registry, subdao, libraryId = "main" }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = _computeLibraryKey(sub, libraryId);
-      const latestCID = await contract.subdaoLibraryLatest(key).catch(() => "");
-      if (!latestCID || latestCID.length === 0) return null;
-      const info = await getManifestInfo({ provider, registry: addr, manifestCID: latestCID });
-      return info;
+    async function getLatestLibrary({ provider, registry, subdao }) {
+      return getLibraryInfo({ provider, registry, subdao });
     }
-    async function getBeforeAfterForUpdate({ provider, registry, subdao, libraryId = "main", newCid }) {
+    async function getBeforeAfterForUpdate({ provider, registry, subdao, newCid }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = _computeLibraryKey(sub, libraryId);
-      const prev = await contract.subdaoLibraryLatest(key).catch(() => "");
-      return { previousCID: prev || null, newCID: String(newCid), libraryId: String(libraryId) };
+      const info = await getLatestLibrary({ provider, registry, subdao });
+      return {
+        previousCID: info ? info.manifestCID : null,
+        newCID: String(newCid),
+        version: info ? info.version : "0.0.0"
+      };
     }
     async function hasScopedOwnership({ provider, registry, subdao, manifestCID }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(registry, "registry");
-      const sub = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      return contract.hasScopedOwnership(sub, manifestCID);
+      const info = await getLatestLibrary({ provider, registry, subdao });
+      return info && info.manifestCID === manifestCID;
     }
-    function buildUpdateLibraryForSubDAOTx({ registry, subdao, manifestCID, promptCount, libraryId = "main" }) {
+    function buildUpdateLibraryTx({ registry, subdao, manifestCID, version = "1.0.0" }) {
       const to = normalise(registry, "registry");
       if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
-      const iface = new Interface(["function updateLibraryForSubDAO(address,string,string,uint256)"]);
-      const data = iface.encodeFunctionData("updateLibraryForSubDAO", [
+      const iface = new Interface(["function updateLibrary(address,string,string)"]);
+      const data = iface.encodeFunctionData("updateLibrary", [
         normalise(subdao, "subdao"),
-        String(libraryId || "main"),
         String(manifestCID),
-        BigInt(promptCount ?? 0n)
+        String(version)
       ]);
       return { to, data, value: 0n };
     }
+    var buildUpdateLibraryForSubDAOTx = buildUpdateLibraryTx;
     module2.exports = {
       listManifests,
       getManifestInfo,
+      getLibraryInfo,
       getLatestLibrary,
       hasScopedOwnership,
+      buildUpdateLibraryTx,
       buildUpdateLibraryForSubDAOTx,
       _computeLibraryKey,
       getBeforeAfterForUpdate,
       /** Build an authorizeTimelock(timelock, subdao) call for a LibraryRegistry. */
       buildAuthorizeTimelockTx: function buildAuthorizeTimelockTx({ registry, timelock, subdao }) {
         const to = normalise(registry, "registry");
-        const iface = new Interface(["function authorizeTimelock(address,address)"]);
-        const data = iface.encodeFunctionData("authorizeTimelock", [normalise(timelock, "timelock"), normalise(subdao, "subdao")]);
+        const iface = new Interface(["function registerDAO(address,address)"]);
+        const data = iface.encodeFunctionData("registerDAO", [normalise(subdao, "subdao"), normalise(timelock, "timelock")]);
         return { to, data, value: 0n };
       },
       searchRegistry,
       validation,
-      /** Simulate calling a registry function as the timelock to verify authority/roles */
+      /** Simulate as timelock */
       simulateAsTimelock: async function simulateAsTimelock({ provider, registry, to, data, timelock }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         const reg = normalise(registry, "registry");
@@ -2121,10 +2144,9 @@ var require_library = __commonJS({
           return { ok: false, error: { type: "Revert", message: String(err && err.message || err) } };
         }
       },
-      /** Best-effort execution readiness for updateLibraryForSubDAO by simulating as timelock. */
-      executionReadiness: async function executionReadiness({ provider, registry, timelock, subdao, libraryId = "main", manifestCID = "", promptCount = 0 }) {
+      executionReadiness: async function executionReadiness({ provider, registry, timelock, subdao, manifestCID = "", version = "1.0.0" }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-        const payload = buildUpdateLibraryForSubDAOTx({ registry, subdao, manifestCID, promptCount, libraryId });
+        const payload = buildUpdateLibraryTx({ registry, subdao, manifestCID, version });
         const sim = await this.simulateAsTimelock({ provider, registry, to: payload.to, data: payload.data, timelock });
         const out = { ok: !!sim.ok, error: sim.ok ? null : sim.error?.message || "revert", missingRole: null };
         return out;
@@ -2937,7 +2959,9 @@ var require_subdao = __commonJS({
     }
     var SubDAOInterface = new Interface([
       "function stake(uint256)",
-      "function unstake(uint256)"
+      "function unstake(uint256)",
+      // Optional on newer SubDAO implementations; provided for tx building only.
+      "function setProfileCid(string)"
     ]);
     function buildStakeTx({ subdao, amount }) {
       const addr = normalise(subdao, "subdao");
@@ -2949,12 +2973,21 @@ var require_subdao = __commonJS({
       const data = SubDAOInterface.encodeFunctionData("unstake", [BigInt(amount)]);
       return { to: addr, data, value: 0n };
     }
+    function buildSetProfileCidTx({ subdao, profileCid }) {
+      const addr = normalise(subdao, "subdao");
+      if (!profileCid || typeof profileCid !== "string" || !profileCid.trim()) {
+        throw new SageSDKError(CODES.INVALID_ARGS, "profileCid (CID string) required");
+      }
+      const data = SubDAOInterface.encodeFunctionData("setProfileCid", [String(profileCid)]);
+      return { to: addr, data, value: 0n };
+    }
     module2.exports = {
       discoverSubDAOs,
       getSubDAOInfo,
       getSubDAOUserStats,
       buildStakeTx,
-      buildUnstakeTx
+      buildUnstakeTx,
+      buildSetProfileCidTx
     };
     async function ensureSxxxBurnAllowance({ signer, sxxx, owner, spender, amount }) {
       if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sage-protocol/sdk",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",