DeXe DAO governance

Description is built at runtime.

Read-only, local. Decodes '0x…' calldata against the DeXe Protocol ABIs (bundled; a local compile wins) — only `contract`'s when given, else every match.

Read-only. Fetches a GovPool proposal via `getProposals(offset, limit)` and decodes its for/against actions.

Returns why dexe-mcp failed to start and how to fix it. The server is running in degraded mode — this is the only tool available until the cause is fixed and the host restarted.

Read-only, local. Maps a 4-byte selector or 32-byte event topic to every matching contract and signature in the compiled codebase; collisions included.

Read-only, local. Contract ABI JSON from the local compile output; run dexe_compile (needs DEXE_TOOLSETS=core,dev) once per session first. Narrow with `kind`/`nameFilter` (GovPool ABI ~21.8k chars).

Read-only, local. The resolved read config: chain set and default chain, subgraph coverage per chain, the backend API and the IPFS read gateways.

Read-only, local. Per-function metadata split into read (view/pure) and write (nonpayable/payable), with canonical signatures, 4-byte selectors and `internalType` kept for tuples.

Read-only, local. devdoc/userdoc from build-info; optionally scoped to one member.

Read-only, local. Function/event/error selectors from the local compile output; run dexe_compile (needs DEXE_TOOLSETS=core,dev) once per session first.

Read-only, local. Source file path for a contract; optionally slices around a symbol via a naive regex scan.

Builds calldata; does not broadcast. `Governor.cancel`. OZ v4+: pass targets/values/calldatas + description or descriptionHash. Bravo: pass proposalId only.

Builds calldata; does not broadcast. `IVotes.delegate` — `to` is the voting token, NOT the Governor. The zero address revokes the delegation.

Builds calldata; does not broadcast. `Governor.execute`. OZ v4+: pass targets/values/calldatas plus description or descriptionHash. Bravo: pass proposalId only.

Builds calldata; does not broadcast. `Governor.propose`: OZ v4+ takes (targets, values, calldatas, description), Bravo takes (targets, values, signatures, calldatas, description) and defaults signatures to empty strings.

Builds calldata; does not broadcast. `Governor.queue`. OZ v4+: pass targets/values/calldatas plus description (hashed for you) or descriptionHash. Bravo: pass proposalId only.

Builds calldata; does not broadcast. `Governor.castVote`, or `castVoteWithReason` when `reason` is set. Identical signature on OZ and Bravo.

Read-only, local. Parses 0x-hex calldata against the configured Governor's write ABI (family-aware) into {method, args} — audit a tx before signing, or round-trip a dexe_gov_build_* payload.

Read-only. ProposalState (name + enum index), snapshot block, deadline block and proposalVotes (for/against/abstain) for one proposal on a configured Governor.

Read-only. `Governor.proposalThreshold()` — the voting power needed to submit a proposal. Returns the live uint256 plus the bundled config value, and whether they still agree.

Read-only. Quorum threshold at a snapshot block (latest when omitted). Bravo (UNI/COMP) reads fixed quorumVotes(); vanilla OZ reads quorum(blockNumber); OP-style governors, whose quorum() is keyed by proposalId, use votableSupply(block) * quorumNumerator/quorumDenominator. `method` reports the path taken, `configured` echoes the numerator/denominator to cross-check.

Read-only. `Governor.state(proposalId)` as {index, name} — one eth_call when the state is all you need.

Read-only. `IVotes.getPastVotes(account, blockNumber)` on the Governor's voting token, or `getVotes(account)` when blockNumber is omitted. Raw wei plus the token's decimals.

Read-only. Whether the account already voted. OZ reads hasVoted(proposalId, account); Bravo has no hasVoted, so it reads getReceipt(proposalId, voter).hasVoted.

Read-only, local. keccak256(toUtf8Bytes(description)) — the 32-byte descriptionHash OZ queue/execute/cancel take.

Read-only. OZ v4+ only: `Governor.hashProposal` gives the deterministic proposalId for a (targets, values, calldatas, descriptionHash) tuple before submission. Bravo has no hashProposal and is refused with that reason.

Read-only, local. Every bundled external-Governor config: its chain, governor address, voting token, voting params and timelock. A static snapshot — a DAO can change its params by proposal.

