@wandevs/governance-contracts-sdk 1.0.0 → 1.1.0

package/dist/index.d.mts

@@ -1,31 +1,82 @@
-import { Abi, Account, Address, Chain, ContractFunctionArgs, ContractFunctionName, EncodeFunctionDataParameters, Hex, PrepareTransactionRequestReturnType } from "viem";
+import { Abi, Account, Address, Chain, ContractFunctionArgs, ContractFunctionName, Hex, PrepareTransactionRequestReturnType, PublicClient } from "viem";
 
 //#region src/util.d.ts
-declare const supportedProposalDescriptionDataTypeSchema: {
-  1: {
-    types: {
-      type: string;
-    }[];
-    names: string[];
-  };
-  2: {
-    types: {
-      type: string;
-    }[];
-    names: string[];
-  };
-  3: {
-    types: {
-      type: string;
-    }[];
-    names: string[];
-  };
-};
-declare function encodeProposalDescriptionData(...args: any[]): any;
-declare function decodeProposalDescriptionData(hexData: any): {};
-declare function getVersionFromData(hexData: any): number;
+/**
+ * Type definition for proposal description schema structure
+ * @interface ProposalDescriptionSchema
+ * @property {Array<{ type: string }>} types - ABI parameter types array
+ * @property {string[]} names - Corresponding parameter names array (no undefined values)
+ */
+interface ProposalDescriptionSchema {
+  types: Array<{
+    type: 'uint8' | 'string';
+  }>;
+  names: string[];
+}
+/**
+ * Type definition for decoded proposal description data
+ * @type {Record<string, number | string>}
+ * Key-value pairs of proposal description data (version/title/description etc.)
+ */
+type ProposalDescriptionData = Record<string, number | string>;
+/**
+ * Valid version types for proposal description schema
+ * @type {1 | 2 | 3}
+ */
+type ValidVersion = 1 | 2 | 3;
+/**
+ * Supported proposal description data type schemas by version
+ * @readonly
+ * @type {Record<ValidVersion, ProposalDescriptionSchema>}
+ * Schema definitions for different versions of proposal description data:
+ * - Version 1: basic fields (version/title/description/email/telegram)
+ * - Version 2: adds twitter field
+ * - Version 3: adds discord field
+ */
+declare const supportedProposalDescriptionDataTypeSchema: Record<ValidVersion, ProposalDescriptionSchema>;
+/**
+ * Encodes proposal description data to Hex format using viem's encodeAbiParameters
+ * @function encodeProposalDescriptionData
+ * @param {...(number | string)} args - Proposal description parameters (matches schema by version):
+ * - First argument: version (uint8, 1/2/3)
+ * - Subsequent arguments: title, description, email, telegram, [twitter], [discord]
+ * @returns {Hex} Encoded Hex string of proposal description data
+ * @throws {Error} If version is unsupported or argument count doesn't match schema
+ * @example
+ * // Encode version 2 proposal data
+ * const encoded = encodeProposalDescriptionData(2, "Test Proposal", "Test Description", "test@example.com", "@test", "@test_twitter");
+ * console.log(encoded); // Hex string
+ */
+declare function encodeProposalDescriptionData(...args: (number | string)[]): Hex;
+/**
+ * Decodes Hex formatted proposal description data back to object format
+ * @function decodeProposalDescriptionData
+ * @param {Hex} hexData - Encoded Hex string of proposal description data
+ * @returns {ProposalDescriptionData} Decoded proposal description object with named fields
+ * @throws {Error} If version from hexData is unsupported or data is corrupted
+ * @example
+ * // Decode Hex data to proposal object
+ * const decoded = decodeProposalDescriptionData("0x...");
+ * console.log(decoded.title); // "Test Proposal"
+ */
+declare function decodeProposalDescriptionData(hexData: Hex): ProposalDescriptionData;
+/**
+ * Extracts version number from encoded Hex proposal data
+ * @function getVersionFromData
+ * @param {Hex} hexData - Encoded Hex string of proposal description data
+ * @returns {ValidVersion | 0} Extracted valid version (1/2/3) or 0 if invalid
+ * Reads the first 32-byte slot of Hex data to get uint8 version value
+ * @example
+ * const version = getVersionFromData("0x...");
+ * console.log(version); // 2
+ */
+declare function getVersionFromData(hexData: Hex): ValidVersion | 0;
 //#endregion
 //#region src/types/index.d.ts
