@sage-protocol/sdk 0.2.6 → 0.2.8

package/dist/node/index.mjs

@@ -20,7 +20,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.2.6",
+      version: "0.2.8",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -146,7 +146,6 @@ var require_abi = __commonJS({
       // Core factory reads
       "function timelockMinDelay() view returns (uint256)",
       "function premiumPromptsAddress() view returns (address)",
-      "function simpleKeyStoreAddress() view returns (address)",
       "function governanceConfigAddress() view returns (address)",
       "function libraryRegistryAddress() view returns (address)",
       // Canonical per‑SubDAO mapping
@@ -333,14 +332,28 @@ var require_abi = __commonJS({
       "event TokensSwept(address indexed token, address indexed to, uint256 amount)"
     ];
     var GovernanceBoostMerkle = [
-      "function getProposalConfig(uint256) view returns (tuple(uint256 proposalId,address token,uint256 totalAmount,uint64 startTime,uint64 endTime,uint256 merkleRoot))",
-      "function fund(uint256 proposalId, uint256 amount)",
-      "function setRoot(uint256 proposalId, uint256 merkleRoot)"
+      "function createBoost(uint256 proposalId, uint256 totalPool)",
+      "function setMerkleRoot(uint256 proposalId, bytes32 root)",
+      "function finalize(uint256 proposalId)",
+      "function claim(uint256 proposalId, address account, uint256 amount, bytes32[] proof)",
+      "function getBoost(uint256 proposalId) view returns (uint256 totalPool, uint256 totalClaimed, bytes32 merkleRoot, bool active, bool finalized, address creator)",
+      "function claimed(uint256 proposalId, address account) view returns (bool)",
+      "event BoostCreated(uint256 indexed proposalId, address indexed creator, uint256 totalPool)",
+      "event MerkleRootSet(uint256 indexed proposalId, bytes32 merkleRoot)",
+      "event RewardClaimed(uint256 indexed proposalId, address indexed voter, uint256 amount)",
+      "event BoostFinalized(uint256 indexed proposalId, uint256 totalClaimed, uint256 refunded)"
     ];
     var GovernanceBoostDirect = [
-      "function getDirectConfig(uint256) view returns (tuple(uint256 proposalId,address token,uint256 perVoter,uint256 maxVoters,uint64 startTime,uint64 endTime))",
-      "function create(uint256 proposalId, address token, uint256 perVoter, uint256 maxVoters)",
-      "function fund(uint256 proposalId, uint256 amount)"
+      "function createBoost((address governor,uint256 proposalId,uint256 perVoter,uint256 maxVoters,uint8 kind,address policy,uint96 minVotes,uint8 payoutMode,uint8 support,uint256 startAt,uint256 expiresAt) params)",
+      "function claim(uint256 proposalId, bytes data)",
+      "function finalize(uint256 proposalId)",
+      "function pause(uint256 proposalId, bool paused)",
+      "function setProtocolRake(uint96 rakeBps, address protocolTreasury)",
+      "function getBoost(uint256 proposalId) view returns (tuple(address creator, address governor, uint256 proposalId, uint256 snapshot, uint256 perVoter, uint256 maxVoters, uint256 votersPaid, uint96 minVotes, uint8 payoutMode, uint8 support, uint256 startAt, uint256 expiresAt, uint256 totalPool, uint256 totalPaid, uint8 kind, address policy, bool active, bool paused) boost)",
+      "function claimed(uint256 proposalId, address account) view returns (bool)",
+      "event BoostCreated(uint256 indexed proposalId, address indexed governor, uint256 perVoter, uint256 maxVoters, uint256 snapshot, uint8 kind, address policy, uint96 minVotes)",
+      "event BoostClaimed(uint256 indexed proposalId, address indexed claimer, uint256 amount, uint256 rake)",
+      "event BoostFinalized(uint256 indexed proposalId, uint256 paidCount, uint256 refund)"
     ];
     var VotingMultiplierNFT = [
       // Constants
@@ -348,6 +361,7 @@ var require_abi = __commonJS({
       "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 createTierViaGovernance(address subdao, 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)",
@@ -6931,6 +6945,7 @@ var require_factory = __commonJS({
     var { Contract, Interface, getAddress } = __require("ethers");
     var ABI = require_abi();
     var { SageSDKError, CODES } = require_errors();
+    var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
     function normalise(address, label) {
       if (!address) throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
       try {
@@ -6939,6 +6954,14 @@ var require_factory = __commonJS({
         throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
       }
     }
+    function normaliseNonZero(address, label) {
+      const addr = normalise(address, label);
+      if (addr === ZERO_ADDRESS) {
+        const hint = label === "operatorAdmin" ? " (set it explicitly; it may be the same as operatorExecutor)" : "";
+        throw new SageSDKError(CODES.INVALID_ARGS, `${label} cannot be zero address${hint}`);
+      }
+      return addr;
+    }
     async function getFactoryConfig({ provider, factory }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(factory, "factory");
@@ -6952,7 +6975,6 @@ var require_factory = __commonJS({
         allowStableForkFee,
         timelockMinDelay,
         premiumPromptsAddress,
-        simpleKeyStoreAddress,
         governanceConfigAddress,
         libraryRegistryAddress,
         templateModule
@@ -6975,7 +6997,6 @@ var require_factory = __commonJS({
         contract.allowStableForkFee().catch(() => null),
         contract.timelockMinDelay().catch(() => null),
         contract.premiumPromptsAddress().catch(() => null),
-        contract.simpleKeyStoreAddress().catch(() => null),
         contract.governanceConfigAddress().catch(() => null),
         contract.libraryRegistryAddress().catch(() => null),
         contract.templateModule().catch(() => null)
@@ -6990,7 +7011,6 @@ var require_factory = __commonJS({
         allowStableForkFee,
         timelockMinDelay,
         premiumPromptsAddress: premiumPromptsAddress && premiumPromptsAddress !== "0x0000000000000000000000000000000000000000" ? getAddress(premiumPromptsAddress) : null,
-        simpleKeyStoreAddress: simpleKeyStoreAddress && simpleKeyStoreAddress !== "0x0000000000000000000000000000000000000000" ? getAddress(simpleKeyStoreAddress) : null,
         governanceConfigAddress: governanceConfigAddress && governanceConfigAddress !== "0x0000000000000000000000000000000000000000" ? getAddress(governanceConfigAddress) : null,
         libraryRegistryAddress: libraryRegistryAddress && libraryRegistryAddress !== "0x0000000000000000000000000000000000000000" ? getAddress(libraryRegistryAddress) : null,
         templateModule: templateModule ? getAddress(templateModule) : null
@@ -7204,7 +7224,7 @@ var require_factory = __commonJS({
         0n,
         // minStakeAmount deprecated
         normalise(operatorExecutor, "operatorExecutor"),
-        normalise(operatorAdmin, "operatorAdmin"),
+        normaliseNonZero(operatorAdmin, "operatorAdmin"),
         tuple
       ]);
       return { to: addr, data: payload, value: 0n };
@@ -7236,7 +7256,7 @@ var require_factory = __commonJS({
         0n,
         // minStakeAmount deprecated
         normalise(operatorExecutor, "operatorExecutor"),
-        normalise(operatorAdmin, "operatorAdmin"),
+        normaliseNonZero(operatorAdmin, "operatorAdmin"),
         Boolean(anyoneExec),
         Boolean(governorProposer),
         tuple
@@ -9457,70 +9477,145 @@ var require_boost = __commonJS({
         throw new SageSDKError(CODES.RPC_ERROR, "failed to normalise bigint", { cause: err });
       }
     }
-    async function getMerkleConfig({ provider, manager, proposalId }) {
+    var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+    async function getMerkleBoost({ provider, manager, proposalId }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(manager, "manager");
       const contract = new Contract(addr, ABI.GovernanceBoostMerkle, provider);
-      const config = await contract.getProposalConfig(proposalId).catch(() => null);
-      if (!config) return null;
+      const result = await contract.getBoost(proposalId).catch(() => null);
+      if (!result) return null;
+      const [totalPool, totalClaimed, merkleRoot, active, finalized, creator] = result;
+      const creatorAddr = creator ? getAddress(creator) : ZERO_ADDRESS;
+      const pool = toBigInt(totalPool);
+      if (!active && !finalized && pool === 0n && creatorAddr === ZERO_ADDRESS) return null;
       return {
         manager: addr,
-        proposalId: Number(config.proposalId ?? proposalId),
-        token: config.token ? getAddress(config.token) : null,
-        totalAmount: toBigInt(config.totalAmount),
-        startTime: Number(config.startTime ?? 0),
-        endTime: Number(config.endTime ?? 0),
-        merkleRoot: toBigInt(config.merkleRoot ?? 0n)
+        proposalId: Number(proposalId),
+        totalPool: pool,
+        totalClaimed: toBigInt(totalClaimed),
+        merkleRoot,
+        active: Boolean(active),
+        finalized: Boolean(finalized),
+        creator: creatorAddr
       };
     }
-    function buildMerkleFundTx({ manager, proposalId, amount }) {
+    function buildMerkleCreateTx({ manager, proposalId, totalPool, amount }) {
+      const addr = normalise(manager, "manager");
+      const pool = totalPool ?? amount;
+      const data = MerkleInterface.encodeFunctionData("createBoost", [Number(proposalId), BigInt(pool ?? 0n)]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildMerkleSetMerkleRootTx({ manager, proposalId, root, merkleRoot }) {
+      const addr = normalise(manager, "manager");
+      const nextRoot = root ?? merkleRoot;
+      const data = MerkleInterface.encodeFunctionData("setMerkleRoot", [Number(proposalId), nextRoot]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildMerkleFinalizeTx({ manager, proposalId }) {
       const addr = normalise(manager, "manager");
-      const data = MerkleInterface.encodeFunctionData("fund", [Number(proposalId), BigInt(amount ?? 0n)]);
+      const data = MerkleInterface.encodeFunctionData("finalize", [Number(proposalId)]);
       return { to: addr, data, value: 0n };
     }
-    function buildMerkleSetRootTx({ manager, proposalId, merkleRoot }) {
+    function buildMerkleClaimTx({ manager, proposalId, account, amount, proof }) {
       const addr = normalise(manager, "manager");
-      const data = MerkleInterface.encodeFunctionData("setRoot", [Number(proposalId), BigInt(merkleRoot ?? 0n)]);
+      const data = MerkleInterface.encodeFunctionData("claim", [
+        Number(proposalId),
+        normalise(account, "account"),
+        BigInt(amount ?? 0n),
+        proof || []
+      ]);
       return { to: addr, data, value: 0n };
     }
-    async function getDirectConfig({ provider, manager, proposalId }) {
+    async function getDirectBoost({ provider, manager, proposalId }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(manager, "manager");
       const contract = new Contract(addr, ABI.GovernanceBoostDirect, provider);
-      const config = await contract.getDirectConfig(proposalId).catch(() => null);
-      if (!config) return null;
+      const boost = await contract.getBoost(proposalId).catch(() => null);
+      if (!boost) return null;
+      const creatorAddr = boost.creator ? getAddress(boost.creator) : ZERO_ADDRESS;
+      const pool = toBigInt(boost.totalPool);
+      if (!boost.active && pool === 0n && creatorAddr === ZERO_ADDRESS) return null;
       return {
         manager: addr,
-        proposalId: Number(config.proposalId ?? proposalId),
-        token: config.token ? getAddress(config.token) : null,
-        perVoter: toBigInt(config.perVoter),
-        maxVoters: toBigInt(config.maxVoters),
-        startTime: Number(config.startTime ?? 0),
-        endTime: Number(config.endTime ?? 0)
+        proposalId: Number(boost.proposalId ?? proposalId),
+        creator: creatorAddr,
+        governor: boost.governor ? getAddress(boost.governor) : null,
+        snapshot: toBigInt(boost.snapshot),
+        perVoter: toBigInt(boost.perVoter),
+        maxVoters: toBigInt(boost.maxVoters),
+        votersPaid: toBigInt(boost.votersPaid),
+        minVotes: toBigInt(boost.minVotes),
+        payoutMode: Number(boost.payoutMode ?? 0),
+        support: Number(boost.support ?? 0),
+        startAt: Number(boost.startAt ?? 0),
+        expiresAt: Number(boost.expiresAt ?? 0),
+        totalPool: pool,
+        totalPaid: toBigInt(boost.totalPaid),
+        kind: Number(boost.kind ?? 0),
+        policy: boost.policy ? getAddress(boost.policy) : null,
+        active: Boolean(boost.active),
+        paused: Boolean(boost.paused)
       };
     }
-    function buildDirectCreateTx({ manager, proposalId, token, perVoter, maxVoters }) {
+    function buildDirectCreateTx({
+      manager,
+      governor,
+      proposalId,
+      perVoter,
+      maxVoters,
+      kind = 0,
+      policy = ZERO_ADDRESS,
+      minVotes = 0n,
+      payoutMode = 0,
+      support = 0,
+      startAt = 0n,
+      expiresAt = 0n
+    }) {
       const addr = normalise(manager, "manager");
-      const data = DirectInterface.encodeFunctionData("create", [
-        Number(proposalId),
-        normalise(token, "token"),
+      const params = [
+        normalise(governor, "governor"),
+        BigInt(proposalId ?? 0n),
         BigInt(perVoter ?? 0n),
-        BigInt(maxVoters ?? 0n)
-      ]);
+        BigInt(maxVoters ?? 0n),
+        Number(kind),
+        policy ? normalise(policy, "policy") : ZERO_ADDRESS,
+        BigInt(minVotes ?? 0n),
+        Number(payoutMode),
+        Number(support),
+        BigInt(startAt ?? 0n),
+        BigInt(expiresAt ?? 0n)
+      ];
+      const data = DirectInterface.encodeFunctionData("createBoost", [params]);
       return { to: addr, data, value: 0n };
     }
-    function buildDirectFundTx({ manager, proposalId, amount }) {
+    function buildDirectClaimTx({ manager, proposalId, data = "0x" }) {
       const addr = normalise(manager, "manager");
-      const data = DirectInterface.encodeFunctionData("fund", [Number(proposalId), BigInt(amount ?? 0n)]);
+      const callData = DirectInterface.encodeFunctionData("claim", [BigInt(proposalId ?? 0n), data]);
+      return { to: addr, data: callData, value: 0n };
+    }
+    function buildDirectFinalizeTx({ manager, proposalId }) {
+      const addr = normalise(manager, "manager");
+      const data = DirectInterface.encodeFunctionData("finalize", [BigInt(proposalId ?? 0n)]);
       return { to: addr, data, value: 0n };
     }
     module2.exports = {
-      getMerkleConfig,
-      buildMerkleFundTx,
-      buildMerkleSetRootTx,
-      getDirectConfig,
+      // Merkle manager (GovernanceBoostManagerMerkle)
+      getMerkleBoost,
+      buildMerkleCreateTx,
+      buildMerkleSetMerkleRootTx,
+      buildMerkleFinalizeTx,
+      buildMerkleClaimTx,
+      // Legacy names (back-compat)
+      getMerkleConfig: getMerkleBoost,
+      buildMerkleFundTx: buildMerkleCreateTx,
+      buildMerkleSetRootTx: buildMerkleSetMerkleRootTx,
+      // Direct manager (GovernanceBoostManager)
+      getDirectBoost,
       buildDirectCreateTx,
-      buildDirectFundTx
+      buildDirectClaimTx,
+      buildDirectFinalizeTx,
+      // Legacy name (back-compat)
+      getDirectConfig: getDirectBoost
     };
   }
 });
@@ -12030,20 +12125,6 @@ ${error}` : ""}`;
             const price = d[2].toString();
             const manifest = d[3];
             return { signature: sig, args: [hash, subdao, price, `"${manifest}"`] };
-          } else if (data.startsWith(__require("ethers").id("setWrappedKey(bytes32,bytes,bytes32)").slice(0, 10))) {
-            const { ethers: ethers2 } = __require("ethers");
-            const sig = "setWrappedKey(bytes32,bytes,bytes32)";
-            const iface = new ethers2.Interface([`function ${sig}`]);
-            const d = iface.decodeFunctionData("setWrappedKey", data);
-            const cidHash = d[0];
-            const wrapped = d[1];
-            const wrapperId = d[2];
-            return { signature: sig, args: [cidHash, wrapped, wrapperId] };
-          } else if (data.startsWith(__require("ethers").id("lockKey(bytes32)").slice(0, 10))) {
-            const { ethers: ethers2 } = __require("ethers");
-            const iface = new ethers2.Interface(["function lockKey(bytes32)"]);
-            const d = iface.decodeFunctionData("lockKey", data);
-            return { signature: "lockKey(bytes32)", args: [d[0]] };
           } else if (data.startsWith(__require("ethers").id("claim(uint256,address,uint256,bytes32[])").slice(0, 10))) {
             const { ethers: ethers2 } = __require("ethers");
             const sig = "claim(uint256,address,uint256,bytes32[])";

package/package.json

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

package/types/index.d.ts

@@ -558,6 +558,85 @@ export interface ManifestValidator {
   bestPracticeCheckFile(manifestPath: string): Array<Record<string, any>>;
 }
 
+// ============================================================================
+// Manifest + Skill Versioning Types (Phase 6)
+// ============================================================================
+
+export interface Provenance {
+  source: 'github' | 'local' | 'sage';
+  repo?: string;
+  path?: string;
+  ref?: string;
+  commit?: string;
+  importedAt?: string;
+}
+
+export interface PromptEntry {
+  key: string;
+  name?: string;
+  type?: 'prompt' | 'skill' | 'agent' | 'command' | 'template' | 'workflow';
+  cid?: string;
+  description?: string;
+  tags?: string[];
+  provenance?: Provenance;
+}
+
+export type UpstreamRef =
+  | { type: 'cid'; value: string }
+  | { type: 'github_commit'; value: { repo: string; commit: string } };
+
+export interface SkillIndex {
+  key: string;
+  activeVersion: string;
+  previousVersion?: string;
+  pendingVersion?: string;
+  installedAt: string;
+
+  origin?: Origin;
+
+  lastChecked?: string;
+  latestUpstream?: UpstreamRef;
+  updateStatus?: 'up_to_date' | 'available' | 'removed' | 'check_failed';
+
+  versions: Record<string, {
+    upstream: UpstreamRef;
+    downloadedAt: string;
+    pinned?: boolean;
+  }>;
+
+  provenance?: Provenance;
+}
+
+export type Origin = OriginSage | OriginGithub;
+
+export type OriginSage =
+  | {
+      type: 'sage';
+      tier: 'dao' | 'personal' | 'shared';
+      originKind: 'entry';
+      chainId: number;
+      owner: string;
+      libraryId: string;
+      manifestCid: string;
+      entryKey: string;
+    }
+  | {
+      type: 'sage';
+      tier: 'dao' | 'personal' | 'shared';
+      originKind: 'library';
+      chainId: number;
+      owner: string;
+      libraryId: string;
+      manifestCid: string;
+    };
+
+export interface OriginGithub {
+  type: 'github';
+  repo: string;
+  path: string;
+  ref?: string;
+}
+
 export interface LibrarySearchResult {
   type: 'library' | 'prompt';
   name: string;
@@ -740,29 +819,89 @@ export interface TreasuryModule {
   getLPContribution(args: { provider: ProviderLike; treasury: AddressLike; subdao: AddressLike; token: AddressLike }): Promise<bigint>;
 }
 
+export interface MerkleBoost {
+  manager: AddressLike;
+  proposalId: number;
+  totalPool: bigint;
+  totalClaimed: bigint;
+  merkleRoot: HashLike;
+  active: boolean;
+  finalized: boolean;
+  creator: AddressLike;
+}
+
+export interface DirectBoost {
+  manager: AddressLike;
+  proposalId: number;
+  creator: AddressLike;
+  governor: AddressLike | null;
+  snapshot: bigint;
+  perVoter: bigint;
+  maxVoters: bigint;
+  votersPaid: bigint;
+  minVotes: bigint;
+  payoutMode: number;
+  support: number;
+  startAt: number;
+  expiresAt: number;
+  totalPool: bigint;
+  totalPaid: bigint;
+  kind: number;
+  policy: AddressLike | null;
+  active: boolean;
+  paused: boolean;
+}
+
 export interface BoostModule {
-  getMerkleConfig(args: { provider: ProviderLike; manager: AddressLike; proposalId: number | bigint }): Promise<{
+  // Merkle manager (GovernanceBoostManagerMerkle)
+  getMerkleBoost(args: { provider: ProviderLike; manager: AddressLike; proposalId: number | bigint }): Promise<MerkleBoost | null>;
+  buildMerkleCreateTx(args: {
     manager: AddressLike;
-    proposalId: number;
-    token: AddressLike | null;
-    totalAmount: bigint;
-    startTime: number;
-    endTime: number;
-    merkleRoot: bigint;
-  } | null>;
+    proposalId: number | bigint;
+    totalPool?: BigNumberish;
+    amount?: BigNumberish;
+  }): TransactionPayload;
+  buildMerkleSetMerkleRootTx(args: {
+    manager: AddressLike;
+    proposalId: number | bigint;
+    root?: HashLike;
+    merkleRoot?: HashLike;
+  }): TransactionPayload;
+  buildMerkleFinalizeTx(args: { manager: AddressLike; proposalId: number | bigint }): TransactionPayload;
+  buildMerkleClaimTx(args: {
+    manager: AddressLike;
+    proposalId: number | bigint;
+    account: AddressLike;
+    amount: BigNumberish;
+    proof: HashLike[];
+  }): TransactionPayload;
+
+  // Legacy names (back-compat)
+  getMerkleConfig(args: { provider: ProviderLike; manager: AddressLike; proposalId: number | bigint }): Promise<MerkleBoost | null>;
   buildMerkleFundTx(args: { manager: AddressLike; proposalId: number | bigint; amount: BigNumberish }): TransactionPayload;
-  buildMerkleSetRootTx(args: { manager: AddressLike; proposalId: number | bigint; merkleRoot: BigNumberish }): TransactionPayload;
-  getDirectConfig(args: { provider: ProviderLike; manager: AddressLike; proposalId: number | bigint }): Promise<{
+  buildMerkleSetRootTx(args: { manager: AddressLike; proposalId: number | bigint; merkleRoot: HashLike }): TransactionPayload;
+
+  // Direct manager (GovernanceBoostManager)
+  getDirectBoost(args: { provider: ProviderLike; manager: AddressLike; proposalId: number | bigint }): Promise<DirectBoost | null>;
+  buildDirectCreateTx(args: {
     manager: AddressLike;
-    proposalId: number;
-    token: AddressLike | null;
-    perVoter: bigint;
-    maxVoters: bigint;
-    startTime: number;
-    endTime: number;
-  } | null>;
-  buildDirectCreateTx(args: { manager: AddressLike; proposalId: number | bigint; token: AddressLike; perVoter: BigNumberish; maxVoters: BigNumberish }): TransactionPayload;
-  buildDirectFundTx(args: { manager: AddressLike; proposalId: number | bigint; amount: BigNumberish }): TransactionPayload;
+    governor: AddressLike;
+    proposalId: number | bigint;
+    perVoter: BigNumberish;
+    maxVoters: BigNumberish;
+    kind?: number;
+    policy?: AddressLike;
+    minVotes?: BigNumberish;
+    payoutMode?: number;
+    support?: number;
+    startAt?: BigNumberish;
+    expiresAt?: BigNumberish;
+  }): TransactionPayload;
+  buildDirectClaimTx(args: { manager: AddressLike; proposalId: number | bigint; data?: HashLike }): TransactionPayload;
+  buildDirectFinalizeTx(args: { manager: AddressLike; proposalId: number | bigint }): TransactionPayload;
+
+  // Legacy name (back-compat)
+  getDirectConfig(args: { provider: ProviderLike; manager: AddressLike; proposalId: number | bigint }): Promise<DirectBoost | null>;
 }
 
 export interface PersonalModule {