Read-only. eth_call dry-run of Governor.execute() (Bravo: proposalId; OZ: targets/values/calldatas + description or hash), returning {success, revertReason, decodedCall, currentState}. Single-block only, not a fork-and-time-warp: a Queued proposal whose timelock ETA has not elapsed reverts with the timelock error.

Read-only. Reads the live tallies + quorum and projects the outcome if `weight` of voting power were cast with `support`. Returns currentTallies, projectedTallies, quorumMet, willPass. Quorum counting follows the governor's COUNTING_MODE (`quorum.counting`): Bravo and CompoundGovernor count For only, vanilla OZ counts For+Abstain, Optimism counts all three. `willPass` ignores any per-proposal-type approvalThreshold or voting module — see `caveats` when present.

Description is built at runtime.

Description is built at runtime.

Description is built at runtime.

Read-only, local. Hashes a JSON value offline, pinning NOTHING — content stays unfetchable until you upload it. `pinataCid` is the dag-pb CIDv0 a real Pinata upload returns: use it wherever a CID goes on-chain. `cid` is the json-codec CIDv1.

Read-only, local. Parses a CIDv0/v1, reports codec + multihash, converts v0↔v1 when legal, and emits a URL per configured gateway.

Read-only. Fetches IPFS content by CID through the server's gateway chain: its dedicated gateway first when it has one, then the configured or public fallbacks.

Writes to a remote service. Fetches the current DAO metadata from IPFS, applies only `overrides`, re-pins the merge (omitted fields kept) and returns the new outer `descriptionURL`.

Writes to a remote service. Pins an image, returning {avatarCID, avatarFileName, avatarUrl}. PREFER `filePath`; never pass base64 through the conversation. Magic-byte validated (JPEG/PNG/WebP/GIF only — SVG/HTML render broken on app.dexe.io); renamed `.jpeg`; CID v1 base32.

Writes to a remote service. Pins DAO metadata in the frontend's nested shape (description pin + outer wrapper); returns the outer CID for `descriptionURL` in `deployGovPool`.

Writes to a remote service. Pins a file to IPFS; PREFER `filePath` over base64. Returns CID v1 (base32) + filename. Images are magic-byte gated to rasters and renamed `.jpeg` unless `normalizeImageExt: false`.

Writes to a remote service. Pins `{proposalName, proposalDescription}` to IPFS via Pinata; returns the CID for `descriptionURL` in `GovPool.createProposal`.

Runs locally and writes artifacts. `npm run lint-fix` with `fix: true` (solhint/eslint/jsonlint), else `npm run lint-check`.

Read-only, local. Lists the compiled DeXe-Protocol contracts; filter by name substring and/or kind.

Read-only, local. Catalog of the DeXe governance contracts: what each does and where its source lives.

Read-only, local. Builds an OpenZeppelin StandardMerkleTree (what DeXe token-sale whitelists verify). Default leaf is one address; `leafEncoding` + `entries` for richer leaves.

Read-only, local. Same tree, but returns the proof for one target — buyer-side flows needing a single proof. Default shape: address-only.

Builds an HTTP request; does not send it. DELETE /integrations/voting/vote/{proposalId}/{voterAddress}, no body. Needs a backend access_token: call dexe_auth_login first.

Builds an HTTP request; does not send it. POST /integrations/voting/vote. `options` holds the selected option strings — one for one_of, one or more for multiple_of. Needs a backend access_token: call dexe_auth_login first.

Broadcasts when a signer is configured. Preflights balance + allowance, adds an ERC20 approve when needed, then builds `TokenSaleProposal.buy(tierId, paymentToken, amount, proof)`. Native path (0x000...000) skips approve and sets `value`; `whitelistUsers` generates the proof.

Broadcasts when a signer is configured. Reads `getUserViews(user, tierIds)` and sends `claim` for tiers with `claimableAmount > 0`. Tiers whose only balance is the VESTED leg are reported under `vestingBlocked` and NOT sent — `vestingWithdraw` is refused by the pool's firewall (upstream defect F15); `includeVesting: true` tries anyway.

Broadcasts when a signer is configured. Proposes a multi-tier token sale on an OTC DAO: builds the `createTiers` envelope (deduped approves, auto-merkle, auto-addToWhitelist, merkle lists pinned to IPFS so buyers can regenerate proofs), then runs the proposal_create flow (approve, deposit, IPFS metadata, `createProposalAndVote`). DAOs from `dexe_dao_create` (v0.19+) already wire TokenSaleProposal as an executor; older ones need a `new_proposal_type` proposal first.