+/**
+ * @enum {number} UnstakeStatus
+ * Define unstake status at different stages.
+ */
 declare enum UnstakeStatus {
   NotExists = 0,
   // Request does not exist
@@ -35,21 +86,37 @@ declare enum UnstakeStatus {
   // Request is in progress
   ReadyToClaim = 3
 }
+/**
+ * @enum {number} ProposalRole
+ * Define the roles of proposal participants.
+ */
 declare enum ProposalRole {
   Proposer = 0,
   Partner = 1,
   Voter = 2
 }
+/**
+ * @enum {number} PledgeType
+ * Define the type of pledged.
+ */
 declare enum PledgeType {
   None = 0,
   Burn = 1,
   Lock = 2
 }
+/**
+ * @enum {number} VoteType
+ * Define the type of vote.
+ */
 declare enum VoteType {
   None = 0,
   For = 1,
   Against = 2
 }
+/**
+ * @enum {number} ProposalState
+ * Define the different stages of a proposal.
+ */
 declare enum ProposalState {
   None = 0,
   UnderReview = 1,
@@ -59,79 +126,443 @@ declare enum ProposalState {
   Succeeded = 5,
   Rejected = 6
 }
+/**
+ * @enum {number} ProposalCategory
+ * Define the category of proposal.
+ */
 declare enum ProposalCategory {
   Funding = 0,
   Technical = 1
 }
+/**
+ * Funding info.
+ */
 interface FundInfo {
+  /**
+   * Amount of WAN.
+   * @type {bigint}
+   */
   wanAmount: bigint;
+  /**
+   * Amount of WAN power.
+   * @type {bigint}
+   */
   wanPower: bigint;
+  /**
+   * ID of proposal request withdrawal to be queried for proposer, partner or voter.
+   * @type {bigint}
+   */
   requestId: bigint;
+  /**
+   * The amount of StWan that can be withdrawn after staking WAN in the proposal for proposer, partner or voter.
+   * @type {bigint}
+   */
   claimStWanAmount: bigint;
+  /**
+   * The amount of WAN that can be received after claim StWan in the proposal for proposer, partner or voter.
+   * @type {bigint}
+   */
   claimWanAmount: bigint;
+  /**
+   * Lock duration of proposal be queried for proposer, partner or voter.
+   * @type {bigint}
+   */
   lockDuration: bigint;
+  /**
+   * PledgeType of proposal be queried for proposer, partner or voter.
+   * @type {PledgeType}
+   */
   pledgeType: PledgeType;
+  /**
+   * Reasons for participating in the proposal.
+   * @type {Hex}
+   */
   reason: Hex;
+  /**
+   * Indicator showing whether it has been claimed.
+   * @type {boolean}
+   */
   exited: boolean;
 }
+/**
+ * Pproposal vote statistics.
+ */
 interface Tally {
+  /**
+   * Amount of WAN power for yes.
+   * @type {bigint}
+   */
   yes: bigint;
+  /**
+   * Amount of WAN power for no.
+   * @type {bigint}
+   */
   no: bigint;
 }
-interface ProposalInfo {
-  proposalId: Hex;
+/**
+ * ContractProposal: proposal info of Wanchain governance contract.
+ */
+interface ContractProposal {
+  /**
+   * Amount of XP required when proposal creation.
+   * @type {bigint}
+   */
   requireXpAmount: bigint;
+  /**
+   * Amount of WAN request when proposal creation.
+   * @type {bigint}
+   */
   requestWanAmount: bigint;
+  /**
+   * Minimum amount of WAN power to win proposal vote.
+   * @type {bigint}
+   */
   requestMinVotingWanPower: bigint;
+  /**
+   * Amount of WAN that proposal total pledged for proposer and partner.
+   * @type {bigint}
+   */
   totalPledgingWanAmount: bigint;
+  /**
+   * Amount of WAN power that proposal total pledged.
+   * @type {bigint}
+   */
   totalPledgingWanPower: bigint;
+  /**
+   * Amount of WAN voted.
+   * @type {bigint}
+   */
   totalVotingWanAmount: bigint;
+  /**
+   * Amount of WAN power voted.
+   * @type {bigint}
+   */
   totalVotingWanPower: bigint;
+  /**
+   * The total amount of T involved in the proposal.
+   * @type {bigint}
+   */
   totalWanAmount: bigint;
+  /**
+   * The amount of WAN's that have passed review in the proposal.
+   * @type {bigint}
+   */
   totalLockingWanAmount: bigint;
+  /**
+   * The amount of WAN's that have burned in the proposal.
+   * @type {bigint}
+   */
   totalBurnedWanAmount: bigint;
+  /**
+   * The total amount of StWan received after staking WAN in the proposal.
+   * @type {bigint}
+   */
   totalStWanAmount: bigint;
+  /**
+   * The amount of StWan that can be withdrawn after staking WAN in the proposal.
+   * @type {bigint}
+   */
   totalClaimeStWanAmount: bigint;
+  /**
+   * Timestamp of proposal creation.
+   * @type {bigint}
+   */
   submitTimestamp: bigint;
+  /**
+   * Fundraising deadline for prospective proposal.
+   * @type {bigint}
+   */
   fundraisingDeadline: bigint;
+  /**
+   * Vote deadline for active(voting) proposal.
+   * @type {bigint}
+   */
   voteDeadline: bigint;
+  /**
+   * Current proposal vote statistics.
+   * @type {bigint}
+   */
   tally: Tally;
+  /**
+   * Funding info of proposer.
+   * @type {Hex}
+   */
   proposerFundInfo: FundInfo;
+  /**
+   * Category of proposal.
+   * @type {Hex}
+   */
   category: ProposalCategory;
+  /**
+   * State of proposal.
+   * @type {Hex}
+   */
   state: ProposalState;
+  /**
+   * Proposer of proposal.
+   * @type {Hex}
+   */
   proposer: Address;
+  /**
+   * Description of proposal creation.
+   * @type {Hex}
+   */
   description: Hex;
+  /**
+   * Reasons to cancel or review proposal.
+   * @type {Hex}
+   */
   reason: Hex;
 }
+/**
+ * ProposalInfo: proposal info extends contract proposal(ContractProposal)
+ */
+interface ProposalInfo extends ContractProposal {
+  /**
+   * ID of proposal, should be bytes32.
+   * @type {Hex}
+   */
+  proposalId: Hex;
+}
+/**
+ * PartnerInfo: partner info in proposal
+ */
 interface PartnerInfo {
+  /**
+   * Fund info for partner.
+   * @type {FundInfo}
+   */
   fundInfo: FundInfo;
 }
+/**
+ * VoterInfo: voter info in proposal
+ */
 interface VoterInfo {
+  /**
+   * Fund info for voter.
+   * @type {FundInfo}
+   */
   fundInfo: FundInfo;
+  /**
+   * Vote type for voter.
+   * @type {VoteType}
+   */
   voteType: VoteType;
 }
+/**
+ * IndexRange: Index range: [start, index]
+ */
 interface IndexRange {
-  start: bigint;
-  end: bigint;
+  /**
+   * Start index.
+   * @type {number}
+   */
+  start: number;
+  /**
+   * End index.
+   * @type {number}
+   */
+  end: number;
 }
+/**
+ * PlegeMultiplierReturn: Return type for getProposalMultipliers.
+ */
 interface PlegeMultiplierReturn {
+  /**
+   * PledgeType of proposal be queried for proposer, partner or voter.
+   * @type {PledgeType}
+   */
   pledgeType: PledgeType;
+  /**
+   * Lock duration of proposal be queried for proposer, partner or voter.
+   * @type {bigint}
+   */
   lockDuration: bigint;
+  /**
+   * Multiplier of proposal be queried for proposer, partner or voter.
+   * @type {bigint}
+   */
   multiplier: bigint;
 }
+/**
+ * CanRequestProposalWithdrawalParam: Input parameter type for canRequestProposalWithdrawal, same as CanClaimProposalWithdrawalParam.
+ */
 interface CanRequestProposalWithdrawalParam {
+  /**
+   * State of proposal to be queried.
+   * @type {ProposalState}
+   */
   state: ProposalState;
-  pledgeType: PledgeType.Lock;
+  /**
+   * PledgeType of proposal to be queried.
+   * @type {PledgeType}
+   */
+  pledgeType: PledgeType;
+  /**
+   * Lock duration of proposal be queried for proposer, partner or voter.
+   * @type {bigint}
+   */
   lockDuration: bigint;
+  /**
+   * Vote deadlint for proposal to be queried.
+   * @type {bigint}
+   */
   voteDeadline: bigint;
+  /**
+   * ID of proposal request withdrawal to be queried for proposer, partner or voter.
+   * @type {bigint}
+   */
   requestId: bigint;
+  /**
+   * Check if already claimed of proposal to be queried for proposer, partner or voter.
+   * @type {boolean}
+   */
   exited: boolean;
 }
+/**
+ * CanClaimProposalWithdrawalParam: Input parameter type for canClaimProposalWithdrawal, same as CanRequestProposalWithdrawalParam.
+ */
+type CanClaimProposalWithdrawalParam = CanRequestProposalWithdrawalParam;
+/**
+ * CanRequestProposalWithdrawalRetrunItem: Return array item for canRequestProposalWithdrawal
+ */
 interface CanRequestProposalWithdrawalRetrunItem {
+  /**
+   * Check if need to request  withdrawal for proposer, partner or voter.
+   * @type {boolean}
+   */
   needRequestWithdrawal: boolean;
+  /**
+   * Check if can request  withdrawal for proposer, partner or voter.
+   * @type {boolean}
+   */
   canRequestWithdrawal: boolean;
 }
-type CanClaimProposalWithdrawalParam = CanRequestProposalWithdrawalParam;
+/**
+ * BaseParametersReturnType: Return type for getBaseParameters.
+ */
+interface BaseParametersReturnType {
+  /**
+   * All reviewed proposal WAN amounts.
+   * @type {bigint}
+   */
+  allProposalWanAmount: bigint;
+  /**
+   * All locking WAN amounts.
+   * @type {bigint}
+   */
+  allProposalLockingWanAmount: bigint;
+  /**
+   * All burned WAN amounts.
+   * @type {bigint}
+   */
+  allProposalBurnedWanAmount: bigint;
+  /**
+   * WAN transfer gaslimit
+   * @type {bigint}
+   */
+  ethTransferGasLimit: bigint;
+  /**
+   * Minimum amount of WANs a participant can participate in for funding proposal
+   * @type {bigint}
+   */
+  minParticipationAmount: bigint;
+  /**
+   * Multiplier to request WANs from Wanchain Treasury
+   * @type {bigint}
+   */
+  requestWanMultiplier: bigint;
+  /**
+   * Threshold to succeed proposal
+   * @type {bigint}
+   */
+  succeedThreshold: bigint;
+  /**
+   * Proposal creation require amount of XP
+   * @type {bigint}
+   */
+  requireXpAmount: bigint;
+  /**
+   * Proposer or partner pledge WAN by locking duration
+   * @type {bigint}
+   */
+  pledgeLockDuration: bigint;
+  /**
+   * Duration for partners to pledge their WAN to help a Prospective Proposal meet the pledge requirements.
+   * @type {bigint}
+   */
+  fundraisingDuration: bigint;
+  /**
+   * Duration for voters to vote active proposal
+   * @type {bigint}
+   */
+  voteDuration: bigint;
+  /**
+   * for XP token
+   * @type {bigint}
+   */
+  xp: Address;
+  /**
+   * Address for StakingManager
+   * @type {bigint}
+   */
+  stakingManager: Address;
+  /**
+   * Address for Wanchain community treasury
+   * @type {bigint}
+   */
+  wanTreasury: Address;
+  /**
+   * Address for WAN burned
+   * @type {bigint}
+   */
+  burnAddr: Address;
+  /**
+   * Count for total proposal: include reviewing proposals, canceled proposals, prospective proposals, active proposals, succeeded proposals and failed proposals
+   * @type {bigint}
+   */
+  proposalCount: bigint;
+  /**
+   * Count for reviewing proposals
+   * @type {bigint}
+   */
+  reviewPendingProposalCount: bigint;
+  /**
+   * Count for prospective proposals
+   * @type {bigint}
+   */
+  prospectiveProposalCount: bigint;
+  /**
+   * Count for active(voting) proposals
+   * @type {bigint}
+   */
+  votingProposalCount: bigint;
+  /**
+   * Count for succeeded proposals
+   * @type {bigint}
+   */
+  succeededProposalCount: bigint;
+  /**
+   * Count for rejected proposals
+   * @type {bigint}
+   */
+  failedProposalCount: bigint;
+  /**
+   * Count for canceled proposals
+   * @type {bigint}
+   */
+  canceledProposalCount: bigint;
+  /**
+   * Count of multipliers for proposer and partner
+   * @type {bigint}
+   */
+  proposalWanMultiplierCount: bigint;
+  /**
+   * Count of multipliers for voter
+   * @type {bigint}
+   */
+  votingWanMultiplierCount: bigint;
+}
 //#endregion
 //#region src/abis/WanGovernor.d.ts
 declare const ABI: readonly [{
@@ -2516,41 +2947,69 @@ declare const ABI: readonly [{
 }];
 //#endregion
 //#region src/governance.d.ts
+/**
+ * Wanchain governance
+ * @remarks Providing creation, cancellation, review, contribute, voting, query, etc. proposal API
+ */
+/**
+ * Governance Core Class: Encapsulates Viem's PublicClient and Wanchain governance contract address management
+ * @class SDK
+ * @template TAbi - Contract ABI type, the built-in GOVERNANCE_ABI constant is used by default
+ * @param {Address} governanceAddr - Wanchain governance contract address
+ * @param {Chain} chain - Block chain from Viem's chains(such as wanchain, wanchainTestnet)
+ * @param {string} [rpcUrl] - Optional custom RPC; if not provided, the chain's default RPC is used.
+ * @example
+ * const sdk = new Governance('0x123...', wanchain);
+ * console.log(sdk.governanceAddr); // '0x123...'
+ */
 declare class Governance<TAbi extends Abi = typeof ABI> {
+  readonly publicClient: PublicClient;
+  readonly governanceAddr: Address;
+  readonly governanceAbi: Abi;
   constructor(governanceAddr: Address, chain?: Chain, rpcUrl?: string);
-  getBaseParameters(): Promise<{
-    allProposalWanAmount: bigint;
-    allProposalLockingWanAmount: bigint;
-    allProposalBurnedWanAmount: bigint;
-    ethTransferGasLimit: bigint;
-    minParticipationAmount: bigint;
-    requestWanMultiplier: bigint;
-    succeedThreshold: bigint;
-    requireXpAmount: bigint;
-    pledgeLockDuration: bigint;
-    fundraisingDuration: bigint;
-    voteDuration: bigint;
-    xp: Address;
-    stakingManager: Address;
-    wanTreasury: Address;
-    burnAddr: Address;
-    proposalCount: bigint;
-    reviewPendingProposalCount: bigint;
-    prospectiveProposalCount: bigint;
-    votingProposalCount: bigint;
-    succeededProposalCount: bigint;
-    failedProposalCount: bigint;
-    canceledProposalCount: bigint;
-    proposalWanMultiplierCount: bigint;
-    votingWanMultiplierCount: bigint;
-  }>;
+  /**
+   * Get the basic parameters(return JSON object)
+   * @returns {Promise<BaseParametersReturnType>}
+   * @example
+   * const ret = await sdk.getBaseParameters();
+   * console.log(ret);
+   */
+  getBaseParameters(): Promise<BaseParametersReturnType>;
+  /**
+   * Get the basic parameters(return JSON object)
+   * @param options - Optional parameters
+   * @param options.proposalWanMultiplier - Index range of proposal WAN multipliers
+   * @param options.votingWanMultiplier - Index range of voter WAN multipliers
+   * @returns {Promise<{
+      proposalWanMultipliers: PlegeMultiplierReturn[] | []
+      votingWanMultipliers: PlegeMultiplierReturn[] | []
+    }>}
+   * @example
+   * const ret = await sdk.getProposalMultipliers({proposalWanMultiplier:{start: 0, end: 0}, votingWanMultiplier:{start: 0, end: 0}});
+   * console.log(ret);
+   */
   getProposalMultipliers(options: {
     proposalWanMultiplier: IndexRange | undefined;
     votingWanMultiplier: IndexRange | undefined;
   }): Promise<{
-    proposalWanMultipliers: [PlegeMultiplierReturn] | [];
-    votingWanMultipliers: [PlegeMultiplierReturn] | [];
+    proposalWanMultipliers: PlegeMultiplierReturn[] | [];
+    votingWanMultipliers: PlegeMultiplierReturn[] | [];
   }>;
+  /**
+   * Get proposal counts for all, recviewPending, prospective, voting, succeeded, failed and canceled proposal
+   * @returns {Promise<{
+      allProposalCount: bigint
+      reviewPendingProposalCount: bigint
+      prospectiveProposalCount: bigint
+      votingProposalCount: bigint
+      succeededProposalCount: bigint
+      failedProposalCount: bigint
+      canceledProposalCount: bigint
+    }>}
+   * @example
+   * const ret = await sdk.getProposalCounts();
+   * console.log(ret);
+   */
   getProposalCounts(): Promise<{
     allProposalCount: bigint;
     reviewPendingProposalCount: bigint;
@@ -2560,59 +3019,522 @@ declare class Governance<TAbi extends Abi = typeof ABI> {
     failedProposalCount: bigint;
     canceledProposalCount: bigint;
   }>;
+  /**
+   * Get active proposal counts by category
+   * @returns {Promise<{
+      fundingProposalCount: bigint
+      technicalProposalCount: bigint
+    }>}
+   * @example
+   * const ret = await sdk.getActiveProposalCategoryCounts();
+   * console.log(ret);
+   */
   getActiveProposalCategoryCounts(): Promise<{
     fundingProposalCount: bigint;
     technicalProposalCount: bigint;
   }>;
-  getAssetBalances(xpAddress: Address, userAddress: Address): Promise<{
+  /**
+   * Get  prospective + active proposal counts by category
+   * @returns {Promise<{
+      fundingProposalCount: bigint
+      technicalProposalCount: bigint
+    }>}
+   * @example
+   * const ret = await sdk.getParticipableProposalCategoryCounts();
+   * console.log(ret);
+   */
+  getParticipableProposalCategoryCounts(): Promise<{
+    fundingProposalCount: bigint;
+    technicalProposalCount: bigint;
+  }>;
+  /**
+   * Get WAN and XP balance for identified account
+   * @returns {Promise<{
+      ethBalance: bigint
+      xpBalance: bigint
+    }>}
+   * @example
+   * const xpAddress = '0x123...';
+   * const account = '0x456...';
+   * const ret = await sdk.getAssetBalances(xpAddress, account);
+   * console.log(ret);
+   */
+  getAssetBalances(xpAddress: Address, account: Address): Promise<{
     ethBalance: bigint;
     xpBalance: bigint;
   }>;
+  /**
+   * Get counts proposal count for identified account
+   * @param {Address} account - Account to be queried
+   * @returns {Promise<{
+      proposerProposalCount: bigint,
+      partnerProposalCount: bigint,
+      voterProposalCount: bigint,
+    }>}
+   * @example
+   * const account = '0x456...';
+   * const ret = await sdk.getAccountProposalCount(account);
+   * console.log(ret);
+   */
   getAccountProposalCount(account: Address): Promise<{
     proposerProposalCount: bigint;
     partnerProposalCount: bigint;
     voterProposalCount: bigint;
   }>;
-  getFoundations(): Promise<Address[]>;
+  /**
+   * Get fouondations
+   * @returns {Promise<readonly Address[]>} - Array of foundations
+   * @example
+   * const ret = await sdk.getFoundations(account);
+   * console.log(ret);
+   */
+  getFoundations(): Promise<readonly Address[]>;
+  /**
+   * Caculate proposal ID
+   * @param {Address} account - Account of proposer
+   * @param {bigint} requestWanAmount - Amount of WAN's requested for proposal
+   * @param {ProposalCategory} category - Category of proposal
+   * @param {PledgeType} pledgeType - PledgeType of proposal for proposer
+   * @param {Hex} description - Description of proposal
+   * @returns {Promise<Hex>} - ID of proposal
+   * @example
+   * const account = '0x456...';
+   * const requestWanAmount = 100n;
+   * const category = ProposalCategory.ProposalCategory;
+   * const pledgeType = PledgeType.Burn;
+   * const description = 'request';
+   * const ret = await sdk.getAccountProposalId(account, requestWanAmount, category, pledgeType, description);
+   * console.log(ret);
+   */
   getAccountProposalId(account: Address, requestWanAmount: bigint, category: ProposalCategory, pledgeType: PledgeType, description: Hex): Promise<Hex>;
-  getProposalPartnerAndVoterCounts(proposalId: Hex): Promise<bigint>;
+  /**
+   * Get counts for the proposal partners and voteres
+   * @param {Hex} proposalId - ID of propsal
+   * @returns {Promise<{
+      partnerCount: bigint,
+      voterCount: bigint
+    }>}
+   * @example
+   * const proposalId = '0x456...';
+   * const ret = await sdk.getProposalPartnerAndVoterCounts(proposalId);
+   * console.log(ret);
+   */
+  getProposalPartnerAndVoterCounts(proposalId: Hex): Promise<{
+    partnerCount: bigint;
+    voterCount: bigint;
+  }>;
+  /**
+   * Get multi-proposasl info of proposer
+   * @param {Address} proposerAddr - Proposer address
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} - Multi-info of proposal
+   * @example
+   * const proposerAddr = '0x456...';
+   * const indexRange = {start:0, end: 1};
+   * const ret = await sdk.getProposerProposals(proposerAddr, indexRange);
+   * console.log(ret);
+   */
   getProposerProposals(proposerAddr: Address, indexRange: IndexRange): Promise<ProposalInfo[]>;
+  /**
+   * Get multi-proposasl info of partner
+   * @param {Address} partnerAddr - Partner address
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} - Multi-info of proposal
+   * @example
+   * const partnerAddr = '0x456...';
+   * const indexRange = {start:0, end: 1};
+   * const ret = await sdk.getPartnerProposals(partnerAddr, indexRange);
+   * console.log(ret);
+   */
   getPartnerProposals(partnerAddr: Address, indexRange: IndexRange): Promise<{
     proposalInfo: ProposalInfo;
     partnerInfo: PartnerInfo;
   }[]>;
+  /**
+   * Get multi-proposasl info of voter
+   * @param {Address} voterAddr - Voter address
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} -  Multi-info of proposal
+   * @example
+   * const voterAddr = '0x456...';
+   * const indexRange = {start:0, end: 1};
+   * const ret = await sdk.getPartnerProposals(voterAddr, indexRange);
+   * console.log(ret);
+   */
   getVoterProposals(voterAddr: Address, indexRange: IndexRange): Promise<{
     proposalInfo: ProposalInfo;
     voterInfo: VoterInfo;
   }[]>;
+  /**
+   * Get multi-info of partner
+   * @param {Address} partnerAddr - Partner address
+   * @param {Hex[]} proposalIds - IDs of proposal
+   * @returns {Promise<PartnerInfo[]>} - Multi-info of partner
+   * @example
+   * const partnerAddr = '0x456...';
+   * const proposalIds = ['0x1...','[0x2...]];
+   * const ret = await sdk.getPartnerInfo(partnerAddr, proposalIds);
+   * console.log(ret);
+   */
   getPartnerInfo(partnerAddr: Address, proposalIds: Hex[]): Promise<PartnerInfo[]>;
+  /**
+   * Get multi-info of voter
+   * @param {Address} voterAddr - Voter address
+   * @param {Hex[]} proposalIds - IDs of proposal
+   * @returns {Promise<PartnerInfo[]>} - Multi-info of voter
+   * @example
+   * const voterAddr = '0x456...';
+   * const proposalIds = ['0x1...','[0x2...]];
+   * const ret = await sdk.getVoterInfo(voterAddr, proposalIds);
+   * console.log(ret);
+   */
   getVoterInfo(voterAddr: Address, proposalIds: Hex[]): Promise<VoterInfo[]>;
-  getReviewPendingProposals(indexRange: IndexRange): Promise<ProposalInfo>;
+  /**
+   * Get review pending proposals
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} - Multi-info of proposal
+   * @example
+   * const indexRange = {start:0, end: 5};
+   * const ret = await sdk.getReviewPendingProposals(indexRange);
+   * console.log(ret);
+   */
+  getReviewPendingProposals(indexRange: IndexRange): Promise<ProposalInfo[]>;
+  /**
+   * Get prospective proposals
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} - Multi-info of proposal
+   * @example
+   * const indexRange = {start:0, end: 5};
+   * const ret = await sdk.getProspectiveProposals(indexRange);
+   * console.log(ret);
+   */
   getProspectiveProposals(indexRange: IndexRange): Promise<ProposalInfo[]>;
+  /**
+   * Get active(voting) proposals
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} - Multi-info of proposal
+   * @example
+   * const indexRange = {start:0, end: 5};
+   * const ret = await sdk.getVotingProposals(indexRange);
+   * console.log(ret);
+   */
   getVotingProposals(indexRange: IndexRange): Promise<ProposalInfo[]>;
+  /**
+   * Get succeed proposals
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} - Multi-info of proposal
+   * @example
+   * const indexRange = {start:0, end: 5};
+   * const ret = await sdk.getSucceedProposals(indexRange);
+   * console.log(ret);
+   */
   getSucceedProposals(indexRange: IndexRange): Promise<ProposalInfo[]>;
+  /**
+   * Get failed proposals
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} - Multi-info of proposal
+   * @example
+   * const indexRange = {start:0, end: 5};
+   * const ret = await sdk.getFailedProposals(indexRange);
+   * console.log(ret);
+   */
   getFailedProposals(indexRange: IndexRange): Promise<ProposalInfo[]>;
+  /**
+   * Get canceled proposals
+   * @param {IndexRange} indexRange - Range of index
+   * @returns {Promise<ProposalInfo[]>} - Multi-info of proposal
+   * @example
+   * const indexRange = {start:0, end: 5};
+   * const ret = await sdk.getCanceledProposals(indexRange);
+   * console.log(ret);
+   */
+  getCanceledProposals(indexRange: IndexRange): Promise<ProposalInfo[]>;
+  /**
+   * Get specified proposal info
+   * @param {Hex} proposalId - ID of proposal
+   * @returns {Promise<ProposalInfo>} - Proposal info
+   * @example
+   * const proposalId = '0x12...';
+   * const ret = await sdk.getProposalInfo(proposalId);
+   * console.log(ret);
+   */
   getProposalInfo(proposalId: Hex): Promise<ProposalInfo>;
+  /**
+   * Check whether need or can request proposal withdrawal
+   * @param {bigint} timestamp - Timestamp of latest block
+   * @param {CanRequestProposalWithdrawalParam[]} params - Parameters
+   * @returns {Promise<CanRequestProposalWithdrawalRetrunItem[]>} - Array of {needRequestWithdrawal, canRequestWithdrawal}
+   * @example
+   * var proposalId = '0x12...';
+   * var proposalInfo = await sdk.getProposalInfo(proposalId);
+   * var latestBlock = await sdk.publicClient.getBlock();
+   * var [{needRequestWithdrawal, canRequestWithdrawal}] = sdk.canRequestProposalWithdrawal(latestBlock.timestamp, [
+        {
+          state: proposalInfo.state,
+          pledgeType: proposalInfo.proposerFundInfo.pledgeType,
+          lockDuration: proposalInfo.proposerFundInfo.lockDuration,
+          voteDeadline: proposalInfo.voteDeadline,
+          requestId: proposalInfo.proposerFundInfo.requestId,
+          exited: proposalInfo.proposerFundInfo.exited,
+        }
+      ]);
+   */
   canRequestProposalWithdrawal(timestamp: bigint, params: CanRequestProposalWithdrawalParam[]): CanRequestProposalWithdrawalRetrunItem[];
+  /**
+   * Check whether can claim proposal withdrawal or not
+   * @param {Address} stakingManagerAddr - Address of stakingManager
+   * @param {bigint} timestamp - Timestamp of latest block
+   * @param {CanClaimProposalWithdrawalParam[]} params - Parameters
+   * @returns {Promise<boolean[]>} - Array of boolean
+   * @example
+   * var stakingManagerAddr = '0x34...';
+   * var proposalId = '0x12...';
+   * var proposalInfo = await sdk.getProposalInfo(proposalId);
+   * var latestBlock = await sdk.publicClient.getBlock();
+   * var ret = sdk.canClaimProposalWithdrawal(stakingManagerAddr, latestBlock.timestamp, [
+        {
+          state: proposalInfo.state,
+          pledgeType: proposalInfo.proposerFundInfo.pledgeType,
+          lockDuration: proposalInfo.proposerFundInfo.lockDuration,
+          voteDeadline: proposalInfo.voteDeadline,
+          requestId: proposalInfo.proposerFundInfo.requestId,
+          exited: proposalInfo.proposerFundInfo.exited,
+        }
+      ]);
+   * console.log(ret);
+   */
   canClaimProposalWithdrawal(stakingManagerAddr: Address, timestamp: bigint, params: CanClaimProposalWithdrawalParam[]): Promise<boolean[]>;
-  getUnstakeStatus(stakingManager: Address, requestId: bigint): Promise<UnstakeStatus>;
+  /**
+   * Get unstake status after request proposal withdrawal
+   * @param {Address} stakingManagerAddr - Address of stakingManager
+   * @param {bigint} requestId - ID of proposal request withdrawal to be queried for proposer, partner or voter.
+   * @returns {Promise<UnstakeStatus>} - Status of unstake
+   * @example
+   * var stakingManagerAddr = '0x34...';
+   * var proposalId = '0x12...';
+   * var proposalInfo = await sdk.getProposalInfo(proposalId);
+   * var ret = sdk.getUnstakeStatus(stakingManagerAddr, proposalInfo.proposerFundInfo.requestId);
+   * console.log(ret);
+   */
+  getUnstakeStatus(stakingManagerAddr: Address, requestId: bigint): Promise<UnstakeStatus>;
+  /**
+   * Build transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {ContractFunctionName} functionName - Function name
+   * @param {ContractFunctionArgs} args - Parameters
+   * @param {bigint} value - Amount of WAN
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const functionName = 'cancelProposal' as ContractFunctionName<TAbi, 'nonpayable' | 'payable'>;
+   * const args = [proposalId, reason] as ContractFunctionArgs<TAbi, 'nonpayable' | 'payable'>;
+   * const ret = await sdk.buildTx(account, functionName, args, BigInt(0));
+   * console.log(ret);
+   */
   buildTx<TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'>>(account: Account | Address, functionName: TFunctionName, args: ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>, value?: bigint): Promise<PrepareTransactionRequestReturnType>;
-  _buildTx(account: Address | Account, parameters: EncodeFunctionDataParameters, value?: bigint): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build createProposal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {bigint} pledgeWanAmount - Amount of WAN that proposer pledged
+   * @param {bigint} requestWanAmount - Amount of WAN that proposer request.
+   * @param {ProposalCategory} category - Category of proposal
+   * @param {PledgeType} pledgeType - Pledge type
+   * @param {Hex} description - Description of proposal
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const pledgeWanAmount = parseEther("1");
+   * const requestWanAmount = parseEther("100");
+   * const category = ProposalCategory.Funding;
+   * const pledgeType = PledgeType.Lock;
+   * const ret = await sdk.buildCreateProposalTx(walletClient.account!, pledgeWanAmount, requestWanAmount, category, pledgeType, description);
+   * console.log(ret);
+   */
   buildCreateProposalTx(account: Address | Account, pledgeWanAmount: bigint, requestWanAmount: bigint, category: ProposalCategory, pledgeType: PledgeType, description: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build cancelProposal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @param {Hex} reason - Cancel reason.
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const reason = toHex('cancel');
+   * const ret = await sdk.buildCancelProposalTx(walletClient.account!, proposalId, reason);
+   * console.log(ret);
+   */
   buildCancelProposalTx(account: Address | Account, proposalId: Hex, reason: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build reviewPoposal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @param {boolean} isApproved - For or against.
+   * @param {Hex} reason - Cancel reason.
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const isApproved = true;
+   * const reason = toHex('greate');
+   * const ret = await sdk.buildReviewProposalTx(walletClient.account!, proposalId, isApproved, reason);
+   * console.log(ret);
+   */
   buildReviewProposalTx(account: Address | Account, proposalId: Hex, isApproved: boolean, reason: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build contributePoposal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @param {bigint} pledgeWanAmount - Amount of WAN that partner pledged
+   * @param {PledgeType} pledgeType - Pledge type
+   * @param {Hex} reason - Reason.
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const pledgeWanAmount = parseEther("1");
+   * const pledgeType = PledgeType.Lock;
+   * const reason = toHex('support');
+   * const ret = await sdk.buildContributeProposalTx(walletClient.account!, proposalId, pledgeWanAmount, pledgeType, toHex(reason));
+   * console.log(ret);
+   */
   buildContributeProposalTx(account: Address | Account, proposalId: Hex, pledgeWanAmount: bigint, pledgeType: PledgeType, reason: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build votePoposal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @param {bigint} pledgeWanAmount - Amount of WAN that partner pledged
+   * @param {bigint} lockDuration - Lock duration of proposal for voter
+   * @param {PledgeType} pledgeType - Pledge type
+   * @param {VoteType} voteType - Vote type
+   * @param {Hex} reason - Reason.
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const pledgeWanAmount = parseEther("1");
+   * const lockDuration = 8...;
+   * const pledgeType = PledgeType.Lock;
+   * const voteType = VoteType.For;
+   * const reason = toHex('support');
+   * const ret = await sdk.buildVoteProposalTx(walletClient.account!, proposalId, pledgeWanAmount, lockDuration, pledgeType, voteType, toHex(reason));
+   * console.log(ret);
+   */
   buildVoteProposalTx(account: Address | Account, proposalId: Hex, pledgeWanAmount: bigint, lockDuration: bigint, pledgeType: PledgeType, voteType: VoteType, reason: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build tallyPoposal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const ret = await sdk.buildTallyProposalTx(walletClient.account!, proposalId);
+   * console.log(ret);
+   */
   buildTallyProposalTx(account: Address | Account, proposalId: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build requestProposerWithdrawal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const ret = await sdk.buildRequestProposerWithdrawalTx(walletClient.account!, proposalId);
+   * console.log(ret);
+   */
   buildRequestProposerWithdrawalTx(account: Address | Account, proposalId: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build claimProposerWithdrawal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @param {bigint} requestId - ID of proposal request withdrawal to be queried
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const requestId = 34...n;
+   * const ret = await sdk.buildClaimProposerWithdrawalTx(walletClient.account!, proposalId, requestId);
+   * console.log(ret);
+   */
   buildClaimProposerWithdrawalTx(account: Address | Account, proposalId: Hex, requestId: bigint): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build requestPartnerWithdrawal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const ret = await sdk.buildRequestPartnerWithdrawalTx(walletClient.account!, proposalId);
+   * console.log(ret);
+   */
   buildRequestPartnerWithdrawalTx(account: Address | Account, proposalId: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build claimPartnerWithdrawal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @param {bigint} requestId - ID of proposal request withdrawal to be queried
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const requestId = 34...n;
+   * const ret = await sdk.buildClaimPartnerWithdrawalTx(walletClient.account!, proposalId, requestId);
+   * console.log(ret);
+   */
   buildClaimPartnerWithdrawalTx(account: Address | Account, proposalId: Hex, requestId: bigint): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build requestVoterWithdrawal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const ret = await sdk.buildRequestVoterWithdrawalTx(walletClient.account!, proposalId);
+   * console.log(ret);
+   */
   buildRequestVoterWithdrawalTx(account: Address | Account, proposalId: Hex): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build claimVoterWithdrawal transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {Hex} proposalId - ID of proposal
+   * @param {bigint} requestId - ID of proposal request withdrawal to be queried
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const proposalId = '0x12...';
+   * const requestId = 34...n;
+   * const ret = await sdk.buildClaimVoterWithdrawalTx(walletClient.account!, proposalId, requestId);
+   * console.log(ret);
+   */
   buildClaimVoterWithdrawalTx(account: Address | Account, proposalId: Hex, requestId: bigint): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build updateFundraisingDuration transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {bigint} fundraisingDuration - Fundraising duration
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const fundraisingDuration = 34...n;
+   * const ret = await sdk.buildUpdateFundraisingDurationTx(walletClient.account!, fundraisingDuration);
+   * console.log(ret);
+   */
   buildUpdateFundraisingDurationTx(account: Address | Account, fundraisingDuration: bigint): Promise<PrepareTransactionRequestReturnType>;
+  /**
+   * Build updateMinParticipationAmount transaction
+   * @param {Account | Address} account - Account | Address of sender
+   * @param {bigint} amount - Minimum amount of WANs a participant can participate in proposal
+   * @returns {Promise<PrepareTransactionRequestReturnType>} - Transaction
+   * @example
+   * const walletClient = createWalletClient({ account: privateKeyToAccount(`0x${process.env.PK}`), chain: sdk.publicClient.chain, transport: http() });
+   * const amount = 34...n;
+   * const ret = await sdk.buildUpdateMinParticipationAmountTx(walletClient.account!, amount);
+   * console.log(ret);
+   */
   buildUpdateMinParticipationAmountTx(account: Address | Account, amount: bigint): Promise<PrepareTransactionRequestReturnType>;
 }
 //#endregion
-export { type CanClaimProposalWithdrawalParam, type CanRequestProposalWithdrawalParam, type CanRequestProposalWithdrawalRetrunItem, type FundInfo, Governance, type IndexRange, type PartnerInfo, PledgeType, type PlegeMultiplierReturn, ProposalCategory, type ProposalInfo, ProposalRole, ProposalState, type Tally, UnstakeStatus, VoteType, type VoterInfo, decodeProposalDescriptionData, encodeProposalDescriptionData, getVersionFromData, supportedProposalDescriptionDataTypeSchema };
+export { type CanClaimProposalWithdrawalParam, type CanRequestProposalWithdrawalParam, type CanRequestProposalWithdrawalRetrunItem, type FundInfo, Governance, type IndexRange, type PartnerInfo, PledgeType, type PlegeMultiplierReturn, ProposalCategory, ProposalDescriptionData, type ProposalInfo, ProposalRole, ProposalState, type Tally, UnstakeStatus, ValidVersion, VoteType, type VoterInfo, decodeProposalDescriptionData, encodeProposalDescriptionData, getVersionFromData, supportedProposalDescriptionDataTypeSchema };
 //# sourceMappingURL=index.d.mts.map