DeXe DAO governance

Read-only. Session orientation — configured chains and the default, env readiness (RPC/IPFS/subgraph/backend), which toolsets are on or hidden and what the hidden ones unlock, and the DAOs/proposals recorded in this install's local state. Pass `user` to add that wallet's deposited power in the newest recorded DAO. Not needed once the DAO and chain are known. Persisted DAOs/proposals are WINDOWED; the *Total fields carry real counts.

Broadcasts when a signer is configured. Deploys a new DeXe DAO in ONE call. SIMPLE mode (recommended): pass `symbol` + `totalSupply` and the tool synthesizes a coherent, frontend-equivalent config (LINEAR power, treasury as an implicit remainder, a quorum that passes on realistic turnout). ADVANCED mode: pass a full `params` struct. Returns a `preview` of the resolved config + a safety proof and broadcasts only with `confirm: true`. Runs the frontend's governance coherence guards over ALL FIVE settings slots (default / internal / validators / distribution / tokenSale) — one un-passable slot bricks that whole proposal class forever — plus a calldata round-trip self-check and a pre-sign eth_call: a provable revert is refused with a classified cause + fix BEFORE any gas is spent, while an RPC outage only downgrades to a warning. Mainnet (56) always needs `confirm: true` (real BNB); validate on testnet (97) first. `deployer` defaults to the signer. Unsure of the journey or params? Call dexe_guide (flow:'create_dao').

Writes to a remote service. Renders a real JPEG of the DAO's initials over a hash-coloured gradient and pins it, returning {avatarCID, avatarFileName, avatarUrl}. Deterministic.

Read-only. One multicall on a GovPool: helper addresses, NFT contract addresses, description URL, and live validator count.

Read-only. Calls `PoolFactory.predictGovAddresses(deployer, poolName)` — the six CREATE2-predicted contract addresses for a DAO before it is deployed.

Read-only. Calls `PoolRegistry.isGovPool(address)` — true when the address is a registered DeXe DAO GovPool.

Read-only. The whole picture of one DAO in one call — every section named by `sections` (default all), plus everything with a DEADLINE: open votes, executable proposals and, with `user`, unvoted proposals and claimable rewards. Pass `since` (ISO timestamp, Unix seconds, `block:<n>`, or `last`) for ONLY what changed; each run stores a snapshot so the next `since` diff has a baseline. Sections degrade independently; unavailable ones are NAMED in `unavailable[]` with the reason.

Read-only. Diagnoses env setup — the cause and the fix of an env-related failure: presence + reachability checks (RPC, Pinata, IPFS gateway DNS, subgraph, backend) as pass/warn/fail with remediation hints. Warnings are advisories — a healthy zero-config install always has some. `probePin` is the one write: one tiny IPFS pin.

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. GraphQL against a DeXe subgraph: 'pools' (DAOs, proposals, voters, delegations, experts, sales), 'interactions' (per-user tx feed), 'validators'. Bound every list with `first:` (max 1000), page with `skip:`; oversized responses are rejected. Entity and field names must match the subgraph schema exactly — root fields are not entity names (DaoPool -> `daoPools`), and a wrong name errors with where to look it up. `chainId` picks the endpoint (pools: 56, validators: 56, interactions: 56; default 56); the reply echoes `indexedChainId`, never another chain's rows.

Read-only. Live introspection of a DeXe subgraph schema — the valid names for a GraphQL query, e.g. after "Type 'X' has no field 'Y'". Omit `entity` for the root query field map (each entity -> the field name to query it by); pass `entity` for that type's fields, '<Entity>_filter' for valid `where:` keys, '<Entity>_orderBy' for valid `orderBy:` values. An unknown name returns ranked candidates. `chainId` picks the endpoint (pools: 56, validators: 56, interactions: 56; default 56); the reply echoes `indexedChainId`, never another chain's rows.

Read-only, local. The plan for a multi-step or unfamiliar DeXe request — 'create a DAO', 'launch a token with distribution/OTC/staking', 'open a sale', 'pass this proposal': the ordered steps (which tools, in what order, with what params), the questions to ask the user with per-parameter risk notes, and the known pitfalls for that journey. Reference topics answer data questions the same way (flow:"read_dao_data" covers the whole read surface). No args or a free-text `intent` returns the menu; `flow` returns the full plan.

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. 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 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`.

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.

Read-only. Deprecated alias of dexe_read_token_sale_position (renamed in 0.36.0); same input and output.

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.

Read-only. Deprecated alias of dexe_read_token_sales (renamed in 0.36.0); same input and output.

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?} · withdraw_treasury {receiver,token?,amount?,nftAddress?,nftIds?} · change_voting_settings {govSettings?,settings[],settingsIds?} · add_expert/remove_expert {expertNftContract,scope,nominatedUser,uri?} · token_sale_whitelist {tokenSaleProposal,requests[]} · token_sale_recover {tokenSaleProposal,tierIds[]} · manage_validators {govValidators,changes[]} · validators_allocation {credits[]} · delegate_to_expert/revoke_from_expert {expert,amount,nftIds?} · change_math_model {newVotePower} · blacklist {erc20Gov,addAddresses?,removeAddresses?} · apply_to_dao {token,receiver,amount} · new_proposal_type/enable_staking {govSettings?,settings,executors,newSettingId} · custom_abi {target,signature,method,args?} · token_distribution · token_sale · create_staking_tier · reward_multiplier.\n• Internal (validators-only): change_validator_balances {changes[]} · change_validator_settings {duration,executionDelay,quorum} · monthly_withdraw {withdrawals[],destination} · offchain_internal_proposal {}.\nOff-chain backend types are rejected with the flow to use instead. Full recipes with examples: dexe://playbook, or dexe_proposal_catalog.

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. 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 DAO discovery via the pools subgraph; name search is case-insensitive, ordered by voter count descending. Pass `chainId` (chains with a pools endpoint here: 56; default 56); the reply echoes `indexedChainId`, never another chain's rows. No endpoint for a chain = an error that names the on-chain reads to use instead.

Read-only. Paginated member list for a DAO — voting power, delegation counts, rewards, expert status. Pass `chainId` (chains with a pools endpoint here: 56; default 56); the reply echoes `indexedChainId`, never another chain's rows. No endpoint for a chain = an error that names the on-chain reads to use instead.

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.

Read-only. Delegation pairs from the pools subgraph: direction='outgoing' = who a user delegated to, 'incoming' = who delegated to them. Pass `chainId` (chains with a pools endpoint here: 56; default 56); the reply echoes `indexedChainId`, never another chain's rows. No endpoint for a chain = an error that names the on-chain reads to use instead.

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

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()` then `getTierViews(0, latestTierId)` on the DAO's TokenSaleProposal: tiers with `totalSold` and status (`upcoming`/`active`/`ended`/`off`) computed from the current block timestamp and the tier's on-chain isOff flag. On-chain only — any chain with an RPC; the reply echoes the resolved `chainId`. `tokenSaleProposal` defaults to the address this install's local state records for the DAO; otherwise it is required.

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`.

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.

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. `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. 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 `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`. A hot DEXE_PRIVATE_KEY keeps signing precedence.

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.