Builds proposal actions; does not broadcast. ExpertNft.mint(nominatedUser, uri); scope 'local' = the DAO's ExpertNft, 'global' = DeXeExpertNft.

Builds proposal actions; does not broadcast. ERC20.transfer when `treasuryBalance` covers `amount`, else the balance plus ERC20Gov.mint for the shortfall. When an RPC is reachable for the target chain (the built-in public RPC counts) the receiver is checked against isBlacklisted; build aborts if blacklisted.

Builds proposal actions; does not broadcast. One ERC20Gov.blacklist(add, true) action and/or one blacklist(remove, false); an empty array skips either.

Builds proposal actions; does not broadcast. GovPool.changeVotePower(newVotePower): a deployed power contract (LINEAR_POWER, POLYNOMIAL_POWER, or a custom one).

Builds calldata; does not broadcast. `data` for GovValidators.createInternalProposal(type=1) — changeBalances(balances, users); balance 0 removes a validator.

Builds calldata; does not broadcast. `data` for GovValidators.createInternalProposal(type=0) — changeSettings(duration, executionDelay, quorum).

Builds proposal actions; does not broadcast. GovSettings.editSettings(ids, params) when `settingsIds` are supplied, else GovSettings.addSettings(params) — a new settings slot.

Builds proposal actions; does not broadcast. StakingProposal.createStaking(rewardToken, rewardAmount, startedAt, deadline, metadata); ERC20 rewards get a prepended approve, isNative sets the action value.

Builds calldata; does not broadcast. Encodes one ProposalAction {executor, value, data} from a function signature + args, for `actionsOnFor` of dexe_proposal_build_external.

Builds proposal actions; does not broadcast. GovPool.delegateTreasury(delegatee, amount, nftIds) — the DAO TREASURY's power, not yours; the delegatee must already have expert status (GovPool.getExpertStatus).

Builds calldata; does not broadcast. GovPool.createProposal(descriptionURL, actionsOnFor, actionsOnAgainst), or createProposalAndVote when andVote=true.

Description is built at runtime.

Builds proposal actions; does not broadcast. GovValidators.changeBalances(balances, users) — balance 0 removes a validator, >0 adds or updates.

Builds proposal actions; does not broadcast. GovPool.editDescriptionURL(url) — upload the new DAO metadata JSON to IPFS first and pass its ipfs://<cid>.

Builds calldata; does not broadcast. `data` for GovValidators.createInternalProposal(type=2) — monthlyWithdraw(tokens, amounts, destination).

Builds proposal actions; does not broadcast. GovSettings.addSettings([newSettings]) + changeExecutors(executors, [newSettingId]); also the path for enabling staking.

Builds an HTTP request; does not send it. Returns method/url/headers/body for POSTing an off-chain proposal to the DeXe backend — you send it. Backend defaults to api.dexe.io; override with DEXE_BACKEND_API_URL.

Builds an HTTP request; does not send it. DISABLED (F22): the DeXe backend has no for_against creation path and 400s every such request — the web app offers only one_of and multiple_of. Use dexe_proposal_build_offchain_single_option with options ['For','Against']. Kept only to return that guidance.

Builds calldata; does not broadcast. `data` for GovValidators.createInternalProposal(type=3): empty (0x) per contract rule; descriptionURL carries it.

Builds an HTTP request; does not send it. POST /integrations/voting/proposals with voting_type='multiple_of' — the voter picks any subset of `voteOptions`. Needs a backend access_token: call dexe_auth_login first.

Builds an HTTP request; does not send it. POST /integrations/voting/proposals with attributes.type='edit_proposal_type' (change the DAO-wide off-chain settings) or 'create_proposal_type' (save a reusable template). Needs a backend access_token: call dexe_auth_login first.

Builds an HTTP request; does not send it. POST /integrations/voting/proposals with voting_type='one_of' — the voter picks exactly one of `voteOptions`. Needs a backend access_token: call dexe_auth_login first.

Builds proposal actions; does not broadcast. ExpertNft.burn(nominatedUser); scope 'local' = the DAO's ExpertNft, 'global' = DeXeExpertNft.

