@sage-protocol/sdk 0.1.17 → 0.1.21

package/dist/index.cjs

@@ -14,7 +14,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.17",
+      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",
@@ -130,7 +130,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)",
@@ -172,13 +171,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)",
@@ -293,6 +297,186 @@ var require_abi = __commonJS({
       "function create(uint256 proposalId, address token, uint256 perVoter, uint256 maxVoters)",
       "function fund(uint256 proposalId, uint256 amount)"
     ];
+    var VotingMultiplierNFT = [
+      // Constants
+      "function MINTER_ROLE() view returns (bytes32)",
+      "function MAX_NFTS_PER_ACCOUNT() view returns (uint256)",
+      // Tier Management
+      "function createTier(address dao, string name, uint256 multiplier, uint256 maxSupply, uint256 price) returns (uint256 tierId)",
+      "function getTier(uint256 tierId) view returns (tuple(string name, uint256 multiplier, uint256 maxSupply, uint256 minted, uint256 price, address dao))",
+      "function tierCount() view returns (uint256)",
+      "function tiers(uint256) view returns (string name, uint256 multiplier, uint256 maxSupply, uint256 minted, uint256 price, address dao)",
+      // Minting
+      "function mint(address to, uint256 tierId, string uri) returns (uint256 tokenId)",
+      "function publicMint(uint256 tierId, string uri) payable returns (uint256 tokenId)",
+      // Multiplier Functions
+      "function getMultiplier(address account, address dao) view returns (uint256)",
+      "function getPastMultiplier(address account, address dao, uint256 timepoint) view returns (uint256)",
+      "function getTokenMultiplier(uint256 tokenId) view returns (uint256)",
+      "function getTokenDAO(uint256 tokenId) view returns (address)",
+      // Token Info
+      "function tokenMultiplier(uint256) view returns (uint256)",
+      "function tokenDAO(uint256) view returns (address)",
+      "function tokenTier(uint256) view returns (uint256)",
+      "function getTokenInfo(uint256 tokenId) view returns (address owner, uint256 tierId, uint256 multiplier, string uri)",
+      // ERC721 Standard
+      "function balanceOf(address owner) view returns (uint256)",
+      "function ownerOf(uint256 tokenId) view returns (address)",
+      "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)",
+      "function tokenURI(uint256 tokenId) view returns (string)",
+      "function transferFrom(address from, address to, uint256 tokenId)",
+      "function safeTransferFrom(address from, address to, uint256 tokenId)",
+      "function approve(address to, uint256 tokenId)",
+      "function setApprovalForAll(address operator, bool approved)",
+      "function getApproved(uint256 tokenId) view returns (address)",
+      "function isApprovedForAll(address owner, address operator) view returns (bool)",
+      // Admin
+      "function withdrawFunds(address to)",
+      "function grantRole(bytes32 role, address account)",
+      "function revokeRole(bytes32 role, address account)",
+      "function hasRole(bytes32 role, address account) view returns (bool)",
+      // Events
+      "event TierCreated(uint256 indexed tierId, address indexed dao, string name, uint256 multiplier, uint256 maxSupply, uint256 price)",
+      "event NFTMinted(address indexed to, uint256 indexed tokenId, address indexed dao, uint256 tierId, uint256 multiplier)",
+      "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
+    ];
+    var MultipliedVotes = [
+      // Core IVotes Interface
+      "function getVotes(address account) view returns (uint256)",
+      "function getPastVotes(address account, uint256 timepoint) view returns (uint256)",
+      "function getPastTotalSupply(uint256 timepoint) view returns (uint256)",
+      "function delegates(address account) view returns (address)",
+      "function delegate(address delegatee)",
+      "function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s)",
+      // IERC6372 Clock Interface
+      "function clock() view returns (uint48)",
+      "function CLOCK_MODE() view returns (string)",
+      // View Helpers
+      "function getVotingBreakdown(address account) view returns (uint256 baseVotes, uint256 multiplier, uint256 effectiveVotes)",
+      "function getPastVotingBreakdown(address account, uint256 timepoint) view returns (uint256 baseVotes, uint256 multiplier, uint256 effectiveVotes)",
+      "function hasMultiplierBonus(address account) view returns (bool)",
+      // Immutable Config
+      "function baseToken() view returns (address)",
+      "function multiplierNFT() view returns (address)",
+      "function dao() view returns (address)",
+      "function BASIS() view returns (uint256)"
+    ];
+    var SageAuctionHouse = [
+      // Core Auction Functions
+      "function createBid(uint256 nftId) payable",
+      "function settleCurrentAndCreateNewAuction()",
+      "function settleAuction()",
+      "function createAuction()",
+      // Current Auction State
+      "function auction() view returns (uint256 nftId, uint256 amount, uint256 startTime, uint256 endTime, address bidder, bool settled)",
+      // Configuration
+      "function nft() view returns (address)",
+      "function treasury() view returns (address)",
+      "function weth() view returns (address)",
+      "function timeBuffer() view returns (uint256)",
+      "function reservePrice() view returns (uint256)",
+      "function minBidIncrementPercentage() view returns (uint256)",
+      "function duration() view returns (uint256)",
+      "function mintTierId() view returns (uint256)",
+      "function defaultTokenURI() view returns (string)",
+      // Admin Functions
+      "function pause()",
+      "function unpause()",
+      "function paused() view returns (bool)",
+      "function setTimeBuffer(uint256 _timeBuffer)",
+      "function setReservePrice(uint256 _reservePrice)",
+      "function setMinBidIncrementPercentage(uint256 _minBidIncrementPercentage)",
+      "function setDuration(uint256 _duration)",
+      "function setMintTierId(uint256 _tierId)",
+      "function setDefaultTokenURI(string _uri)",
+      "function owner() view returns (address)",
+      "function transferOwnership(address newOwner)",
+      // Events
+      "event AuctionCreated(uint256 indexed nftId, uint256 startTime, uint256 endTime)",
+      "event AuctionBid(uint256 indexed nftId, address sender, uint256 value, bool extended)",
+      "event AuctionExtended(uint256 indexed nftId, uint256 endTime)",
+      "event AuctionSettled(uint256 indexed nftId, address winner, uint256 amount)",
+      "event AuctionTimeBufferUpdated(uint256 timeBuffer)",
+      "event AuctionReservePriceUpdated(uint256 reservePrice)",
+      "event AuctionMinBidIncrementPercentageUpdated(uint256 minBidIncrementPercentage)",
+      "event AuctionDurationUpdated(uint256 duration)"
+    ];
+    var SimpleBountySystem = [
+      // Constants
+      "function GOVERNANCE_ROLE() view returns (bytes32)",
+      "function MAX_SUBMISSIONS_PER_BOUNTY() view returns (uint256)",
+      // Bounty Creation
+      "function createBounty(string title, string description, string ipfsCID, uint256 reward, uint256 deadline) returns (uint256)",
+      "function createBountyAdvanced(string title, string description, string ipfsCID, uint256 reward, uint256 deadline, uint256 votingDuration, uint8 mode, uint8 libraryAction, address assignee, string libraryKey) returns (uint256)",
+      // Submission & Claiming
+      "function claimBounty(uint256 bountyId)",
+      "function submitEntry(uint256 bountyId, string promptIPFS, string deliverableIPFS) returns (uint256)",
+      "function completeBounty(uint256 bountyId, string deliverableIPFS)",
+      // Voting (COMPETITIVE mode)
+      "function startVoting(uint256 bountyId)",
+      "function vote(uint256 bountyId, uint256 submissionId)",
+      "function finalizeCompetitive(uint256 bountyId)",
+      // Approval
+      "function approveSubmission(uint256 bountyId, uint256 submissionId)",
+      "function approveBountyCompletion(uint256 bountyId, string)",
+      // Cancellation & Expiry
+      "function cancelBounty(uint256 bountyId)",
+      "function expireBounty(uint256 bountyId)",
+      // Reward Management
+      "function increaseReward(uint256 bountyId, uint256 additionalReward)",
+      "function slashCreator(uint256 bountyId, uint256 amount, address to)",
+      // Gate Management
+      "function setGates(uint256 bountyId, uint256 minTokenBalance, uint256 requiredBadgeId)",
+      "function addToWhitelist(uint256 bountyId, address[] addresses)",
+      "function removeFromWhitelist(uint256 bountyId, address[] addresses)",
+      "function canSubmit(uint256 bountyId, address submitter) view returns (bool)",
+      // View Functions
+      "function getBounty(uint256 bountyId) view returns (tuple(address creator, uint256 id, string title, string description, string ipfsCID, uint256 reward, uint256 creatorDeposit, uint256 minContributorLevel, uint256 minTokenBalance, uint256 requiredBadgeId, uint256 deadline, uint256 votingEndTime, uint256 snapshotBlock, uint8 mode, uint8 status, uint8 libraryAction, address assignee, address winner, uint256 winningSubmissionId, string libraryKey, uint256 governanceProposalId))",
+      "function getSubmission(uint256 bountyId, uint256 submissionId) view returns (tuple(uint256 id, uint256 bountyId, address submitter, string promptIPFS, string deliverableIPFS, uint256 timestamp, uint256 voteCount, bool exists))",
+      "function getSubmissionCount(uint256 bountyId) view returns (uint256)",
+      "function getLeadingSubmission(uint256 bountyId) view returns (uint256 submissionId, uint256 votes)",
+      "function calculateStake(uint256 reward) view returns (uint256)",
+      // State Mappings
+      "function bounties(uint256) view returns (address creator, uint256 id, string title, string description, string ipfsCID, uint256 reward, uint256 creatorDeposit, uint256 minContributorLevel, uint256 minTokenBalance, uint256 requiredBadgeId, uint256 deadline, uint256 votingEndTime, uint256 snapshotBlock, uint8 mode, uint8 status, uint8 libraryAction, address assignee, address winner, uint256 winningSubmissionId, string libraryKey, uint256 governanceProposalId)",
+      "function nextBountyId() view returns (uint256)",
+      "function submissionCount(uint256) view returns (uint256)",
+      "function submitterToSubmission(uint256, address) view returns (uint256)",
+      "function hasVotedInBounty(uint256, address) view returns (bool)",
+      "function voterChosenSubmission(uint256, address) view returns (uint256)",
+      "function whitelist(uint256, address) view returns (bool)",
+      "function hasWhitelist(uint256) view returns (bool)",
+      // External Contracts
+      "function sxxxToken() view returns (address)",
+      "function contributorSystem() view returns (address)",
+      "function governanceConfig() view returns (address)",
+      "function communityTreasury() view returns (address)",
+      "function governanceContract() view returns (address)",
+      "function libraryRegistry() view returns (address)",
+      "function subdao() view returns (address)",
+      "function soulboundBadge() view returns (address)",
+      // Admin
+      "function setGovernanceContract(address _gov)",
+      "function setCommunityTreasury(address _treasury)",
+      "function setLibraryRegistry(address _registry)",
+      "function setSoulboundBadge(address _sbtAddress)",
+      "function grantRole(bytes32 role, address account)",
+      "function revokeRole(bytes32 role, address account)",
+      "function hasRole(bytes32 role, address account) view returns (bool)",
+      // Events
+      "event BountyCreated(uint256 indexed bountyId, address indexed creator, string title, uint256 reward, uint256 deposit, uint8 mode, address assignee)",
+      "event SubmissionReceived(uint256 indexed bountyId, uint256 indexed submissionId, address indexed submitter, string promptIPFS)",
+      "event BountyClaimed(uint256 indexed bountyId, address indexed claimant)",
+      "event BountyUnderReview(uint256 indexed bountyId, address indexed claimant, uint256 proposalId)",
+      "event VoteCast(uint256 indexed bountyId, uint256 indexed submissionId, address indexed voter, uint256 weight)",
+      "event VotingStarted(uint256 indexed bountyId, uint256 votingEndTime)",
+      "event BountyCompleted(uint256 indexed bountyId, address indexed winner, uint256 reward, string deliverable)",
+      "event BountyAutoApproved(uint256 indexed bountyId, address indexed winner)",
+      "event PromptAddedToLibrary(uint256 indexed bountyId, string libraryKey, string promptIPFS)",
+      "event BountyCancelled(uint256 indexed bountyId, address indexed creator)",
+      "event BountyExpired(uint256 indexed bountyId)",
+      "event BountyRewardIncreased(uint256 indexed bountyId, uint256 additionalReward, uint256 newTotal)",
+      "event CreatorSlashed(uint256 indexed bountyId, uint256 amount, address indexed to)"
+    ];
     var Events = {
       ProposalCreated: "event ProposalCreated(uint256 id, address proposer, address[] targets, uint256[] values, string[] signatures, bytes[] calldatas, uint256 startBlock, uint256 endBlock, string description)"
     };
@@ -315,6 +499,13 @@ var require_abi = __commonJS({
       // Protocol treasury (replaces SageTreasury)
       GovernanceBoostMerkle,
       GovernanceBoostDirect,
+      // Voting Multiplier System
+      VotingMultiplierNFT,
+      MultipliedVotes,
+      // Auction House
+      SageAuctionHouse,
+      // Bounty System
+      SimpleBountySystem,
       Events
     };
   }
@@ -672,6 +863,409 @@ var require_subgraph = __commonJS({
       listLibraries,
       getSubdaoLibraries,
       getSubdaoPrompts,
+      /**
+       * Bounty dashboards (SimpleBountySystem)
+       */
+      async listBounties({ url, first = 50, skip = 0, status = null, creator = null }) {
+        if (!url) throw new Error("subgraph url required");
+        const filters = [];
+        if (status != null) filters.push(`status: ${Number(status)}`);
+        if (creator) {
+          const addr = safeGetAddress(creator);
+          if (!addr) throw new Error("invalid creator address");
+          filters.push(`creator: "${addr.toLowerCase()}"`);
+        }
+        const where = filters.length ? `where:{ ${filters.join(", ")} }` : "";
+        const doc = `
+      query($first:Int!,$skip:Int!){
+        bounties(
+          ${where}
+          first:$first
+          skip:$skip
+          orderBy: createdAt
+          orderDirection: desc
+        ){
+          id
+          contract
+          bountyId
+          creator
+          title
+          reward
+          creatorDeposit
+          mode
+          status
+          libraryAction
+          assignee
+          winner
+          winningSubmissionId
+          libraryKey
+          deadline
+          votingEndTime
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+        const data = await query(url, doc, {
+          first: Math.min(Math.max(1, Number(first || 50)), 200),
+          skip: Number(skip || 0)
+        });
+        return mapSafe(data?.bounties, (row) => {
+          const contract = safeGetAddress(row.contract);
+          const creatorAddr = safeGetAddress(row.creator);
+          const assignee = row.assignee ? safeGetAddress(row.assignee) : null;
+          const winner = row.winner ? safeGetAddress(row.winner) : null;
+          if (!contract || !creatorAddr) return null;
+          return {
+            id: String(row.id),
+            contract,
+            bountyId: BigInt(String(row.bountyId || "0")),
+            creator: creatorAddr,
+            title: String(row.title || ""),
+            reward: BigInt(String(row.reward || "0")),
+            creatorDeposit: BigInt(String(row.creatorDeposit || "0")),
+            mode: Number(row.mode || 0),
+            status: Number(row.status || 0),
+            libraryAction: row.libraryAction != null ? Number(row.libraryAction) : null,
+            assignee,
+            winner,
+            winningSubmissionId: row.winningSubmissionId != null ? BigInt(String(row.winningSubmissionId)) : null,
+            libraryKey: row.libraryKey || null,
+            deadline: row.deadline != null ? Number(row.deadline) : null,
+            votingEndTime: row.votingEndTime != null ? Number(row.votingEndTime) : null,
+            createdAt: Number(row.createdAt || 0),
+            updatedAt: Number(row.updatedAt || 0)
+          };
+        });
+      },
+      async getBounty({ url, id: id2 }) {
+        if (!url) throw new Error("subgraph url required");
+        const doc = `
+      query($id:ID!){
+        bounty(id:$id){
+          id
+          contract
+          bountyId
+          creator
+          title
+          reward
+          creatorDeposit
+          mode
+          status
+          libraryAction
+          assignee
+          winner
+          winningSubmissionId
+          libraryKey
+          deadline
+          votingEndTime
+          snapshotBlock
+          governanceProposalId
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+        const data = await query(url, doc, { id: String(id2) });
+        const row = data?.bounty;
+        if (!row) return null;
+        const contract = safeGetAddress(row.contract);
+        const creatorAddr = safeGetAddress(row.creator);
+        if (!contract || !creatorAddr) return null;
+        return {
+          id: String(row.id),
+          contract,
+          bountyId: BigInt(String(row.bountyId || "0")),
+          creator: creatorAddr,
+          title: String(row.title || ""),
+          reward: BigInt(String(row.reward || "0")),
+          creatorDeposit: BigInt(String(row.creatorDeposit || "0")),
+          mode: Number(row.mode || 0),
+          status: Number(row.status || 0),
+          libraryAction: row.libraryAction != null ? Number(row.libraryAction) : null,
+          assignee: row.assignee ? safeGetAddress(row.assignee) : null,
+          winner: row.winner ? safeGetAddress(row.winner) : null,
+          winningSubmissionId: row.winningSubmissionId != null ? BigInt(String(row.winningSubmissionId)) : null,
+          libraryKey: row.libraryKey || null,
+          deadline: row.deadline != null ? Number(row.deadline) : null,
+          votingEndTime: row.votingEndTime != null ? Number(row.votingEndTime) : null,
+          snapshotBlock: row.snapshotBlock != null ? Number(row.snapshotBlock) : null,
+          governanceProposalId: row.governanceProposalId != null ? BigInt(String(row.governanceProposalId)) : null,
+          createdAt: Number(row.createdAt || 0),
+          updatedAt: Number(row.updatedAt || 0)
+        };
+      },
+      async listBountySubmissions({ url, bountyId, first = 50, skip = 0 }) {
+        if (!url) throw new Error("subgraph url required");
+        const doc = `
+      query($bountyId:BigInt!,$first:Int!,$skip:Int!){
+        bountySubmissions(
+          where:{ bountyId:$bountyId }
+          first:$first
+          skip:$skip
+          orderBy: timestamp
+          orderDirection: asc
+        ){
+          id
+          bountyId
+          submissionId
+          submitter
+          promptIPFS
+          deliverableIPFS
+          timestamp
+          voteCount
+        }
+      }
+    `;
+        const data = await query(url, doc, {
+          bountyId: String(bountyId),
+          first: Math.min(Math.max(1, Number(first || 50)), 200),
+          skip: Number(skip || 0)
+        });
+        return mapSafe(data?.bountySubmissions, (row) => {
+          const submitter = safeGetAddress(row.submitter);
+          if (!submitter) return null;
+          return {
+            id: String(row.id),
+            bountyId: BigInt(String(row.bountyId || "0")),
+            submissionId: BigInt(String(row.submissionId || "0")),
+            submitter,
+            promptIPFS: String(row.promptIPFS || ""),
+            deliverableIPFS: String(row.deliverableIPFS || ""),
+            timestamp: Number(row.timestamp || 0),
+            voteCount: BigInt(String(row.voteCount || "0"))
+          };
+        });
+      },
+      async listBountyVotes({ url, bountyId, first = 100, skip = 0 }) {
+        if (!url) throw new Error("subgraph url required");
+        const doc = `
+      query($bountyId:BigInt!,$first:Int!,$skip:Int!){
+        bountyVotes(
+          where:{ bountyId:$bountyId }
+          first:$first
+          skip:$skip
+          orderBy: blockTimestamp
+          orderDirection: desc
+        ){
+          id
+          bountyId
+          submissionId
+          voter
+          weight
+          blockNumber
+          blockTimestamp
+          transactionHash
+        }
+      }
+    `;
+        const data = await query(url, doc, {
+          bountyId: String(bountyId),
+          first: Math.min(Math.max(1, Number(first || 100)), 500),
+          skip: Number(skip || 0)
+        });
+        return mapSafe(data?.bountyVotes, (row) => {
+          const voter = safeGetAddress(row.voter);
+          if (!voter) return null;
+          return {
+            id: String(row.id),
+            bountyId: BigInt(String(row.bountyId || "0")),
+            submissionId: BigInt(String(row.submissionId || "0")),
+            voter,
+            weight: BigInt(String(row.weight || "0")),
+            blockNumber: Number(row.blockNumber || 0),
+            blockTimestamp: Number(row.blockTimestamp || 0),
+            transactionHash: row.transactionHash || null
+          };
+        });
+      },
+      /**
+       * Multiplier dashboards (VotingMultiplierNFT + SageAuctionHouse)
+       */
+      async listMultiplierAccounts({ url, dao, first = 100, skip = 0 }) {
+        if (!url) throw new Error("subgraph url required");
+        const daoAddr = safeGetAddress(dao);
+        if (!daoAddr) throw new Error("invalid dao address");
+        const doc = `
+      query($dao:Bytes!,$first:Int!,$skip:Int!){
+        multiplierAccounts(
+          where:{ dao: $dao }
+          first:$first
+          skip:$skip
+          orderBy: currentMultiplierBps
+          orderDirection: desc
+        ){
+          id
+          dao
+          account
+          currentMultiplierBps
+          tokenCount
+          updatedAt
+        }
+      }
+    `;
+        const data = await query(url, doc, {
+          dao: daoAddr.toLowerCase(),
+          first: Math.min(Math.max(1, Number(first || 100)), 500),
+          skip: Number(skip || 0)
+        });
+        return mapSafe(data?.multiplierAccounts, (row) => {
+          const daoNorm = safeGetAddress(row.dao);
+          const account = safeGetAddress(row.account);
+          if (!daoNorm || !account) return null;
+          return {
+            id: String(row.id),
+            dao: daoNorm,
+            account,
+            multiplierBps: BigInt(String(row.currentMultiplierBps || "0")),
+            tokenCount: Number(row.tokenCount || 0),
+            updatedAt: Number(row.updatedAt || 0)
+          };
+        });
+      },
+      async listMultiplierNFTs({ url, dao, owner = null, first = 100, skip = 0 }) {
+        if (!url) throw new Error("subgraph url required");
+        const daoAddr = safeGetAddress(dao);
+        if (!daoAddr) throw new Error("invalid dao address");
+        const ownerAddr = owner ? safeGetAddress(owner) : null;
+        const filters = [`dao: $dao`];
+        if (ownerAddr) filters.push(`owner: $owner`);
+        const where = `where:{ ${filters.join(", ")} }`;
+        const doc = `
+      query($dao:Bytes!,$owner:Bytes,$first:Int!,$skip:Int!){
+        multiplierNFTs(
+          ${where}
+          first:$first
+          skip:$skip
+          orderBy: mintedAt
+          orderDirection: desc
+        ){
+          id
+          owner
+          dao
+          tier { id name multiplier maxSupply minted price }
+          multiplier
+          tokenURI
+          mintedAt
+          transactionHash
+        }
+      }
+    `;
+        const variables = {
+          dao: daoAddr.toLowerCase(),
+          owner: ownerAddr ? ownerAddr.toLowerCase() : null,
+          first: Math.min(Math.max(1, Number(first || 100)), 500),
+          skip: Number(skip || 0)
+        };
+        const data = await query(url, doc, variables);
+        return mapSafe(data?.multiplierNFTs, (row) => {
+          const ownerNorm = safeGetAddress(row.owner);
+          const daoNorm = safeGetAddress(row.dao);
+          if (!ownerNorm || !daoNorm) return null;
+          return {
+            id: String(row.id),
+            owner: ownerNorm,
+            dao: daoNorm,
+            tier: row.tier ? {
+              id: String(row.tier.id),
+              name: String(row.tier.name || ""),
+              multiplier: Number(row.tier.multiplier || 0),
+              maxSupply: BigInt(String(row.tier.maxSupply || "0")),
+              minted: BigInt(String(row.tier.minted || "0")),
+              price: BigInt(String(row.tier.price || "0"))
+            } : null,
+            multiplier: Number(row.multiplier || 0),
+            tokenURI: row.tokenURI || null,
+            mintedAt: Number(row.mintedAt || 0),
+            transactionHash: row.transactionHash || null
+          };
+        });
+      },
+      async getCurrentAuction({ url, auctionHouse }) {
+        if (!url) throw new Error("subgraph url required");
+        const addr = safeGetAddress(auctionHouse);
+        if (!addr) throw new Error("invalid auctionHouse address");
+        const doc = `
+      query($id:ID!){
+        multiplierAuction(id:$id){
+          id
+          auctionHouse
+          nft
+          treasury
+          currentNftId
+          currentAmount
+          currentBidder
+          startTime
+          endTime
+          settled
+          updatedAt
+        }
+      }
+    `;
+        const data = await query(url, doc, { id: addr.toLowerCase() });
+        const row = data?.multiplierAuction;
+        if (!row) return null;
+        return {
+          id: String(row.id),
+          auctionHouse: safeGetAddress(row.auctionHouse) || addr,
+          nft: safeGetAddress(row.nft),
+          treasury: safeGetAddress(row.treasury),
+          currentNftId: BigInt(String(row.currentNftId || "0")),
+          currentAmount: BigInt(String(row.currentAmount || "0")),
+          currentBidder: safeGetAddress(row.currentBidder || "0x0000000000000000000000000000000000000000"),
+          startTime: Number(row.startTime || 0),
+          endTime: Number(row.endTime || 0),
+          settled: !!row.settled,
+          updatedAt: Number(row.updatedAt || 0)
+        };
+      },
+      async listAuctionBids({ url, auctionHouse, first = 100, skip = 0 }) {
+        if (!url) throw new Error("subgraph url required");
+        const addr = safeGetAddress(auctionHouse);
+        if (!addr) throw new Error("invalid auctionHouse address");
+        const doc = `
+      query($auctionHouse:Bytes!,$first:Int!,$skip:Int!){
+        multiplierAuctionBids(
+          where:{ auctionHouse:$auctionHouse }
+          first:$first
+          skip:$skip
+          orderBy: blockTimestamp
+          orderDirection: desc
+        ){
+          id
+          auctionHouse
+          nftId
+          bidder
+          amount
+          extended
+          blockNumber
+          blockTimestamp
+          transactionHash
+        }
+      }
+    `;
+        const data = await query(url, doc, {
+          auctionHouse: addr.toLowerCase(),
+          first: Math.min(Math.max(1, Number(first || 100)), 500),
+          skip: Number(skip || 0)
+        });
+        return mapSafe(data?.multiplierAuctionBids, (row) => {
+          const bidder = safeGetAddress(row.bidder);
+          const ah = safeGetAddress(row.auctionHouse);
+          if (!ah || !bidder) return null;
+          return {
+            id: String(row.id),
+            auctionHouse: ah,
+            nftId: BigInt(String(row.nftId || "0")),
+            bidder,
+            amount: BigInt(String(row.amount || "0")),
+            extended: !!row.extended,
+            blockNumber: Number(row.blockNumber || 0),
+            blockTimestamp: Number(row.blockTimestamp || 0),
+            transactionHash: row.transactionHash || null
+          };
+        });
+      },
       /**
        * 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).
@@ -1160,7 +1754,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 };
         }
@@ -1181,8 +1774,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 };
         }
@@ -1203,6 +1795,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");
@@ -1210,17 +1809,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()) {
@@ -1298,7 +1970,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");
@@ -1307,7 +1979,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 });
@@ -1319,6 +1991,9 @@ var require_ipfs = __commonJS({
               return await uploadSimulated(payload, { warm, gateways });
             }
           } catch (error2) {
+            if (error2.code === "CONTENT_BLOCKED" || error2.code === "PAYMENT_REQUIRED") {
+              throw error2;
+            }
             errors2.push({ provider: candidate, error: error2 });
           }
         }
@@ -1327,7 +2002,7 @@ var require_ipfs = __commonJS({
         throw error;
       }
       async function uploadPrompt(options2 = {}) {
-        const { prompt: prompt2, providers, provider, warm, gateways } = options2;
+        const { prompt: prompt2, providers, provider, warm, gateways, pin: pin2 } = options2;
         if (!prompt2 || typeof prompt2 !== "object") {
           throw new Error("prompt payload required");
         }
@@ -1353,6 +2028,7 @@ var require_ipfs = __commonJS({
           provider,
           warm,
           gateways,
+          pin: pin2,
           filename: `${prompt2.name || "prompt"}.json`,
           metadata
         });
@@ -1587,8 +2263,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 {
@@ -2446,13 +3121,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);
@@ -2533,6 +3205,210 @@ var require_governance = __commonJS({
       const token2 = await g.sxxxToken();
       return buildDelegateTx({ token: token2, delegatee: account });
     }
+    async function resolveVotesTokenChain({ provider, subdao: subdao2, governor }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!subdao2 && !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 && subdao2) {
+        try {
+          const subAddr = getAddress(subdao2);
+          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 (!subdao2 || daoNorm === getAddress(subdao2)) {
+            baseToken = baseNorm;
+            isWrapper = true;
+          }
+        }
+      } catch (_) {
+      }
+      return { votingToken: votingTokenNorm, baseToken, isWrapper };
+    }
+    async function describeVotesToken({ provider, subdao: subdao2, governor }) {
+      const { votingToken, baseToken, isWrapper } = await resolveVotesTokenChain({ provider, subdao: subdao2, 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 (subdao2) {
+          description += ` for DAO ${getAddress(subdao2)}`;
+        }
+      }
+      return {
+        votingToken: votingNorm,
+        baseToken: baseNorm,
+        isWrapper,
+        multiplierNFT: multiplierNorm,
+        basis: basisBig,
+        description
+      };
+    }
+    async function getVotingStatus({ provider, subdao: subdao2, governor, account }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!governor && !subdao2) 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 (subdao2) {
+        subdaoAddr = getAddress(subdao2);
+        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,
@@ -2564,52 +3440,28 @@ var require_governance = __commonJS({
        * - SubDAO.stakeToken() (when subdao provided)
        */
       resolveVotesToken: async function resolveVotesToken({ provider, subdao: subdao2, governor }) {
-        if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-        if (!subdao2 && !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 (subdao2) {
-          try {
-            const subAddr = getAddress(subdao2);
-            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: subdao2, 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: subdao2, governor, account }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
-        const token2 = await this.resolveVotesToken({ provider, subdao: subdao2, governor });
-        return buildDelegateTx({ token: token2, delegatee: account });
+        const { baseToken } = await resolveVotesTokenChain({ provider, subdao: subdao2, governor });
+        return buildDelegateTx({ token: baseToken, delegatee: account });
       },
       /**
        * Send a delegate(self) and verify votes at latest-1.
@@ -2618,15 +3470,15 @@ var require_governance = __commonJS({
       delegateSelfAndVerify: async function delegateSelfAndVerify({ provider, subdao: subdao2, 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 token2 = await this.resolveVotesToken({ provider, subdao: subdao2, governor });
-        const payload = buildDelegateTx({ token: token2, delegatee: account });
+        const { votingToken, baseToken } = await resolveVotesTokenChain({ provider, subdao: subdao2, 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: token2, account });
+        const votes = await getVotesLatestMinusOne({ provider, token: votingToken, account });
         const ok = minVotes != null ? votes >= BigInt(minVotes) : votes > 0n;
         return { txHash, ok, votes, payload };
       },
@@ -2680,8 +3532,8 @@ var require_governance = __commonJS({
         }
         let votesOk = null;
         try {
-          const token2 = sxxx || await this.resolveVotesToken({ provider, governor });
-          const votes = await getVotesLatestMinusOne({ provider, token: token2, 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 (_) {
@@ -3215,6 +4067,602 @@ var require_templates = __commonJS({
   }
 });
 
+// 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: subdao2, first = 50, skip = 0 }) {
+      const where = subdao2 ? `where: { subDAO: "${String(subdao2).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: subdao2, first = 20, skip = 0 }) {
+      if (!url) throw new Error("subgraph url required");
+      const hasFilter = !!subdao2;
+      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(subdao2);
+        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: subdao2 = null, first = 50, skip = 0, orderBy = "blockTimestamp", orderDirection = "desc" }) {
+        if (!url) throw new Error("subgraph url required");
+        const filters = [];
+        if (subdao2) {
+          const addr = safeGetAddress(subdao2);
+          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: subdao2 = null, first = 50, skip = 0, orderBy = "blockTimestamp", orderDirection = "desc" }) {
+        if (!url) throw new Error("subgraph url required");
+        const filters = [];
+        if (subdao2) {
+          const addr = safeGetAddress(subdao2);
+          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;
+        }
+      }
+    };
+  }
+});
+
 // src/adapters/governance/openzeppelin.js
 var require_openzeppelin = __commonJS({
   "src/adapters/governance/openzeppelin.js"(exports2, module2) {
@@ -3569,6 +5017,7 @@ var require_operations = __commonJS({
       cache = null,
       fromBlock = 0,
       helperAddress = null,
+      subgraphUrl = null,
       hints = {},
       chunkSizeBlocks = 1e4,
       lookBackBlocks = 2e3,
@@ -3582,6 +5031,27 @@ var require_operations = __commonJS({
         const cached = await cacheAdapter.load(govAddr, id2);
         if (cached) return cached;
       }
+      if (subgraphUrl) {
+        try {
+          const subgraph2 = require_subgraph2();
+          const sgProposal = await subgraph2.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 = [
@@ -3795,8 +5265,14 @@ var require_operations = __commonJS({
       ]);
       let resolvedSubDAO = subdao2;
       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;
@@ -3871,10 +5347,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 governance2.getProposal({ provider, governor: tuple.governor, id: tuple.id });
@@ -4212,8 +5689,6 @@ var require_factory = __commonJS({
         stableCreationFee,
         feeReceiver,
         allowStableFee,
-        stablePromptForkFee,
-        allowStablePromptForkFee,
         stableForkFee,
         allowStableForkFee,
         timelockMinDelay,
@@ -4237,8 +5712,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),
@@ -4254,8 +5727,6 @@ var require_factory = __commonJS({
         stableCreationFee,
         feeReceiver: feeReceiver && feeReceiver !== "0x0000000000000000000000000000000000000000" ? getAddress(feeReceiver) : null,
         allowStableFee,
-        stablePromptForkFee,
-        allowStablePromptForkFee,
         stableForkFee,
         allowStableForkFee,
         timelockMinDelay,
@@ -4587,6 +6058,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: subdao2 }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao2) 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(subdao2, "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: subdao2 }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao2) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const chain = [];
+        let current = normalise(subdao2, "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: subdao2 }) {
+      const parent = await getParentLibrary({ provider, registry, subdao: subdao2 });
+      return parent !== null;
+    }
+    async function getLibraryForkFee({ provider, registry, subdao: subdao2 }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao2) 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(subdao2, "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: subdao2 }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao2) 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(subdao2, "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) {
@@ -5259,7 +6837,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 };
         }
@@ -5281,8 +6858,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 };
         }
@@ -5919,8 +7495,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)",
@@ -5965,7 +7567,7 @@ var require_treasury = __commonJS({
     async function getTreasuryInfo({ provider, treasury: treasury2 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury2, "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),
@@ -5989,7 +7591,7 @@ var require_treasury = __commonJS({
     async function getPendingWithdrawals({ provider, treasury: treasury2, ids, limit = 50 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury2, "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);
@@ -6021,14 +7623,14 @@ var require_treasury = __commonJS({
     async function getReserveTokens({ provider, treasury: treasury2 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury2, "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((token2) => getAddress(token2));
     }
     async function getReserves({ provider, treasury: treasury2, tokens, fetchMetadata = true }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury2, "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((token2) => getAddress(token2)) : await contract.getReserveTokens().catch(() => []);
       const reserves = [];
       for (const token2 of tokenList) {
@@ -6058,7 +7660,7 @@ var require_treasury = __commonJS({
     async function getManualPriceOverrides({ provider, treasury: treasury2, tokens }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury2, "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((token2) => getAddress(token2)) : await contract.getReserveTokens().catch(() => []);
       const overrides = [];
       for (const token2 of tokenList) {
@@ -6163,7 +7765,7 @@ var require_treasury = __commonJS({
     async function getLPContribution({ provider, treasury: treasury2, subdao: subdao2, token: token2 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury2, "treasury");
-      const c = new Contract(addr, ABI.SageTreasury, provider);
+      const c = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const amount = await c.lpContributions(normalise(subdao2, "subdao"), normalise(token2, "token")).catch(() => 0n);
       return amount;
     }
@@ -6205,7 +7807,7 @@ var require_treasury = __commonJS({
     function createWriteContract({ signer, treasury: treasury2 }) {
       if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
       const addr = normalise(treasury2, "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;
@@ -6509,6 +8111,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, treasury2, 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(treasury2),
+        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) {
@@ -8372,8 +10318,8 @@ var require_doppler = __commonJS({
       return res;
     };
     module2.exports.getStaticPoolInfo = async function getStaticPoolInfo(sdk, poolAddress) {
-      const auction = await sdk.getStaticAuction(poolAddress);
-      return auction.getPoolInfo();
+      const auction2 = await sdk.getStaticAuction(poolAddress);
+      return auction2.getPoolInfo();
     };
     module2.exports.quoteV3ExactIn = async function quoteV3ExactIn(sdk, { tokenIn, tokenOut, amountIn, fee, sqrtPriceLimitX96 = 0n }) {
       return sdk.quoter.quoteExactInputV3({ tokenIn, tokenOut, amountIn, fee, sqrtPriceLimitX96 });
@@ -8396,8 +10342,8 @@ var require_doppler = __commonJS({
       return { deposited: needed, hash };
     };
     module2.exports.getDynamicHookInfo = async function getDynamicHookInfo(sdk, hookAddress) {
-      const auction = await sdk.getDynamicAuction(hookAddress);
-      return auction.getHookInfo();
+      const auction2 = await sdk.getDynamicAuction(hookAddress);
+      return auction2.getHookInfo();
     };
     module2.exports.quoteV4ExactIn = async function quoteV4ExactIn(sdk, { poolKey, zeroForOne, exactAmount, hookData }) {
       return sdk.quoter.quoteExactInputV4({ poolKey, zeroForOne, exactAmount, hookData });
@@ -8510,6 +10456,60 @@ var require_doppler = __commonJS({
   }
 });
 
+// src/points.js
+var require_points = __commonJS({
+  "src/points.js"(exports2, module2) {
+    var axios = require("axios");
+    function resolveBaseUrl(baseUrl) {
+      const fromEnv = process.env.SAGE_POINTS_BASE_URL;
+      const base = baseUrl || fromEnv;
+      if (!base) {
+        throw new Error(
+          "SAGE_POINTS_BASE_URL not set and no baseUrl provided. Provide the Sage web app base URL, e.g. https://app.sage.xyz"
+        );
+      }
+      return base.replace(/\/+$/, "");
+    }
+    async function fetchSeasonSnapshot({ baseUrl, season = "season-1" } = {}) {
+      const base = resolveBaseUrl(baseUrl);
+      const url = `${base}/airdrop/${season}/points.json`;
+      const resp = await axios.get(url, { timeout: 15e3 });
+      if (!resp || !resp.data) {
+        throw new Error(`No data returned from ${url}`);
+      }
+      return resp.data;
+    }
+    async function getSeasonPoints({ address, season = "season-1", baseUrl } = {}) {
+      if (!address) throw new Error("address is required");
+      const snapshot = await fetchSeasonSnapshot({ baseUrl, season });
+      const totals = snapshot.totals || {};
+      const key = address.toLowerCase();
+      const entry = totals[key] || null;
+      return {
+        season: snapshot.season || season,
+        chainId: snapshot.chainId,
+        address: key,
+        totalPoints: entry ? entry.points || 0 : 0,
+        breakdown: entry ? entry.breakdown || {} : {}
+      };
+    }
+    async function getSeasonLeaderboard({ limit = 100, season = "season-1", baseUrl } = {}) {
+      const snapshot = await fetchSeasonSnapshot({ baseUrl, season });
+      const totals = snapshot.totals || {};
+      const entries = Object.entries(totals).map(([addr, v]) => ({
+        address: addr,
+        points: v.points || 0
+      })).sort((a, b) => b.points - a.points);
+      return entries.slice(0, limit);
+    }
+    module2.exports = {
+      fetchSeasonSnapshot,
+      getSeasonPoints,
+      getSeasonLeaderboard
+    };
+  }
+});
+
 // src/services/utils/cache.js
 var require_cache = __commonJS({
   "src/services/utils/cache.js"(exports2, module2) {
@@ -9260,6 +11260,273 @@ var require_client2 = __commonJS({
   }
 });
 
+// src/clients/discovery-client.js
+var require_discovery_client = __commonJS({
+  "src/clients/discovery-client.js"(exports2, module2) {
+    var DiscoveryClient2 = 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: DiscoveryClient2 };
+  }
+});
+
+// src/clients/index.js
+var require_clients = __commonJS({
+  "src/clients/index.js"(exports2, module2) {
+    var { DiscoveryClient: DiscoveryClient2 } = require_discovery_client();
+    module2.exports = {
+      DiscoveryClient: DiscoveryClient2
+    };
+  }
+});
+
 // src/hooks/useSubDAOs.js
 var require_useSubDAOs = __commonJS({
   "src/hooks/useSubDAOs.js"(exports2, module2) {
@@ -9468,6 +11735,7 @@ var subdao = require_subdao();
 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();
@@ -9481,6 +11749,8 @@ var time = require_time();
 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();
@@ -9495,11 +11765,13 @@ var adapters = {
     openzeppelin: require_openzeppelin()
   }
 };
+var points = require_points();
 var { SubgraphService } = require_client();
 var { IPFSService } = require_client2();
 var serviceErrors = require_errors2();
 var { SimpleCache } = require_cache();
 var { retryWithBackoff } = require_retry();
+var { DiscoveryClient } = require_clients();
 var hooks = null;
 try {
   hooks = require_hooks();
@@ -9515,6 +11787,7 @@ module.exports = {
   timelock,
   factory,
   library,
+  lineage,
   prompt,
   ipfs,
   ipns,
@@ -9527,6 +11800,8 @@ module.exports = {
   subgraph,
   utils: { ...utils, privateTx, safe, time },
   bounty,
+  votingMultiplier,
+  auction,
   wallet: Object.assign(wallet, {
     cast: walletCastManager,
     cdp: walletCdpManager
@@ -9535,6 +11810,8 @@ module.exports = {
   errors,
   doppler,
   adapters,
+  // Season points helpers (airdrops/testnet)
+  points,
   // New service layer exports
   services: {
     SubgraphService,
@@ -9545,6 +11822,11 @@ module.exports = {
     SimpleCache,
     retryWithBackoff
   },
+  // Client exports
+  clients: {
+    DiscoveryClient
+  },
+  DiscoveryClient,
   // React hooks (optional - requires react + swr peer dependencies)
   hooks,
   // Legacy exports (deprecated): maintain compatibility while consumers migrate