@sage-protocol/sdk 0.1.18 → 0.1.21

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.18",
+      version: "0.1.21",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -136,7 +136,6 @@ var require_abi = __commonJS({
       "function stableCreationFee() view returns (uint256)",
       "function stableFeeReceiver() view returns (address)",
       "function stableCreationEnabled() view returns (bool)",
-      "function stablePromptForkFee() view returns (uint256)",
       "function stableForkFee() view returns (uint256)",
       // Core factory reads
       "function timelockMinDelay() view returns (uint256)",
@@ -178,13 +177,18 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version)",
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee)",
       "function daoTimelock(address) view returns (address)",
-      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version))",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee))",
+      "function getLibraryForkFee(address dao) view returns (uint256)",
+      "function setLibraryForkFee(address dao, uint256 fee)",
       "function updateLibrary(address dao, string manifestCID, string version)",
       "function registerDAO(address dao, address timelock)",
+      "function registerForkedDAO(address childDAO, address childTimelock, address parentDAO, string manifestCID, string version)",
       "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version)",
-      "event DAORegistered(address indexed dao, address indexed timelock)"
+      "event DAORegistered(address indexed dao, address indexed timelock)",
+      "event LibraryForked(address indexed parentDAO, address indexed childDAO)",
+      "event LibraryForkFeeUpdated(address indexed dao, uint256 fee)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",
@@ -1756,7 +1760,6 @@ var require_ipfs = __commonJS({
             headers["X-Wallet-Address"] = auth.address;
             headers["X-Wallet-Signature"] = auth.signature;
             headers["X-Wallet-Nonce"] = auth.nonce;
-            headers["X-Wallet-Message"] = auth.message;
           }
           return { headers, auth };
         }
@@ -1777,8 +1780,7 @@ var require_ipfs = __commonJS({
             ...extraHeaders,
             "X-Wallet-Address": auth.address,
             "X-Wallet-Signature": auth.signature,
-            "X-Wallet-Nonce": auth.nonce,
-            "X-Wallet-Message": auth.message
+            "X-Wallet-Nonce": auth.nonce
           };
           return { headers, auth };
         }