Builds proposal actions; does not broadcast. GovPool.undelegateTreasury(delegatee, amount, nftIds) — pulls back power delegated from the DAO TREASURY, not yours.

Builds proposal actions; does not broadcast. set_address sets GovPool.setNftMultiplierAddress (ZERO disables); the other modes call ERC721Multiplier.setTokenURI / mint(to, multiplier, duration, uri_) / changeToken. Mint is onlyOwner: pass `govPool` so a contract the GovPool does not own is refused up-front.

Builds proposal actions; does not broadcast. DistributionProposal.execute(proposalId, token, amount); ERC20 gets a prepended approve, isNative sets the action value.

Builds proposal actions; does not broadcast. Single-tier TokenSaleProposal.createTiers. Multi-tier or merkle whitelists: dexe_proposal_build_token_sale_multi.

Builds proposal actions; does not broadcast. TokenSaleProposal.createTiers for one or more tiers, each with zero or more participation requirements. ERC20 approves are summed per sale token; plain Whitelist tiers with users also get addToWhitelist.

Builds proposal actions; does not broadcast. TokenSaleProposal.recover(tierIds) for unsold tokens. Or skip this tool: dexe_proposal_create with proposalType:'token_sale_recover' and params {tokenSaleProposal, tierIds}.

Builds proposal actions; does not broadcast. TokenSaleProposal.addToWhitelist([{tierId, users, uri}, ...]) extends a live tier. Plain Whitelist tiers only; merkle tiers are gated by their root.

Builds proposal actions; does not broadcast. ERC20.transfer(recipient, amount), or a native value transfer when isNative=true. When an RPC is reachable for the target chain (the built-in public RPC counts) and the token is ERC20Gov, the recipient is checked against isBlacklisted; build aborts if blacklisted.

Builds proposal actions; does not broadcast. One ERC20.transfer per token and/or one ERC721.transferFrom(govPool → receiver) per NFT. When an RPC is reachable for the target chain (the built-in public RPC counts) and `token` is ERC20Gov, the receiver is checked against isBlacklisted; build aborts if blacklisted.

Read-only, local. Every proposal type DeXe supports (external, internal validator, off-chain) with target, IPFS-metadata need, gating and builder tool.