@@ -1799,6 +1801,13 @@ var require_ipfs = __commonJS({
           order.push(name);
         };
         const normalizedPreference = Array.isArray(preference) ? preference.map((p) => toLowerSafe(p)).filter(Boolean) : preference ? [toLowerSafe(preference)].filter(Boolean) : [];
+        if (process.env.SAGE_DEBUG_WORKER === "1") {
+          console.log("[SDK DEBUG] resolveProviderOrder preference:", preference);
+          console.log("[SDK DEBUG] normalizedPreference:", normalizedPreference);
+          console.log("[SDK DEBUG] config.provider:", config.provider);
+          console.log("[SDK DEBUG] shouldUseWorker():", shouldUseWorker());
+          console.log("[SDK DEBUG] hasPinataCreds():", hasPinataCreds());
+        }
         normalizedPreference.forEach(append);
         if (shouldUseWorker()) append("worker");
         if (hasPinataCreds()) append("pinata");
@@ -1806,17 +1815,90 @@ var require_ipfs = __commonJS({
         if (config.simulate) append("simulate");
         return order;
       }
-      async function uploadViaWorker(payload, { warm, gateways } = {}) {
+      async function uploadViaWorker(payload, { warm, gateways, pin: pin2 } = {}) {
+        const uploadUrl = workerUrl("upload");
+        if (process.env.SAGE_DEBUG_WORKER === "1") {
+          console.log("[SDK DEBUG] uploadViaWorker called");
+          console.log("[SDK DEBUG]   workerBaseUrl:", workerBaseUrl());
+          console.log("[SDK DEBUG]   uploadUrl:", uploadUrl);
+          console.log("[SDK DEBUG]   workerHasAuth:", workerHasAuth());
+        }
         const { headers, auth } = await buildWorkerAuthHeaders({ "Content-Type": "application/json" });
         const body = { ...payload };
         if (auth) body.auth = auth;
-        const response = await axiosInstance.post(workerUrl("upload"), body, { headers, timeout: config.timeoutMs });
-        const cid = response?.data?.cid || response?.data?.IpfsHash;
+        if (pin2) {
+          body.pin = typeof pin2 === "string" ? { duration: pin2 } : pin2;
+        }
+        if (process.env.SAGE_DEBUG_WORKER === "1") {
+          console.log("[SDK DEBUG]   headers:", Object.keys(headers));
+          console.log("[SDK DEBUG]   hasAuth:", !!auth);
+          if (pin2) console.log("[SDK DEBUG]   pin:", JSON.stringify(body.pin));
+        }
+        let response;
+        try {
+          response = await axiosInstance.post(uploadUrl, body, { headers, timeout: config.timeoutMs });
+          if (process.env.SAGE_DEBUG_WORKER === "1") {
+            console.log("[SDK DEBUG] Upload response status:", response?.status);
+            console.log("[SDK DEBUG] Upload response data:", JSON.stringify(response?.data || {}));
+          }
+        } catch (uploadErr) {
+          if (process.env.SAGE_DEBUG_WORKER === "1") {
+            console.log("[SDK DEBUG] Upload error:", uploadErr.message);
+            console.log("[SDK DEBUG] Response status:", uploadErr.response?.status);
+            console.log("[SDK DEBUG] Response data:", JSON.stringify(uploadErr.response?.data || {}));
+          }
+          const status = uploadErr.response?.status;
+          const data2 = uploadErr.response?.data;
+          if (status === 400 && data2?.error === "content_blocked") {
+            const error = new Error("content_blocked");
+            error.code = "CONTENT_BLOCKED";
+            error.categories = data2.categories || [];
+            error.reason = data2.reason;
+            error.response = data2;
+            throw error;
+          }
+          if (status === 402) {
+            const error = new Error("payment_required");
+            error.code = "PAYMENT_REQUIRED";
+            error.creditsNeeded = data2?.creditsNeeded;
+            error.balance = data2?.balance;
+            error.duration = data2?.duration;
+            error.accepts = data2?.accepts;
+            error.response = data2;
+            throw error;
+          }
+          throw uploadErr;
+        }
+        const data = response?.data || {};
+        const cid = data.cid || data.IpfsHash;
+        if (response?.status === 202 || data.status === "pending_review") {
+          return {
+            cid: cid || null,
+            provider: "worker",
+            status: "pending_review",
+            categories: data.categories || [],
+            response: data
+          };
+        }
         if (!cid) {
           throw new Error("Worker response missing cid");
         }
         if (warm || config.shouldWarm) await warmGateways(cid, { gateways });
-        return { cid, provider: "worker", response: response?.data || null };
+        const result = {
+          cid,
+          provider: "worker",
+          response: data
+        };
+        if (data.moderation) {
+          result.moderation = data.moderation;
+        }
+        if (data.pinned !== void 0) {
+          result.pinned = data.pinned;
+          result.expiresAt = data.expiresAt;
+          result.creditsPaid = data.creditsPaid;
+          result.urls = data.urls;
+        }
+        return result;
       }
       async function uploadToPinata(payload, { filename = "payload.json", metadata, warm, gateways } = {}) {
         if (!hasPinataCreds()) {
@@ -1894,7 +1976,7 @@ var require_ipfs = __commonJS({
         return { cid, provider: "simulate" };
       }
       async function uploadPayload(payload, options2 = {}) {
-        const { providers, provider, warm, gateways, filename, metadata } = options2;
+        const { providers, provider, warm, gateways, filename, metadata, pin: pin2 } = options2;
         const order = resolveProviderOrder(providers || provider);
         if (!order.length) {
           throw new Error("No IPFS providers configured. Set Pinata credentials, worker upload, or enable test mode");
@@ -1903,7 +1985,7 @@ var require_ipfs = __commonJS({
         for (const candidate of order) {
           try {
             if (candidate === "worker") {
-              return await uploadViaWorker(payload, { warm, gateways });
+              return await uploadViaWorker(payload, { warm, gateways, pin: pin2 });
             }
             if (candidate === "pinata") {
               return await uploadToPinata(payload, { filename, metadata, warm, gateways });
@@ -1915,6 +1997,9 @@ var require_ipfs = __commonJS({
               return await uploadSimulated(payload, { warm, gateways });
             }
           } catch (error2) {
+            if (error2.code === "CONTENT_BLOCKED" || error2.code === "PAYMENT_REQUIRED") {
+              throw error2;
+            }
             errors.push({ provider: candidate, error: error2 });
           }
         }
@@ -1923,7 +2008,7 @@ var require_ipfs = __commonJS({
         throw error;
       }
       async function uploadPrompt(options2 = {}) {
-        const { prompt, providers, provider, warm, gateways } = options2;
+        const { prompt, providers, provider, warm, gateways, pin: pin2 } = options2;
         if (!prompt || typeof prompt !== "object") {
           throw new Error("prompt payload required");
         }
@@ -1949,6 +2034,7 @@ var require_ipfs = __commonJS({
           provider,
           warm,
           gateways,
+          pin: pin2,
           filename: `${prompt.name || "prompt"}.json`,
           metadata
         });
@@ -2183,8 +2269,7 @@ var require_ipfs = __commonJS({
         "Content-Type": "application/json",
         "X-Wallet-Address": address,
         "X-Wallet-Signature": signature,
-        "X-Wallet-Nonce": nonce,
-        "X-Wallet-Message": message
+        "X-Wallet-Nonce": nonce
       };
       let verified = false;
       try {
@@ -3042,13 +3127,10 @@ var require_governance = __commonJS({
       } else {
         const govAddr = normaliseGovernor(governor);
         try {
-          const iface = new Interface(["function sxxxToken() view returns (address)"]);
-          const data = iface.encodeFunctionData("sxxxToken", []);
-          const ret = await provider.call({ to: govAddr, data });
-          const [tok] = AbiCoder.defaultAbiCoder().decode(["address"], ret);
-          addr = getAddress(tok);
+          const chain = await resolveVotesTokenChain({ provider, governor: govAddr });
+          addr = getAddress(chain.votingToken);
         } catch (err) {
-          throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve governance token from governor", { cause: err });
+          throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve votes token from governor", { cause: err });
         }
       }
       const user = getAddress(account);
@@ -3129,6 +3211,210 @@ var require_governance = __commonJS({
       const token = await g.sxxxToken();
       return buildDelegateTx({ token, delegatee: account });
     }
+    async function resolveVotesTokenChain({ provider, subdao, governor }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!subdao && !governor) throw new SageSDKError(CODES.INVALID_ARGS, "subdao or governor required");
+      let votingToken = null;
+      if (governor) {
+        const govAddr = normaliseGovernor(governor);
+        try {
+          const iTok = new Interface(["function token() view returns (address)"]);
+          const data = iTok.encodeFunctionData("token", []);
+          const ret = await provider.call({ to: govAddr, data });
+          if (ret && ret !== "0x") {
+            const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], ret);
+            votingToken = addr;
+          }
+        } catch (_) {
+        }
+        if (!votingToken) {
+          try {
+            const iGov = new Interface(["function sxxxToken() view returns (address)"]);
+            const d2 = iGov.encodeFunctionData("sxxxToken", []);
+            const r2 = await provider.call({ to: govAddr, data: d2 });
+            if (r2 && r2 !== "0x") {
+              const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], r2);
+              votingToken = addr;
+            }
+          } catch (_) {
+          }
+        }
+      }
+      if (!votingToken && subdao) {
+        try {
+          const subAddr = getAddress(subdao);
+          const iSub = new Interface(["function stakeToken() view returns (address)"]);
+          const d3 = iSub.encodeFunctionData("stakeToken", []);
+          const r3 = await provider.call({ to: subAddr, data: d3 });
+          if (r3 && r3 !== "0x") {
+            const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], r3);
+            votingToken = addr;
+          }
+        } catch (_) {
+        }
+      }
+      if (!votingToken) {
+        throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve votes token");
+      }
+      const votingTokenNorm = getAddress(votingToken);
+      let baseToken = votingTokenNorm;
+      let isWrapper = false;
+      try {
+        const wrapperIface = new Interface([
+          "function baseToken() view returns (address)",
+          "function dao() view returns (address)"
+        ]);
+        const [rawBase, rawDao] = await Promise.all([
+          provider.call({ to: votingTokenNorm, data: wrapperIface.encodeFunctionData("baseToken", []) }),
+          provider.call({ to: votingTokenNorm, data: wrapperIface.encodeFunctionData("dao", []) })
+        ]);
+        if (rawBase && rawBase !== "0x" && rawDao && rawDao !== "0x") {
+          const [decodedBase] = AbiCoder.defaultAbiCoder().decode(["address"], rawBase);
+          const [decodedDao] = AbiCoder.defaultAbiCoder().decode(["address"], rawDao);
+          const baseNorm = getAddress(decodedBase);
+          const daoNorm = getAddress(decodedDao);
+          if (!subdao || daoNorm === getAddress(subdao)) {
+            baseToken = baseNorm;
+            isWrapper = true;
+          }
+        }
+      } catch (_) {
+      }
+      return { votingToken: votingTokenNorm, baseToken, isWrapper };
+    }
+    async function describeVotesToken({ provider, subdao, governor }) {
+      const { votingToken, baseToken, isWrapper } = await resolveVotesTokenChain({ provider, subdao, governor });
+      let multiplierNFT = null;
+      let basis = null;
+      if (isWrapper) {
+        try {
+          const wrapper = new Contract(votingToken, ABI.MultipliedVotes, provider);
+          multiplierNFT = await wrapper.multiplierNFT().catch(() => null);
+          basis = await wrapper.BASIS().catch(() => null);
+        } catch (_) {
+        }
+      }
+      const votingNorm = getAddress(votingToken);
+      const baseNorm = getAddress(baseToken);
+      const multiplierNorm = multiplierNFT && /^0x[0-9a-fA-F]{40}$/.test(String(multiplierNFT)) ? getAddress(multiplierNFT) : null;
+      const basisBig = basis != null ? BigInt(String(basis)) : null;
+      let description;
+      if (!isWrapper) {
+        description = `Voting token = ERC20Votes at ${votingNorm}`;
+      } else {
+        const basisStr = basisBig != null ? basisBig.toString() : "10000";
+        description = `Voting token = MultipliedVotes(base=${baseNorm}, multiplierNFT=${multiplierNorm || "unknown"}, BASIS=${basisStr})`;
+        if (subdao) {
+          description += ` for DAO ${getAddress(subdao)}`;
+        }
+      }
+      return {
+        votingToken: votingNorm,
+        baseToken: baseNorm,
+        isWrapper,
+        multiplierNFT: multiplierNorm,
+        basis: basisBig,
+        description
+      };
+    }
+    async function getVotingStatus({ provider, subdao, governor, account }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!governor && !subdao) throw new SageSDKError(CODES.INVALID_ARGS, "governor or subdao required");
+      if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
+      const acct = getAddress(account);
+      let govAddr = null;
+      let subdaoAddr = null;
+      if (governor) {
+        govAddr = normaliseGovernor(governor);
+      }
+      if (subdao) {
+        subdaoAddr = getAddress(subdao);
+        if (!govAddr) {
+          try {
+            const sub = new Contract(subdaoAddr, ["function governor() view returns (address)"], provider);
+            govAddr = getAddress(await sub.governor());
+          } catch (_) {
+          }
+        }
+      }
+      if (!govAddr) throw new SageSDKError(CODES.INVALID_ARGS, "could not resolve governor address");
+      let threshold = null;
+      try {
+        const g = new Contract(govAddr, ABI.Governor, provider);
+        const t = await g.proposalThreshold();
+        threshold = BigInt(t.toString());
+      } catch (_) {
+      }
+      const desc = await describeVotesToken({ provider, subdao: subdaoAddr || void 0, governor: govAddr });
+      let stakeToken = null;
+      if (subdaoAddr) {
+        try {
+          const sub = new Contract(subdaoAddr, ["function stakeToken() view returns (address)"], provider);
+          const st = await sub.stakeToken();
+          if (st && /^0x[0-9a-fA-F]{40}$/.test(String(st))) {
+            stakeToken = getAddress(st);
+          }
+        } catch (_) {
+        }
+      }
+      const VotesABI = [
+        "function getVotes(address) view returns (uint256)",
+        "function delegates(address) view returns (address)",
+        "function balanceOf(address) view returns (uint256)"
+      ];
+      let votingPower = null;
+      let delegate = null;
+      let tokenBalance = null;
+      try {
+        const votingC = new Contract(desc.votingToken, VotesABI, provider);
+        const vp = await votingC.getVotes(acct).catch(() => null);
+        if (vp != null) votingPower = BigInt(vp.toString());
+        const del = await votingC.delegates(acct).catch(() => null);
+        if (del && /^0x[0-9a-fA-F]{40}$/.test(String(del))) delegate = getAddress(del);
+        const bal = await votingC.balanceOf(acct).catch(() => null);
+        if (bal != null) tokenBalance = BigInt(bal.toString());
+      } catch (_) {
+      }
+      const canPropose = threshold != null && votingPower != null ? votingPower >= threshold : null;
+      let stakeTokenVotes = null;
+      let stakeTokenDelegate = null;
+      let stakeTokenBalance = null;
+      const tokenMismatch = !!stakeToken && stakeToken.toLowerCase() !== desc.votingToken.toLowerCase();
+      if (stakeToken && tokenMismatch) {
+        try {
+          const stakeC = new Contract(stakeToken, VotesABI, provider);
+          const sv = await stakeC.getVotes(acct).catch(() => null);
+          if (sv != null) stakeTokenVotes = BigInt(sv.toString());
+          const sd = await stakeC.delegates(acct).catch(() => null);
+          if (sd && /^0x[0-9a-fA-F]{40}$/.test(String(sd))) {
+            stakeTokenDelegate = getAddress(sd);
+          }
+          const sb = await stakeC.balanceOf(acct).catch(() => null);
+          if (sb != null) stakeTokenBalance = BigInt(sb.toString());
+        } catch (_) {
+        }
+      }
+      return {
+        subdao: subdaoAddr,
+        governor: govAddr,
+        stakeToken,
+        votingToken: desc.votingToken,
+        baseToken: desc.baseToken,
+        isWrapper: desc.isWrapper,
+        multiplierNFT: desc.multiplierNFT,
+        basis: desc.basis,
+        threshold,
+        votingPower,
+        tokenBalance,
+        delegate,
+        canPropose,
+        tokenMismatch,
+        stakeTokenVotes,
+        stakeTokenDelegate,
+        stakeTokenBalance,
+        description: desc.description
+      };
+    }
     module2.exports = {
       getGovernorInfo,
       getProposal,
@@ -3160,52 +3446,28 @@ var require_governance = __commonJS({
        * - SubDAO.stakeToken() (when subdao provided)
        */
       resolveVotesToken: async function resolveVotesToken({ provider, subdao, governor }) {
-        if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-        if (!subdao && !governor) throw new SageSDKError(CODES.INVALID_ARGS, "subdao or governor required");
-        if (governor) {
-          const govAddr = normaliseGovernor(governor);
-          try {
-            const iTok = new Interface(["function token() view returns (address)"]);
-            const data = iTok.encodeFunctionData("token", []);
-            const ret = await provider.call({ to: govAddr, data });
-            if (ret && ret !== "0x") {
-              const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], ret);
-              return getAddress(addr);
-            }
-          } catch (_) {
-          }
-          try {
-            const iGov = new Interface(["function sxxxToken() view returns (address)"]);
-            const d2 = iGov.encodeFunctionData("sxxxToken", []);
-            const r2 = await provider.call({ to: govAddr, data: d2 });
-            if (r2 && r2 !== "0x") {
-              const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], r2);
-              return getAddress(addr);
-            }
-          } catch (_) {
-          }
-        }
-        if (subdao) {
-          try {
-            const subAddr = getAddress(subdao);
-            const iSub = new Interface(["function stakeToken() view returns (address)"]);
-            const d3 = iSub.encodeFunctionData("stakeToken", []);
-            const r3 = await provider.call({ to: subAddr, data: d3 });
-            if (r3 && r3 !== "0x") {
-              const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], r3);
-              return getAddress(addr);
-            }
-          } catch (_) {
-          }
-        }
-        throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve votes token");
+        const { votingToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+        return votingToken;
       },
+      /**
+       * Resolve the IVotes token chain used for voting (wrapper + base token).
+       * See resolveVotesTokenChain() for details.
+       */
+      resolveVotesTokenChain,
+      /**
+       * Human-friendly description of the voting token wiring for a Governor/SubDAO.
+       */
+      describeVotesToken,
+      /**
+       * Get voting status for an account relative to a Governor/SubDAO.
+       */
+      getVotingStatus,
       /** Build a delegate(self) tx using the preferred votes token resolution path. */
       buildDelegateSelfPreferred: async function buildDelegateSelfPreferred({ provider, subdao, governor, account }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
-        const token = await this.resolveVotesToken({ provider, subdao, governor });
-        return buildDelegateTx({ token, delegatee: account });
+        const { baseToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+        return buildDelegateTx({ token: baseToken, delegatee: account });
       },
       /**
        * Send a delegate(self) and verify votes at latest-1.
@@ -3214,15 +3476,15 @@ var require_governance = __commonJS({
       delegateSelfAndVerify: async function delegateSelfAndVerify({ provider, subdao, governor, account, signer = null, minVotes = null }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
-        const token = await this.resolveVotesToken({ provider, subdao, governor });
-        const payload = buildDelegateTx({ token, delegatee: account });
+        const { votingToken, baseToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+        const payload = buildDelegateTx({ token: baseToken, delegatee: account });
         let txHash = null;
         if (signer && typeof signer.sendTransaction === "function") {
           const tx = await signer.sendTransaction({ to: payload.to, data: payload.data, value: payload.value });
           txHash = tx?.hash || null;
           if (tx?.wait) await tx.wait();
         }
-        const votes = await getVotesLatestMinusOne({ provider, token, account });
+        const votes = await getVotesLatestMinusOne({ provider, token: votingToken, account });
         const ok = minVotes != null ? votes >= BigInt(minVotes) : votes > 0n;
         return { txHash, ok, votes, payload };
       },
@@ -3276,8 +3538,8 @@ var require_governance = __commonJS({
         }
         let votesOk = null;
         try {
-          const token = sxxx || await this.resolveVotesToken({ provider, governor });
-          const votes = await getVotesLatestMinusOne({ provider, token, account: user });
+          const { votingToken } = await resolveVotesTokenChain({ provider, governor });
+          const votes = await getVotesLatestMinusOne({ provider, token: votingToken, account: user });
           const th = threshold != null ? BigInt(threshold) : 0n;
           votesOk = votes >= th;
         } catch (_) {
@@ -3801,12 +4063,608 @@ var require_templates = __commonJS({
       if (depositOnly) {
         actions.push(() => governorContract.setDepositOnlyMode(true));
       }
-      const receipts = await executeSequence(actions);
-      return { governor, timelock, receipts };
-    }
-    module2.exports = {
-      communityDraftsBoardExec,
-      tokenDemocracy
+      const receipts = await executeSequence(actions);
+      return { governor, timelock, receipts };
+    }
+    module2.exports = {
+      communityDraftsBoardExec,
+      tokenDemocracy
+    };
+  }
+});
+
+// src/browser/utils.js
+var require_utils = __commonJS({
+  "src/browser/utils.js"(exports2, module2) {
+    function getAddress(address) {
+      if (!address) return address;
+      const addr = String(address).trim();
+      const normalized = addr.startsWith("0x") ? addr.slice(2).toLowerCase() : addr.toLowerCase();
+      return `0x${normalized}`;
+    }
+    async function keccak256Async(data) {
+      const encoder = new TextEncoder();
+      const dataBuffer = typeof data === "string" ? encoder.encode(data) : data;
+      const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+      return `0x${hashHex}`;
+    }
+    function keccak256Sync(data) {
+      const str = typeof data === "string" ? data : JSON.stringify(data);
+      let hash = 0;
+      for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+      }
+      const hex = Math.abs(hash).toString(16).padStart(8, "0");
+      return `0x${hex.repeat(8)}`.slice(0, 66);
+    }
+    module2.exports = {
+      getAddress,
+      keccak256Async,
+      keccak256Sync
+    };
+  }
+});
+
+// src/browser/subgraph.js
+var require_subgraph2 = __commonJS({
+  "src/browser/subgraph.js"(exports2, module2) {
+    var { getAddress } = require_utils();
+    function sanitizeOrderBy(orderBy, allowed, fallback) {
+      const value = (orderBy || "").toString();
+      return allowed.includes(value) ? value : fallback;
+    }
+    function sanitizeOrderDirection(direction, fallback = "desc") {
+      const v = (direction || "").toString().toLowerCase();
+      return v === "asc" ? "asc" : "desc";
+    }
+    function safeGetAddress(value) {
+      try {
+        return getAddress(value);
+      } catch {
+        return null;
+      }
+    }
+    function mapSafe(list, mapper) {
+      const out = [];
+      for (const item of list || []) {
+        try {
+          const v = mapper(item);
+          if (v != null) out.push(v);
+        } catch {
+        }
+      }
+      return out;
+    }
+    async function query(url, document, variables) {
+      if (!url) throw new Error("subgraph url required");
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 1e4);
+      try {
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query: document, variables }),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!resp.ok) {
+          throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+        }
+        const data = await resp.json();
+        if (data && data.errors) {
+          throw new Error(data.errors.map((e) => e.message).join("; "));
+        }
+        return data.data;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+      }
+    }
+    async function listProposals({ url, governor, first = 20, skip = 0 }) {
+      const data = await query(url, `
+    query($governor: Bytes!, $first: Int!, $skip: Int!) {
+      proposals(where: { governor: $governor }, first: $first, skip: $skip, orderBy: createdAt, orderDirection: desc) {
+        id
+        proposer
+        description
+        createdAt
+        targets
+        values
+        calldatas
+      }
+    }
+  `, { governor: String(governor).toLowerCase(), first, skip });
+      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,
+      ACTIVE: 1,
+      CANCELED: 2,
+      CANCELLED: 2,
+      // some indexes may use British spelling
+      DEFEATED: 3,
+      SUCCEEDED: 4,
+      QUEUED: 5,
+      EXPIRED: 6,
+      EXECUTED: 7
+    };
+    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(
+        where: {
+          ${governor ? "governor: $governor," : ""}
+          ${statesUpper ? "state_in: $states," : ""}
+          ${fromTimestamp !== void 0 ? "createdAt_gte: $from," : ""}
+          ${toTimestamp !== void 0 ? "createdAt_lte: $to," : ""}
+        }
+        first: $first
+        skip: $skip
+        orderBy: ${safeOrderBy}
+        orderDirection: ${safeOrderDirection}
+      ) {
+        id
+        proposer
+        description
+        createdAt
+        updatedAt
+        state
+        eta
+        targets
+        values
+        calldatas
+      }
+    }
+  `;
+      const variables = { first, skip };
+      if (govLower) variables.governor = govLower;
+      if (statesUpper) variables.states = statesUpper;
+      if (fromTimestamp !== void 0) variables.from = Number(fromTimestamp);
+      if (toTimestamp !== void 0) variables.to = Number(toTimestamp);
+      const data = await query(url, doc, variables);
+      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,
+          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,
+          values: (p.values || []).map((value) => BigInt(String(value))),
+          calldatas: p.calldatas || []
+        };
+      });
+    }
+    async function listLibraries({ url, subdao, first = 50, skip = 0 }) {
+      const where = subdao ? `where: { subDAO: "${String(subdao).toLowerCase()}" }` : "";
+      const data = await query(url, `
+    query($first: Int!, $skip: Int!) {
+      libraries(${where} first: $first, skip: $skip, orderBy: createdAt, orderDirection: desc) {
+        id
+        manifestCID
+        subDAO
+        proposer
+        createdAt
+      }
+    }
+  `, { first, skip });
+      return mapSafe(data?.libraries, (lib) => {
+        const sub = safeGetAddress(lib.subDAO);
+        const proposer = safeGetAddress(lib.proposer);
+        if (!sub || !proposer) return null;
+        return {
+          id: lib.id,
+          manifestCID: lib.manifestCID,
+          subdao: sub,
+          proposer,
+          createdAt: Number(lib.createdAt || 0)
+        };
+      });
+    }
+    async function getSubdaoLibraries({ url, subdao, first = 20, skip = 0 }) {
+      if (!url) throw new Error("subgraph url required");
+      const hasFilter = !!subdao;
+      const whereClause = hasFilter ? "where:{ subdao:$subdao }" : "";
+      const doc = `
+    query($subdao:Bytes,$first:Int!,$skip:Int!){
+      subDAOLibraryPointers(
+        ${whereClause}
+        first:$first,
+        skip:$skip,
+        orderBy: updatedAt,
+        orderDirection: desc
+      ){
+        id
+        subdao
+        libraryId
+        manifestCID
+        previousCID
+        promptCount
+        updatedAt
+      }
+    }
+  `;
+      const variables = {
+        first: Math.min(Math.max(1, Number(first || 20)), 100),
+        skip
+      };
+      if (hasFilter) {
+        const addr = safeGetAddress(subdao);
+        if (!addr) throw new Error("invalid subdao address");
+        variables.subdao = addr.toLowerCase();
+      }
+      const data = await query(url, doc, variables);
+      return mapSafe(data?.subDAOLibraryPointers, (row) => {
+        const id2 = row?.id;
+        const manifestCID = row?.manifestCID;
+        const sub = safeGetAddress(row?.subdao);
+        if (!id2 || !manifestCID || !sub) return 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: row.updatedAt != null ? Number(row.updatedAt) : null
+        };
+      });
+    }
+    async function getSubdaoPrompts({ url, registry, first = 50, skip = 0, orderBy = "updatedAt", orderDirection = "desc" }) {
+      if (!url) throw new Error("subgraph url required");
+      const reg = safeGetAddress(registry);
+      if (!reg) throw new Error("invalid registry address");
+      const safeOrderBy = sanitizeOrderBy(orderBy, ["updatedAt"], "updatedAt");
+      const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
+      const doc = `
+    query($registry:Bytes!,$first:Int!,$skip:Int!){
+      prompts(
+        where:{ registry:$registry },
+        first:$first,
+        skip:$skip,
+        orderBy: ${safeOrderBy},
+        orderDirection: ${safeOrderDirection}
+      ){
+        id
+        key
+        cid
+        version
+        author
+        registry
+        updatedAt
+      }
+    }
+  `;
+      const data = await query(url, doc, {
+        registry: reg.toLowerCase(),
+        first: Math.min(Math.max(1, Number(first || 50)), 100),
+        skip
+      });
+      return mapSafe(data?.prompts, (p) => {
+        const author = safeGetAddress(p.author);
+        const regAddr = safeGetAddress(p.registry);
+        if (!author || !regAddr) return null;
+        return {
+          id: String(p.id),
+          key: String(p.key),
+          cid: String(p.cid),
+          version: BigInt(p.version || "0"),
+          author,
+          registry: regAddr,
+          updatedAt: Number(p.updatedAt || 0)
+        };
+      });
+    }
+    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).
+       */
+      async getProposalTimeline({ url, id: id2 }) {
+        if (!url) throw new Error("subgraph url required");
+        const pid = typeof id2 === "bigint" ? id2.toString() : String(id2);
+        try {
+          const data = await query(url, `
+        query($id: ID!) {
+          proposal(id: $id) {
+            id
+            createdAt
+            updatedAt
+            state
+            eta
+            queuedAt
+            executedAt
+            canceledAt
+          }
+        }
+      `, { id: pid });
+          if (data && data.proposal) {
+            const p = data.proposal;
+            return {
+              id: p.id,
+              createdAt: Number(p.createdAt || 0),
+              queuedAt: p.queuedAt != null ? Number(p.queuedAt) : null,
+              executedAt: p.executedAt != null ? Number(p.executedAt) : null,
+              canceledAt: p.canceledAt != null ? Number(p.canceledAt) : null,
+              eta: p.eta != null ? BigInt(String(p.eta)) : null,
+              state: String(p.state || "")
+            };
+          }
+        } catch (_) {
+        }
+        try {
+          const data = await query(url, `
+        query($id: String!) {
+          proposalEvents(where: { proposal: $id }, orderBy: timestamp, orderDirection: asc) {
+            type
+            timestamp
+          }
+          proposals(where: { id: $id }, first:1) { id createdAt state eta }
+        }
+      `, { id: pid });
+          const events = (data?.proposalEvents || []).map((e) => ({ type: String(e.type || ""), timestamp: Number(e.timestamp || 0) }));
+          const base = data?.proposals?.[0] || {};
+          const find = (t) => events.find((e) => e.type.toLowerCase() === t)?.timestamp || null;
+          return {
+            id: base.id || pid,
+            createdAt: Number(base.createdAt || 0),
+            queuedAt: find("queued"),
+            executedAt: find("executed"),
+            canceledAt: find("canceled") || find("cancelled") || null,
+            eta: base.eta != null ? BigInt(String(base.eta)) : null,
+            state: String(base.state || "")
+          };
+        } catch (_) {
+        }
+        return { id: pid, createdAt: 0, queuedAt: null, executedAt: null, canceledAt: null, eta: null, state: "" };
+      },
+      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) {
+          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: ${safeOrderBy}, orderDirection: ${safeOrderDirection}){
+          id subdao pool sxxxToken stableToken sxxxAmount stableAmount lpRecipient blockNumber blockTimestamp transactionHash
+}
+      }
+    `;
+        const data = await query(url, doc, { first, skip });
+        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) {
+          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: ${safeOrderBy}, orderDirection: ${safeOrderDirection}){
+          id subdao pool lpToken lpAmount recipient blockNumber blockTimestamp transactionHash
+        }
+      }
+    `;
+        const data = await query(url, doc, { first, skip });
+        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) {
+          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: ${safeOrderBy}, orderDirection: ${safeOrderDirection}) {
+          id key cid version author registry updatedAt tagsHash
+        }
+      }
+    `;
+        const data = await query(url, doc, { first, 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),
+            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 = 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: ${safeOrderBy}, orderDirection: ${safeOrderDirection}) {
+          id
+          key
+          cid
+          version
+          author
+          registry
+          updatedAt
+        }
+      }
+    `;
+        const data = await query(url, doc, { first, skip, registry: reg.toLowerCase() });
+        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 = 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) {
+          id
+          key
+          cid
+          version
+          author
+          registry
+          updatedAt
+        }
+      }
+    `;
+        const data = await query(url, doc, { registry: reg.toLowerCase(), key: String(key) });
+        const p = (data?.prompts || [])[0];
+        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,
+          registry: regAddr,
+          updatedAt: Number(p.updatedAt || 0)
+        };
+      },
+      async getProposalById({ url, id: id2 }) {
+        if (!url) throw new Error("subgraph url required");
+        const doc = `query($id: ID!){ proposal(id:$id){ id proposer description createdAt updatedAt state eta targets values calldatas } }`;
+        const data = await query(url, doc, { id: String(id2) });
+        const p = data?.proposal;
+        if (!p) return null;
+        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;
+        }
+      }
     };
   }
 });
@@ -4165,6 +5023,7 @@ var require_operations = __commonJS({
       cache = null,
       fromBlock = 0,
       helperAddress = null,
+      subgraphUrl = null,
       hints = {},
       chunkSizeBlocks = 1e4,
       lookBackBlocks = 2e3,
@@ -4178,6 +5037,27 @@ var require_operations = __commonJS({
         const cached = await cacheAdapter.load(govAddr, id2);
         if (cached) return cached;
       }
+      if (subgraphUrl) {
+        try {
+          const subgraph = require_subgraph2();
+          const sgProposal = await subgraph.getProposalById({ url: subgraphUrl, id: String(id2) });
+          if (sgProposal && sgProposal.targets && sgProposal.targets.length > 0) {
+            const tuple2 = {
+              id: id2,
+              governor: govAddr,
+              targets: sgProposal.targets,
+              values: sgProposal.values || [],
+              calldatas: sgProposal.calldatas || [],
+              description: sgProposal.description || "",
+              descriptionHash: sgProposal.description ? keccak256(toUtf8Bytes(sgProposal.description)) : null,
+              createdBlock: sgProposal.createdAt || null
+            };
+            if (cacheAdapter) await cacheAdapter.save(govAddr, id2, tuple2);
+            return tuple2;
+          }
+        } catch (_) {
+        }
+      }
       if (helperAddress) {
         try {
           const helperAbi = [
@@ -4391,8 +5271,14 @@ var require_operations = __commonJS({
       ]);
       let resolvedSubDAO = subdao;
       if (!resolvedSubDAO) {
-        resolvedSubDAO = await governorContract.subDAO().catch(() => null);
-        if (resolvedSubDAO === ZeroAddress) resolvedSubDAO = null;
+        try {
+          const subDAOInterface = new Interface(["function subDAO() view returns (address)"]);
+          const subdaoContract = new Contract(govAddr, subDAOInterface, provider);
+          resolvedSubDAO = await subdaoContract.subDAO().catch(() => null);
+          if (resolvedSubDAO === ZeroAddress) resolvedSubDAO = null;
+        } catch {
+          resolvedSubDAO = null;
+        }
       }
       let mode = null;
       let eligible = null;
@@ -4467,10 +5353,11 @@ var require_operations = __commonJS({
       refresh = false,
       cache = null,
       includeTimeline = false,
-      helperAddress = null
+      helperAddress = null,
+      subgraphUrl = null
     }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const tuple = await resolveProposalTuple({ provider, governor, proposalId, refresh, cache, helperAddress });
+      const tuple = await resolveProposalTuple({ provider, governor, proposalId, refresh, cache, helperAddress, subgraphUrl });
       let proposal = null;
       try {
         proposal = await governance.getProposal({ provider, governor: tuple.governor, id: tuple.id });
@@ -4808,8 +5695,6 @@ var require_factory = __commonJS({
         stableCreationFee,
         feeReceiver,
         allowStableFee,
-        stablePromptForkFee,
-        allowStablePromptForkFee,
         stableForkFee,
         allowStableForkFee,
         timelockMinDelay,
@@ -4833,8 +5718,6 @@ var require_factory = __commonJS({
           }
         })(),
         contract.allowStableFee().catch(() => null),
-        contract.stablePromptForkFee().catch(() => null),
-        contract.allowStablePromptForkFee().catch(() => null),
         contract.stableForkFee().catch(() => null),
         contract.allowStableForkFee().catch(() => null),
         contract.timelockMinDelay().catch(() => null),
@@ -4850,8 +5733,6 @@ var require_factory = __commonJS({
         stableCreationFee,
         feeReceiver: feeReceiver && feeReceiver !== "0x0000000000000000000000000000000000000000" ? getAddress(feeReceiver) : null,
         allowStableFee,
-        stablePromptForkFee,
-        allowStablePromptForkFee,
         stableForkFee,
         allowStableForkFee,
         timelockMinDelay,
@@ -5183,6 +6064,113 @@ var require_factory = __commonJS({
   }
 });
 
+// src/lineage/index.js
+var require_lineage = __commonJS({
+  "src/lineage/index.js"(exports2, module2) {
+    var { Contract, getAddress } = __require("ethers");
+    var { SageSDKError, CODES } = require_errors();
+    var LINEAGE_ABI = [
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee)",
+      "function getLibraryForkFee(address) view returns (uint256)"
+    ];
+    var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+    function normalise(address, label) {
+      if (!address) throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
+      try {
+        return getAddress(address);
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
+      }
+    }
+    async function getParentLibrary({ provider, registry, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const info = await contract.libraryByDAO(normalise(subdao, "subdao"));
+        const parent = info.forkedFromDAO;
+        if (!parent || parent === ZERO_ADDRESS) {
+          return null;
+        }
+        return getAddress(parent).toLowerCase();
+      } catch (err) {
+        throw new SageSDKError(CODES.CONTRACT_ERROR, "Failed to fetch parent library", { cause: err });
+      }
+    }
+    async function getLineageChain({ provider, registry, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const chain = [];
+        let current = normalise(subdao, "subdao");
+        const MAX_DEPTH = 100;
+        let iterations = 0;
+        while (current && iterations < MAX_DEPTH) {
+          chain.unshift(getAddress(current).toLowerCase());
+          const info = await contract.libraryByDAO(current);
+          const parent = info.forkedFromDAO;
+          if (!parent || parent === ZERO_ADDRESS) {
+            break;
+          }
+          current = parent;
+          iterations++;
+        }
+        return {
+          chain,
+          depth: chain.length - 1,
+          root: chain[0]
+        };
+      } catch (err) {
+        throw new SageSDKError(CODES.CONTRACT_ERROR, "Failed to fetch lineage chain", { cause: err });
+      }
+    }
+    async function isFork({ provider, registry, subdao }) {
+      const parent = await getParentLibrary({ provider, registry, subdao });
+      return parent !== null;
+    }
+    async function getLibraryForkFee({ provider, registry, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const fee = await contract.getLibraryForkFee(normalise(subdao, "subdao"));
+        return BigInt(fee.toString());
+      } catch (err) {
+        throw new SageSDKError(CODES.CONTRACT_ERROR, "Failed to fetch library fork fee", { cause: err });
+      }
+    }
+    async function getLibraryInfo({ provider, registry, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const info = await contract.libraryByDAO(normalise(subdao, "subdao"));
+        const parent = info.forkedFromDAO;
+        return {
+          parentDAO: !parent || parent === ZERO_ADDRESS ? null : getAddress(parent).toLowerCase(),
+          forkFee: BigInt(info.sxxxForkFee.toString()),
+          manifestCID: info.manifestCID,
+          version: info.version
+        };
+      } catch (err) {
+        throw new SageSDKError(CODES.CONTRACT_ERROR, "Failed to fetch library info", { cause: err });
+      }
+    }
+    module2.exports = {
+      getParentLibrary,
+      getLineageChain,
+      isFork,
+      getLibraryForkFee,
+      getLibraryInfo
+    };
+  }
+});
+
 // src/prompt/execute.js
 var require_execute = __commonJS({
   "src/prompt/execute.js"(exports2, module2) {
@@ -5855,7 +6843,6 @@ var require_ipns = __commonJS({
             headers["X-Wallet-Address"] = auth.address;
             headers["X-Wallet-Signature"] = auth.signature;
             headers["X-Wallet-Nonce"] = auth.nonce;
-            headers["X-Wallet-Message"] = auth.message;
           }
           return { headers, auth };
         }
@@ -5877,8 +6864,7 @@ var require_ipns = __commonJS({
             ...extraHeaders,
             "X-Wallet-Address": auth.address,
             "X-Wallet-Signature": auth.signature,
-            "X-Wallet-Nonce": auth.nonce,
-            "X-Wallet-Message": auth.message
+            "X-Wallet-Nonce": auth.nonce
           };
           return { headers, auth };
         }
@@ -6515,8 +7501,34 @@ var require_time = __commonJS({
 var require_treasury = __commonJS({
   "src/treasury/index.js"(exports2, module2) {
     var { Contract, Interface, getAddress } = __require("ethers");
-    var ABI = require_abi();
     var { SageSDKError, CODES } = require_errors();
+    var SAGE_TREASURY_ABI = [
+      // Aggregated views
+      "function totalReserves() view returns (uint256)",
+      "function totalPOL() view returns (uint256)",
+      "function totalDebt() view returns (uint256)",
+      // Canonical liquidity config
+      "function canonicalPool() view returns (address)",
+      "function routerOrVault() view returns (address)",
+      // Withdrawal rate limits
+      "function maxWithdrawalRate() view returns (uint256)",
+      "function emergencyWithdrawalLimit() view returns (uint256)",
+      // Reserve tokens
+      "function getReserveTokens() view returns (address[])",
+      "function getReserve(address token) view returns (tuple(uint256 amount, uint256 value, bool isLP, bool isActive))",
+      // Withdrawal queue
+      "function nextWithdrawalId() view returns (uint256)",
+      "function pendingWithdrawals(uint256 id) view returns (tuple(bool exists, address token, address recipient, uint256 amount, uint256 value, address requester, uint256 balanceBefore, uint256 recipientBalanceBefore, uint256 depositSnapshot, bool isLP, bool isEmergency))",
+      "function withdraw(address token, uint256 amount, address recipient)",
+      "function confirmWithdrawal(uint256 id)",
+      "function cancelWithdrawal(uint256 id)",
+      // Manual price overrides
+      "function manualPrices(address token) view returns (tuple(uint256 price, uint256 expiresAt, bool active))",
+      "function setPriceOverride(address token, uint256 price, uint256 ttlSeconds)",
+      "function clearPriceOverride(address token)",
+      // Events
+      "event WithdrawalScheduled(uint256 indexed id, address indexed token, address indexed recipient, uint256 amount)"
+    ];
     var LiquidityEvents = new Interface([
       "event CanonicalLiquidityUpdated(address indexed pool, address indexed routerOrVault)",
       "event LiquidityAddPlanned(address indexed subdao, address indexed pool, address sxxxToken, address stableToken, uint256 sxxxAmount, uint256 stableAmount, address lpRecipient)",
@@ -6561,7 +7573,7 @@ var require_treasury = __commonJS({
     async function getTreasuryInfo({ provider, treasury }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const [totalReserves, totalPOL, totalDebt, canonicalPool, routerOrVault, maxWithdrawalRate, emergencyWithdrawalLimit] = await Promise.all([
         contract.totalReserves().catch(() => 0n),
         contract.totalPOL().catch(() => 0n),
@@ -6585,7 +7597,7 @@ var require_treasury = __commonJS({
     async function getPendingWithdrawals({ provider, treasury, ids, limit = 50 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       let idList = ids;
       if (!Array.isArray(idList)) {
         const nextId = await contract.nextWithdrawalId().catch(() => 0n);
@@ -6617,14 +7629,14 @@ var require_treasury = __commonJS({
     async function getReserveTokens({ provider, treasury }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const tokens = await contract.getReserveTokens().catch(() => []);
       return tokens.map((token) => getAddress(token));
     }
     async function getReserves({ provider, treasury, tokens, fetchMetadata = true }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const tokenList = Array.isArray(tokens) && tokens.length ? tokens.map((token) => getAddress(token)) : await contract.getReserveTokens().catch(() => []);
       const reserves = [];
       for (const token of tokenList) {
@@ -6654,7 +7666,7 @@ var require_treasury = __commonJS({
     async function getManualPriceOverrides({ provider, treasury, tokens }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const tokenList = Array.isArray(tokens) && tokens.length ? tokens.map((token) => getAddress(token)) : await contract.getReserveTokens().catch(() => []);
       const overrides = [];
       for (const token of tokenList) {
@@ -6759,7 +7771,7 @@ var require_treasury = __commonJS({
     async function getLPContribution({ provider, treasury, subdao, token }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const c = new Contract(addr, ABI.SageTreasury, provider);
+      const c = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const amount = await c.lpContributions(normalise(subdao, "subdao"), normalise(token, "token")).catch(() => 0n);
       return amount;
     }
@@ -6801,7 +7813,7 @@ var require_treasury = __commonJS({
     function createWriteContract({ signer, treasury }) {
       if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
       const addr = normalise(treasury, "treasury");
-      return new Contract(addr, ABI.SageTreasury, signer);
+      return new Contract(addr, SAGE_TREASURY_ABI, signer);
     }
     async function waitForReceipt({ signer, tx, waitMs }) {
       const provider = signer.provider;
@@ -7105,6 +8117,350 @@ var require_bounty = __commonJS({
   }
 });
 
+// src/votingMultiplier/index.js
+var require_votingMultiplier = __commonJS({
+  "src/votingMultiplier/index.js"(exports2, module2) {
+    var { Contract, Interface, getAddress } = __require("ethers");
+    var ABI = require_abi();
+    var { SageSDKError, CODES } = require_errors();
+    function normaliseAddress(address, label) {
+      if (!address) throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
+      try {
+        return getAddress(address);
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
+      }
+    }
+    function toBigInt(value, label) {
+      if (value === void 0 || value === null) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
+      }
+      try {
+        return BigInt(value.toString());
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
+      }
+    }
+    function getNftContract(provider, nft) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normaliseAddress(nft, "nft");
+      return new Contract(addr, ABI.VotingMultiplierNFT, provider);
+    }
+    function getWrapperContract(provider, wrapper) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normaliseAddress(wrapper, "wrapper");
+      return new Contract(addr, ABI.MultipliedVotes, provider);
+    }
+    async function getTier({ provider, nft, tierId }) {
+      const c = getNftContract(provider, nft);
+      const id2 = toBigInt(tierId, "tierId");
+      let tier;
+      if (typeof c.getTier === "function") {
+        tier = await c.getTier(id2);
+      } else {
+        tier = await c.tiers(id2);
+      }
+      const name = String(tier.name ?? tier[0]);
+      const multiplier = BigInt((tier.multiplier ?? tier[1]).toString());
+      const maxSupply = BigInt((tier.maxSupply ?? tier[2]).toString());
+      const minted = BigInt((tier.minted ?? tier[3]).toString());
+      const price = BigInt((tier.price ?? tier[4]).toString());
+      const dao = getAddress(tier.dao ?? tier[5]);
+      return { name, multiplier, maxSupply, minted, price, dao };
+    }
+    async function getTierCount({ provider, nft }) {
+      const c = getNftContract(provider, nft);
+      const count = await c.tierCount();
+      return BigInt(count.toString());
+    }
+    function buildCreateTierTx({ nft, dao, name, multiplier, maxSupply, price }) {
+      const addr = normaliseAddress(nft, "nft");
+      const iface = new Interface(ABI.VotingMultiplierNFT);
+      const data = iface.encodeFunctionData("createTier", [
+        normaliseAddress(dao, "dao"),
+        String(name ?? ""),
+        toBigInt(multiplier, "multiplier"),
+        toBigInt(maxSupply, "maxSupply"),
+        toBigInt(price, "price")
+      ]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildMintTx({ nft, to, tierId, uri }) {
+      const addr = normaliseAddress(nft, "nft");
+      const iface = new Interface(ABI.VotingMultiplierNFT);
+      const data = iface.encodeFunctionData("mint", [
+        normaliseAddress(to, "to"),
+        toBigInt(tierId, "tierId"),
+        String(uri ?? "")
+      ]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildPublicMintTx({ nft, tierId, uri, value }) {
+      const addr = normaliseAddress(nft, "nft");
+      const iface = new Interface(ABI.VotingMultiplierNFT);
+      const data = iface.encodeFunctionData("publicMint", [
+        toBigInt(tierId, "tierId"),
+        String(uri ?? "")
+      ]);
+      return { to: addr, data, value: toBigInt(value ?? 0n, "value") };
+    }
+    async function getMultiplier({ provider, nft, account, dao }) {
+      const c = getNftContract(provider, nft);
+      const res = await c.getMultiplier(normaliseAddress(account, "account"), normaliseAddress(dao, "dao"));
+      return BigInt(res.toString());
+    }
+    async function getPastMultiplier({ provider, nft, account, dao, timepoint }) {
+      const c = getNftContract(provider, nft);
+      const res = await c.getPastMultiplier(
+        normaliseAddress(account, "account"),
+        normaliseAddress(dao, "dao"),
+        toBigInt(timepoint, "timepoint")
+      );
+      return BigInt(res.toString());
+    }
+    async function getTokenMultiplier({ provider, nft, tokenId }) {
+      const c = getNftContract(provider, nft);
+      const res = await c.getTokenMultiplier(toBigInt(tokenId, "tokenId"));
+      return BigInt(res.toString());
+    }
+    async function getTokenDAO({ provider, nft, tokenId }) {
+      const c = getNftContract(provider, nft);
+      const res = await c.getTokenDAO(toBigInt(tokenId, "tokenId"));
+      return getAddress(res);
+    }
+    async function getTokenInfo({ provider, nft, tokenId }) {
+      const c = getNftContract(provider, nft);
+      const id2 = toBigInt(tokenId, "tokenId");
+      const info = await c.getTokenInfo(id2);
+      const owner = getAddress(info.owner ?? info[0]);
+      const tierId = BigInt((info.tierId ?? info[1]).toString());
+      const multiplier = BigInt((info.multiplier ?? info[2]).toString());
+      const uri = String(info.uri ?? info[3]);
+      return { owner, tierId, multiplier, uri };
+    }
+    async function getVotes({ provider, wrapper, account }) {
+      const c = getWrapperContract(provider, wrapper);
+      const res = await c.getVotes(normaliseAddress(account, "account"));
+      return BigInt(res.toString());
+    }
+    async function getPastVotes({ provider, wrapper, account, timepoint }) {
+      const c = getWrapperContract(provider, wrapper);
+      const res = await c.getPastVotes(
+        normaliseAddress(account, "account"),
+        toBigInt(timepoint, "timepoint")
+      );
+      return BigInt(res.toString());
+    }
+    async function getVotingBreakdown({ provider, wrapper, account }) {
+      const c = getWrapperContract(provider, wrapper);
+      const [baseVotes, multiplier, effectiveVotes] = await c.getVotingBreakdown(normaliseAddress(account, "account"));
+      return {
+        baseVotes: BigInt(baseVotes.toString()),
+        multiplier: BigInt(multiplier.toString()),
+        effectiveVotes: BigInt(effectiveVotes.toString())
+      };
+    }
+    async function getPastVotingBreakdown({ provider, wrapper, account, timepoint }) {
+      const c = getWrapperContract(provider, wrapper);
+      const [baseVotes, multiplier, effectiveVotes] = await c.getPastVotingBreakdown(
+        normaliseAddress(account, "account"),
+        toBigInt(timepoint, "timepoint")
+      );
+      return {
+        baseVotes: BigInt(baseVotes.toString()),
+        multiplier: BigInt(multiplier.toString()),
+        effectiveVotes: BigInt(effectiveVotes.toString())
+      };
+    }
+    async function hasMultiplierBonus({ provider, wrapper, account }) {
+      const c = getWrapperContract(provider, wrapper);
+      const res = await c.hasMultiplierBonus(normaliseAddress(account, "account"));
+      return !!res;
+    }
+    module2.exports = {
+      // Tier management
+      getTier,
+      getTierCount,
+      buildCreateTierTx,
+      // Minting
+      buildMintTx,
+      buildPublicMintTx,
+      // Multiplier queries
+      getMultiplier,
+      getPastMultiplier,
+      getTokenMultiplier,
+      getTokenDAO,
+      getTokenInfo,
+      // Wrapper queries
+      getVotes,
+      getPastVotes,
+      getVotingBreakdown,
+      getPastVotingBreakdown,
+      hasMultiplierBonus
+    };
+  }
+});
+
+// src/auction/index.js
+var require_auction = __commonJS({
+  "src/auction/index.js"(exports2, module2) {
+    var { Contract, Interface, getAddress } = __require("ethers");
+    var ABI = require_abi();
+    var { SageSDKError, CODES } = require_errors();
+    function normaliseAddress(address, label) {
+      if (!address) throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
+      try {
+        return getAddress(address);
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
+      }
+    }
+    function toBigInt(value, label) {
+      if (value === void 0 || value === null) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
+      }
+      try {
+        return BigInt(value.toString());
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
+      }
+    }
+    function getAuctionContract(provider, auctionHouse) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      return new Contract(addr, ABI.SageAuctionHouse, provider);
+    }
+    async function getAuction({ provider, auctionHouse }) {
+      const c = getAuctionContract(provider, auctionHouse);
+      const res = await c.auction();
+      const nftId = BigInt(res.nftId.toString());
+      const amount = BigInt(res.amount.toString());
+      const startTime = BigInt(res.startTime.toString());
+      const endTime = BigInt(res.endTime.toString());
+      const bidder = getAddress(res.bidder);
+      const settled = !!res.settled;
+      return { nftId, amount, startTime, endTime, bidder, settled };
+    }
+    async function getConfig({ provider, auctionHouse }) {
+      const c = getAuctionContract(provider, auctionHouse);
+      const [nft, treasury, weth, timeBuffer, reservePrice, minBidIncrementPercentage, duration, mintTierId, defaultTokenURI, paused, owner] = await Promise.all([
+        c.nft(),
+        c.treasury(),
+        c.weth(),
+        c.timeBuffer(),
+        c.reservePrice(),
+        c.minBidIncrementPercentage(),
+        c.duration(),
+        c.mintTierId(),
+        c.defaultTokenURI(),
+        c.paused(),
+        c.owner()
+      ]);
+      return {
+        nft: getAddress(nft),
+        treasury: getAddress(treasury),
+        weth: getAddress(weth),
+        timeBuffer: BigInt(timeBuffer.toString()),
+        reservePrice: BigInt(reservePrice.toString()),
+        minBidIncrementPercentage: BigInt(minBidIncrementPercentage.toString()),
+        duration: BigInt(duration.toString()),
+        mintTierId: BigInt(mintTierId.toString()),
+        defaultTokenURI: String(defaultTokenURI),
+        paused: !!paused,
+        owner: getAddress(owner)
+      };
+    }
+    function buildCreateBidTx({ auctionHouse, nftId, value }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("createBid", [toBigInt(nftId, "nftId")]);
+      return { to: addr, data, value: toBigInt(value, "value") };
+    }
+    function buildSettleAndCreateTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("settleCurrentAndCreateNewAuction", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSettleTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("settleAuction", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildCreateAuctionTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("createAuction", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildPauseTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("pause", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildUnpauseTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("unpause", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetTimeBufferTx({ auctionHouse, timeBuffer }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setTimeBuffer", [toBigInt(timeBuffer, "timeBuffer")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetReservePriceTx({ auctionHouse, reservePrice }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setReservePrice", [toBigInt(reservePrice, "reservePrice")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetMinBidIncrementTx({ auctionHouse, percentage }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setMinBidIncrementPercentage", [toBigInt(percentage, "percentage")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetDurationTx({ auctionHouse, duration }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setDuration", [toBigInt(duration, "duration")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetMintTierIdTx({ auctionHouse, tierId }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setMintTierId", [toBigInt(tierId, "tierId")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetDefaultTokenURITx({ auctionHouse, uri }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setDefaultTokenURI", [String(uri ?? "")]);
+      return { to: addr, data, value: 0n };
+    }
+    module2.exports = {
+      getAuction,
+      getConfig,
+      buildCreateBidTx,
+      buildSettleAndCreateTx,
+      buildSettleTx,
+      buildCreateAuctionTx,
+      buildPauseTx,
+      buildUnpauseTx,
+      buildSetTimeBufferTx,
+      buildSetReservePriceTx,
+      buildSetMinBidIncrementTx,
+      buildSetDurationTx,
+      buildSetMintTierIdTx,
+      buildSetDefaultTokenURITx
+    };
+  }
+});
+
 // src/utils/provider.js
 var require_provider = __commonJS({
   "src/utils/provider.js"(exports2, module2) {
@@ -9910,6 +11266,273 @@ var require_client2 = __commonJS({
   }
 });
 
+// src/clients/discovery-client.js
+var require_discovery_client = __commonJS({
+  "src/clients/discovery-client.js"(exports2, module2) {
+    var DiscoveryClient = class {
+      /**
+       * @param {string} baseUrl - Base URL of the discovery API
+       * @param {object} [options] - Client options
+       * @param {number} [options.timeout=10000] - Request timeout in milliseconds
+       * @param {Record<string, string>} [options.headers] - Custom headers
+       */
+      constructor(baseUrl, options = {}) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.timeout = options.timeout || 1e4;
+        this.headers = options.headers || {};
+      }
+      /**
+       * Search prompts with keyword matching and trend ranking
+       * @param {string} query - Search query
+       * @param {object} [options] - Search options
+       * @param {string} [options.category] - Filter by category
+       * @param {string[]} [options.tags] - Filter by tags
+       * @param {string} [options.author] - Filter by author
+       * @param {number} [options.limit] - Max results to return
+       * @param {number} [options.offset] - Number of results to skip
+       * @param {boolean} [options.useVector] - Use vector search
+       * @returns {Promise<{results: Array, total: number}>}
+       */
+      async search(query, options = {}) {
+        const params = new URLSearchParams();
+        if (query) params.set("q", query);
+        if (options.category) params.set("category", options.category);
+        if (options.author) params.set("author", options.author);
+        if (options.tags) {
+          options.tags.forEach((tag) => params.append("tags", tag));
+        }
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.offset !== void 0) params.set("offset", String(options.offset));
+        if (options.useVector !== void 0) params.set("useVector", String(options.useVector));
+        return this._get(`/discover/search?${params}`);
+      }
+      /**
+       * Get trending prompts by time window
+       * @param {object} [options] - Trending options
+       * @param {'1h'|'24h'|'7d'|'30d'|'all'} [options.window] - Time window
+       * @param {string} [options.category] - Filter by category
+       * @param {number} [options.limit] - Max results to return
+       * @param {number} [options.offset] - Number of results to skip
+       * @returns {Promise<{results: Array}>}
+       */
+      async trending(options = {}) {
+        const params = new URLSearchParams();
+        if (options.window) params.set("window", options.window);
+        if (options.category) params.set("category", options.category);
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.offset !== void 0) params.set("offset", String(options.offset));
+        return this._get(`/discover/trending?${params}`);
+      }
+      /**
+       * Get trending prompts (alias for /trends/top endpoint)
+       * @param {object} [options] - Trending options
+       * @param {'1h'|'24h'|'7d'|'30d'|'all'} [options.window] - Time window
+       * @param {number} [options.limit] - Max results to return
+       * @param {number} [options.offset] - Number of results to skip
+       * @returns {Promise<{results: Array}>}
+       */
+      async trendingTop(options = {}) {
+        const params = new URLSearchParams();
+        if (options.window) params.set("window", options.window);
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.offset !== void 0) params.set("offset", String(options.offset));
+        return this._get(`/trends/top?${params}`);
+      }
+      /**
+       * Find prompts matching user preferences
+       *
+       * Note: This endpoint is not yet implemented in the backend.
+       * This is a placeholder for future implementation.
+       * @param {object} preferences - User preferences
+       * @param {string[]} [preferences.recentPrompts] - Recent prompt CIDs
+       * @param {string[]} [preferences.preferredTags] - Preferred tags
+       * @param {string[]} [preferences.preferredCategories] - Preferred categories
+       * @param {string[]} [preferences.excludeAuthors] - Authors to exclude
+       * @param {number} [preferences.limit] - Max results
+       * @param {boolean} [preferences.diversify] - Diversify results
+       * @returns {Promise<{results: Array, total: number}>}
+       */
+      async match(preferences) {
+        return this._post("/discover/match", preferences);
+      }
+      /**
+       * Find prompts similar to a given prompt
+       * @param {string} cid - Prompt CID to find similar prompts for
+       * @param {object} [options] - Similar options
+       * @param {number} [options.limit] - Max results to return
+       * @param {'vector'|'keyword'|'hybrid'} [options.method] - Similarity method
+       * @returns {Promise<{similar: Array}>}
+       */
+      async similar(cid, options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.method) params.set("method", options.method);
+        return this._get(`/discover/similar/${cid}?${params}`);
+      }
+      /**
+       * Get popular tags with optional clustering
+       * @param {object} [options] - Tags options
+       * @param {number} [options.limit] - Max tags to return
+       * @param {string} [options.category] - Filter by category
+       * @param {boolean} [options.clusters] - Enable tag clustering
+       * @returns {Promise<{tags: Array}>}
+       */
+      async tags(options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.category) params.set("category", options.category);
+        if (options.clusters !== void 0) params.set("clusters", String(options.clusters));
+        return this._get(`/discover/tags?${params}`);
+      }
+      /**
+       * Get category statistics
+       *
+       * Note: This endpoint is not yet implemented in the backend.
+       * This is a placeholder for future implementation.
+       * @returns {Promise<{categories: Array}>}
+       */
+      async categories() {
+        return this._get("/discover/categories");
+      }
+      /**
+       * Get prompts by tag
+       * @param {string} tag - Tag to search for
+       * @param {number} [limit] - Max results to return
+       * @returns {Promise<{results: Array}>}
+       */
+      async promptsByTag(tag, limit) {
+        const params = new URLSearchParams();
+        if (limit !== void 0) params.set("limit", String(limit));
+        const encodedTag = encodeURIComponent(tag);
+        return this._get(`/discover/by-tag/${encodedTag}?${params}`);
+      }
+      /**
+       * Get index statistics
+       * @returns {Promise<{totalPrompts: number, totalTags: number, avgTrendScore: number}>}
+       */
+      async stats() {
+        return this._get("/discover/stats");
+      }
+      /**
+       * Get trend signals for a specific CID
+       * @param {string} cid - Prompt CID
+       * @returns {Promise<{usageCount: number, forkCount: number, purchaseCount: number, uniqueBuyers: number, governanceVotes: number, lastActivityAt: number}>}
+       */
+      async trendSignals(cid) {
+        return this._get(`/trends/signals/${cid}`);
+      }
+      /**
+       * Get trend history for a specific CID
+       * @param {string} cid - Prompt CID
+       * @param {object} [options] - History options
+       * @param {number} [options.limit] - Max history entries
+       * @param {number} [options.since] - Timestamp to start from
+       * @returns {Promise<{history: Array}>}
+       */
+      async trendHistory(cid, options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.since !== void 0) params.set("since", String(options.since));
+        return this._get(`/trends/history/${cid}?${params}`);
+      }
+      /**
+       * Get trend statistics
+       * @returns {Promise<{totalTracked: number, avgScore: number, maxScore: number, recentlyActive: number}>}
+       */
+      async trendStats() {
+        return this._get("/trends/stats");
+      }
+      /**
+       * Record a usage event for a prompt (requires authentication)
+       * @param {string} cid - Prompt CID
+       * @returns {Promise<{ok: boolean}>}
+       */
+      async recordUsage(cid) {
+        return this._post("/trends/usage", { cid });
+      }
+      // Private fetch helpers
+      /**
+       * Perform a GET request
+       * @private
+       * @param {string} path - API path
+       * @returns {Promise<any>}
+       */
+      async _get(path2) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const response = await fetch(`${this.baseUrl}${path2}`, {
+            method: "GET",
+            headers: {
+              "Accept": "application/json",
+              ...this.headers
+            },
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text().catch(() => "Unknown error");
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.timeout}ms`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * Perform a POST request
+       * @private
+       * @param {string} path - API path
+       * @param {any} body - Request body
+       * @returns {Promise<any>}
+       */
+      async _post(path2, body) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const response = await fetch(`${this.baseUrl}${path2}`, {
+            method: "POST",
+            headers: {
+              "Accept": "application/json",
+              "Content-Type": "application/json",
+              ...this.headers
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text().catch(() => "Unknown error");
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.timeout}ms`);
+          }
+          throw error;
+        }
+      }
+    };
+    module2.exports = { DiscoveryClient };
+  }
+});
+
+// src/clients/index.js
+var require_clients = __commonJS({
+  "src/clients/index.js"(exports2, module2) {
+    var { DiscoveryClient } = require_discovery_client();
+    module2.exports = {
+      DiscoveryClient
+    };
+  }
+});
+
 // src/hooks/useSubDAOs.js
 var require_useSubDAOs = __commonJS({
   "src/hooks/useSubDAOs.js"(exports2, module2) {
@@ -10120,6 +11743,7 @@ var require_src = __commonJS({
     var timelock = require_timelock();
     var factory = require_factory();
     var library = require_library();
+    var lineage = require_lineage();
     var prompt = require_prompt();
     var { SageEchoExecutor } = require_execute();
     var ipfs = require_ipfs();
@@ -10133,6 +11757,8 @@ var require_src = __commonJS({
     var treasury = require_treasury();
     var boost = require_boost();
     var bounty = require_bounty();
+    var votingMultiplier = require_votingMultiplier();
+    var auction = require_auction();
     var wallet = require_wallet();
     wallet.session = require_session();
     var walletCastManager = require_cast_manager();
@@ -10153,6 +11779,7 @@ var require_src = __commonJS({
     var serviceErrors = require_errors2();
     var { SimpleCache } = require_cache();
     var { retryWithBackoff } = require_retry();
+    var { DiscoveryClient } = require_clients();
     var hooks = null;
     try {
       hooks = require_hooks();
@@ -10168,6 +11795,7 @@ var require_src = __commonJS({
       timelock,
       factory,
       library,
+      lineage,
       prompt,
       ipfs,
       ipns,
@@ -10180,6 +11808,8 @@ var require_src = __commonJS({
       subgraph,
       utils: { ...utils, privateTx, safe, time },
       bounty,
+      votingMultiplier,
+      auction,
       wallet: Object.assign(wallet, {
         cast: walletCastManager,
         cdp: walletCdpManager
@@ -10200,6 +11830,11 @@ var require_src = __commonJS({
         SimpleCache,
         retryWithBackoff
       },
+      // Client exports
+      clients: {
+        DiscoveryClient
+      },
+      DiscoveryClient,
       // React hooks (optional - requires react + swr peer dependencies)
       hooks,
       // Legacy exports (deprecated): maintain compatibility while consumers migrate