Broadcasts when a signer is configured. Creates ANY governance proposal in ONE call: runs approve→deposit→createProposalAndVote and uploads correct IPFS metadata (category/isMeta/changes). Without a signer it returns ordered TxPayloads + a WalletConnect QR.\nPass `proposalType` — the enum lists every wired type — with its inputs in `params`:\n• 'custom': your own actionsOnFor [{executor,value,data}]. 'modify_dao_profile' reads the top-level newDaoName/newDaoDescription/newWebsiteUrl/newSocialLinks/newAvatarPath fields, not `params`.\n• External: token_transfer {token,recipient,amount,isNative?…

Read-only. Reads the latest 10 proposals on a DAO and their final states and forecasts the pass-rate over DECIDED proposals (still-voting ones are `pending`, never failures), with the average For-vote weight. `quorum.requiredWeight` is an ABSOLUTE vote weight (getTotalPower x quorum / 1e27), not the 1e25 percentage setting. The history cross-check needs a pools subgraph for the chain being forecast; a chain with none is forecast on-chain only (`subgraphHistory: null`, `subgraphNote` says why) — never from another chain's index. `indexedChainId` reports whose index was used (null = none).

Read-only. Calls `GovPool.getProposals(offset, limit)` and adds quorum progress per proposal. Quorum is per-side — either For or Against clearing the target reaches it; `requiredQuorum` is an ABSOLUTE vote weight, not a percentage.

Read-only. Assesses low-quorum treasury risk and privileged no-value governance calls (blacklist, pause, changeVotePower, add/editSettings, changeExecutors, changeBalances). SAFE means 'no risk of the kinds this tool classifies', never 'this proposal is safe'.

Read-only. Reads `getProposalState`, `getProposalRequiredQuorum` and the proposal's votes in one multicall. `requiredQuorum` is an ABSOLUTE vote weight, not a percentage; quorum is per-side — either For or Against clearing it reaches quorum.

Broadcasts when a signer is configured. The ONE call for 'vote on / pass / execute proposal N': checks proposal state, AUTO-DEPOSITS wallet tokens when voting power is short (approve UserKeeper → deposit → vote, the frontend's bundled shape), and with autoExecute executes once the vote passes. Without a signer it returns ordered TxPayloads + a WalletConnect QR. Unsure of the lifecycle (validator round, locked tokens)? Call dexe_guide (flow:'vote_execute') first.

Read-only. Paginated voter list for one proposal from the pools subgraph (`proposalInteractions`). `chainId` picks the chain and the reply reports `indexedChainId`; a chain with no pools endpoint errors rather than answering from another index.

Description is built at runtime.

Description is built at runtime.

Description is built at runtime.

Read-only. Time series of DAO stats (tvl_usd, member counts, proposal counts, delegations) from the DeXe tracker. `period` is a human duration like '24 hours', '7 days', '1 months'. Backend-only — mainnets.

Description is built at runtime.

Read-only. Per proposal id, reads `isClaimed(proposalId, voter)` and `getPotentialReward(proposalId, voter)` on a DistributionProposal.

Read-only. Reads `GovPool.getExpertStatus(user)` and, when the DAO has a BABT contract, `BABT.balanceOf(user) > 0`.

Read-only. Reads `getHelperContracts()` and `getNftContracts()` on a GovPool.

Read-only. N independent view calls in one Multicall3 round-trip; each supplies its own ABI signature fragment, target, method and args.

Read-only. NFTs owned by any address via the DeXe backend (Moralis-backed). Backend-only — mainnets, not testnet 97.

Read-only. Reads `UserRegistry.documentHash()` and `agreed(user)` — the current policy hash and whether the user agreed.

Read-only. The app.dexe.io landing numbers: TVL across ALL DAOs (aggregated over `chainIds`), proposals created, DAO count, voting-locked token value, 24h change percents, a TVL series, and optionally the top-N DAOs by TVL. Backend-only — mainnets (1, 56).

Read-only. Reads `GovSettings.getDefaultSettings()` and `getInternalSettings()` for the DAO at `govPool` — quorum, duration, executionDelay, minVotesForCreating/Voting.

Read-only. Reads `stakingsCount()` and `getActiveStakings()` on a StakingProposal — pass its address, or a `govPool` to resolve it via GovUserKeeper.stakingProposalAddress(). With `user`, also reads `getUserInfo(user)`.

Read-only. Holders + raw balances for any ERC20 from the DeXe backend, balance desc, one page per call (see `pageToken`). Mainnets only (1, 56).

Read-only. Tier params + user state across N tiers: purchasable status, claimable amount, vesting withdrawable, lockup ETA, totalSold, merkle root. `whitelists` adds the user's proof, making `canParticipate` accurate for gated tiers.

Read-only. Reads `latestTierId()` and `getTierViews(offset, limit)` on a TokenSaleProposal.

Read-only. Reads `getUserViews(user, tierIds)` on a TokenSaleProposal — per-tier purchase status, claimable amounts, vesting info.

Description is built at runtime.

Read-only. Treasury / wallet balances for any address; pass a GovPool address for a DAO treasury. Auto-discovers EVERY token via the DeXe backend with USD prices and a total. Falls back to an on-chain read (chain 97, explicit `tokens`, or a backend failure) — no token discovery there, and it reports `degraded: true`.

Description is built at runtime.

Description is built at runtime.

Read-only. Reads `validatorsCount()` and optionally `isValidator(candidate)` on the DAO's GovValidators, plus the validators' monthly credit lines (GovPool.getCreditInfo) — an internal monthly_withdraw against an unfunded line reverts.

Read-only. Live Safe state (nonce, threshold, owners, singleton version), the Safe Transaction Service endpoint a propose would POST to, and whether the DEXE_PRIVATE_KEY signer is a Safe owner.

Broadcasts when a signer is configured. Queues a tx in the Safe Transaction Service for the owners to co-sign and execute. Takes a TxPayload, reads the Safe's next nonce on-chain (unless `nonce` is given), computes the EIP-712 `safeTxHash`. **dryRun defaults to true and is UNSIGNED** — payload, safeTxHash and POST target only, no signature. dryRun=false signs with the configured signer, which must be a Safe owner (keystore mode: after the owner approves the exact SafeTx — awaiting_approval until then; re-run the same call) and POSTs (api.safe.global needs DEXE_SAFE_API_KEY); sign=true returns …

Read-only. Simulates TokenSaleProposal.buy(tierId, paymentToken, amount, proof). Native path (0x0) sets value = amount; ERC20 path reads allowance and flags `willNeedApprove` when it is below `amount`.

Read-only. Preflights any tx via eth_call against live state: success / revertReason / gasEstimate, no gas spent. Decodes Error(string) and Panic(uint256) payloads.

Read-only. Simulates GovPool.execute(proposalId) against live state; refuses unless the proposal is `SucceededFor` (idx 4). Finds a reverting action before you pay gas.

Runs locally and writes artifacts. `npx hardhat test` in DEXE_PROTOCOL_PATH; pass/fail counts plus up to 20 failure bodies.

Read-only. Status + landed tx hashes of a keystore approval (`awaiting_approval`). Cannot approve; only the owner can, on the page.

Broadcasts when a signer is configured. Sends the TxPayload fields from any dexe_*_build_* tool and waits for confirmation. Pass `chainId` when several chains are configured, plus the payload's own chainId as `payloadChainId` — a mismatch REFUSES the send. Calldata with a privileged GovUserKeeper accounting selector is refused (hard block, no override).

Read-only. Receipt/status for a submitted tx hash (pending vs not_found). A broadcast timeout is not a failure — the tx may still confirm; re-check here.

Description is built at runtime.

Builds calldata; does not broadcast. `GovPool.cancelVote(proposalId)` — removes your weight from the tally so you can re-vote. This can drop the proposal back below quorum.

Builds calldata; does not broadcast. `GovPool.claimMicropoolRewards(proposalIds, delegator, delegatee)` — the delegator collects their share of the rewards their delegatee's votes earned.

Builds calldata; does not broadcast. `GovPool.claimRewards(proposalIds, user)` — claims creation/voting rewards. Reverts "Gov: proposal is not executed" unless every id is executed, and "Gov: rewards are off" when that settings slot has no reward token. Pass proposalId 0 to sweep the off-chain reward balance.

Builds calldata; does not broadcast. Emits `GovPool.multicall([delegate(delegatee, amount, nftIds)])` — the single-element multicall the frontend sends, because SphereX-protected pools revert a raw top-level delegate(). Delegates YOUR staked power; for DAO treasury delegation use dexe_proposal_build_delegate_to_expert (needs DEXE_TOOLSETS=core,proposals).

Builds calldata; does not broadcast. `GovPool.deposit(amount, nftIds)` — stakes into the DAO to gain voting power. Payable: native-coin DAOs pass `value`; ERC20 DAOs pass value=0 and need the GovUserKeeper approve first.

Builds calldata; does not broadcast. `DistributionProposal.claim(voter, proposalIds)` — the voter's proportional share of executed distribution proposals.

Builds calldata; does not broadcast. `ERC20.approve(spender, amount)`. Run it before dexe_vote_build_deposit when staking an ERC20: approve the DAO's GovUserKeeper (dexe_dao_info), never the GovPool. Native-coin staking needs no approve — pass `value` on deposit instead.

Builds calldata; does not broadcast. `GovPool.execute(proposalId)`; scope:'internal' + govValidators builds `GovValidators.executeInternalProposal(proposalId)` (anyone may send once Succeeded). When an action calls GovSettings.addSettings the response carries an advisory naming the chains where the proposal passes the vote and then reverts here — read it before signing.

Builds calldata; does not broadcast. `GovPool.moveProposalToValidators(proposalId)` — hands a passed proposal to the validator chamber. Only valid in state WaitingForVotingTransfer, and only a BABT holder may send it when the DAO sets onlyBABTHolders.

Builds calldata; does not broadcast. `GovPool.multicall(calls)` — wraps N inner calldatas. Pass the `data` fields of other build tools (deposit + delegate, execute + claim). Every inner call runs against GovPool itself, so only GovPool methods belong here.

Builds calldata; does not broadcast. `ERC721Multiplier.lock(tokenId)` — applies the reward-multiplier NFT's bonus to your voting power.

Builds calldata; does not broadcast. `ERC721Multiplier.unlock()` — returns the locked NFT and removes its voting-power bonus.

Builds calldata; does not broadcast. `UserRegistry.agreeToPrivacyPolicy(signature)` — pass the EIP712 signature from dexe_vote_build_privacy_policy_sign. With `profileURL` it calls changeProfileAndAgreeToPrivacyPolicy instead.

Read-only, local. Returns the EIP712 typed data to sign before `agreeToPrivacyPolicy`. Sign it with the wallet's signTypedData, then pass the signature to dexe_vote_build_privacy_policy_agree. One-time per user, not per DAO.

Builds calldata; does not broadcast. `StakingProposal.claim(id)` — claims a tier's accumulated rewards without unstaking.

Builds calldata; does not broadcast. `StakingProposal.claimAll()` — claims rewards from every active tier in one tx.

Builds calldata; does not broadcast. `StakingProposal.reclaim(id)` — withdraws the staked tokens and any pending rewards from a tier.

Builds calldata; does not broadcast. `GovUserKeeper.stakeTokens(tierId, amount)` — stakes into a tier to earn rewards. Target is GovUserKeeper, not StakingProposal.

Builds calldata; does not broadcast. `TokenSaleProposal.buy(tierId, tokenToBuyWith, amount, proof)`. For native-coin purchases pass ETHEREUM_ADDRESS (0xEeee…EEeE) as `tokenToBuyWith`; `value` is auto-set to `amount` when left at 0 (the contract requires msg.value == amount). Whitelisted tiers need the Merkle `proof`.

Builds calldata; does not broadcast. `TokenSaleProposal.claim(tierIds)`. Call after the tier's claim lock duration has passed.

Builds calldata; does not broadcast. `TokenSaleProposal.vestingWithdraw(tierIds)` — withdraws the unlocked portion of a vesting tier. The on-chain firewall refuses this call in every shape on current pools, stranding the vested allocation; the payload is still returned (older pools work) with the defect reported alongside it.

Builds calldata; does not broadcast. `GovPool.undelegate(delegatee, amount, nftIds)` — pulls back power you delegated. The delegatee's live votes are recomputed downward, and a delegate and an undelegate in the same block revert. On chain 97 it reverts while the delegatee has votes on record; the reply then carries the unlock call to send first.

Builds calldata; does not broadcast. `GovValidators.cancelVote{Internal,External}Proposal(proposalId)`. The on-chain firewall refuses this call on fresh (SphereX-era) pools and GovValidators has no multicall to wrap it in, so there is no workaround — an upstream defect, reported with every payload.

Builds calldata; does not broadcast. `GovValidators.vote{Internal,External}Proposal(proposalId, amount, isVoteFor)`. Arg order differs from GovPool.vote — amount comes before isVoteFor. Requires validator stake.

Builds calldata; does not broadcast. Emits `GovPool.multicall([vote(proposalId, isVoteFor, amount, nftIds)])` — the single-element multicall the frontend sends, because SphereX-protected pools revert a raw top-level vote(). Needs staked or delegated power first (dexe_vote_build_deposit).

Builds calldata; does not broadcast. `GovPool.withdraw(receiver, amount, nftIds)` — unstakes deposited governance tokens. Tokens you voted with stay locked until that proposal is executed.

Read-only. Reads `GovPool.getUserVotes(proposalId, voter, voteType)` and returns the VoteInfoView. Defaults to PersonalVote.

Read-only. Reads `tokenBalance` and `nftBalance` on GovUserKeeper for every VoteType (Personal/Micropool/Delegated/Treasury) in one multicall. tokenBalance includes the un-deposited wallet balance; deposited power = tokenBalance - tokenOwned.

Writes to a remote service. Starts a WalletConnect session and renders a scannable QR (ASCII + PNG). RECOMMENDED signer — the phone signs and broadcasts, so no private key touches this machine. Poll dexe_wc_status until `connected`. In DEXE_SIGNER_MODE=unattended a hot key signs instead.

Writes to a remote service. Tears down the active WalletConnect session; safe when not connected.

Read-only. WalletConnect config plus live session state (connected?, account, chain, topic, peer wallet, last error). It dispatches transactions in DEXE_SIGNER_MODE=walletconnect (the default).

Read-only. Write posture for this session — the signer mode + address (WalletConnect, keystore, hot key or none), the agent KEYRING (signerKey, address, gas, 24h broadcasts per persona), Pinata / WalletConnect / Safe readiness, the signer's deposited power in the newest recorded DAO, and a write journey a prior session left unfinished. Chains, env readiness and recorded DAOs are dexe_context.