# DeXe DAO governance (npm · dexe-mcp)

DeXe Protocol DAOs for AI agents: create DAOs, proposals, votes, OTC token sales, on-chain reads.

- Trust score: 85/100 (high trust)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-25

## Components

- npm · `dexe-mcp`: 85/100 (this document), [markdown](https://verifymcp.io/servers/edward-arinin-web-dev-dexe-mcp/dexe-mcp.md), [page](https://verifymcp.io/servers/edward-arinin-web-dev-dexe-mcp/dexe-mcp)

## Channel facts

- Registry: `npm`
- Package: `dexe-mcp`
- Version: `0.37.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-25.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 110 of 303 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to edward-arinin-web-dev/dexe-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 11 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 75/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 11171 tokens (~219/item across 51 items; 48 tools + 3 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 37/100
  - Stability observed for 11 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (46% of tools); any adoption earns full credit.
- **Tool Safety**: 88/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 2 of 4 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "dexe_vote_build_withdraw" implies "withdraw" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 50 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the DeXe DAO governance MCP server?

DeXe DAO governance runs locally as an npm package, launched with npx -y dexe-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add edward-arinin-web-dev-dexe-mcp -- npx -y dexe-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "edward-arinin-web-dev-dexe-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "dexe-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "edward-arinin-web-dev-dexe-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "dexe-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add edward-arinin-web-dev-dexe-mcp -- npx -y dexe-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "edward-arinin-web-dev-dexe-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "dexe-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add edward-arinin-web-dev-dexe-mcp --command npx --arg -y --arg dexe-mcp
```

### Hermes

```yaml
mcp_servers:
  edward-arinin-web-dev-dexe-mcp:
    command: "npx"
    args: ["-y", "dexe-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "edward-arinin-web-dev-dexe-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "dexe-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add edward-arinin-web-dev-dexe-mcp -t stdio -c npx -a -y dexe-mcp
```

### Other

```json
{
  "mcpServers": {
    "edward-arinin-web-dev-dexe-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "dexe-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-24 (score 85, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-22 (score 84, +4)

- [functional improvement] Stability: unverified → 0.27

### 2026-10-14 (score 80, +31)

- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: fail
- [functional] First check of Destructive annotations: 50
- [functional] First check of Tool coverage: 46
- [functional] First check of Schema quality: good
- [functional] First check of Tool coverage: 100

### 2026-10-13 (score 49, 0)

- [functional] Package version: 0.37.0 → 0.37.1

### 2026-10-12 (score 49)

First indexed and scored.

## MCP tools (48)

### `dexe_dao_predict_addresses` (~118 tokens)

Predict addresses for a future DAO deployment

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

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `deployer` (string, required): Address that will send the deployGovPool tx (tx.origin)
- `poolName` (string, required): Unique pool name — part of the CREATE2 salt

Output parameters:

- `distributionProposal` (string)
- `expertNft` (string)
- `govPool` (string)
- `govToken` (string)
- `govTokenSale` (string)
- `nftMultiplier` (string)

### `dexe_dao_registry_lookup` (~104 tokens)

Check whether an address is a DeXe GovPool

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

Input parameters:

- `address` (string): Candidate GovPool address
- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string): Alias for `address` — the name every other DAO tool uses

Output parameters:

- `address` (string)
- `chainId` (number)
- `isGovPool` (boolean)
- `poolRegistry` (string)

### `dexe_dao_info` (~83 tokens)

DAO overview — helpers, NFT contracts, validator count

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

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): GovPool contract address

Output parameters:

- `descriptionURL` (string|null)
- `govPool` (string)
- `helpers` (object)
- `nftContracts` (object)
- `validatorsCount` (string|null)

### `dexe_proposal_state` (~140 tokens)

Live proposal state + required quorum

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): GovPool contract address
- `proposalId` (string|number, required): On-chain proposal id, 1-indexed decimal (dexe_proposal_list).

Output parameters:

- `govPool` (string)
- `proposalId` (string)
- `quorumAttainmentAgainstPct` (number|null)
- `quorumAttainmentForPct` (number|null)
- `quorumReached` (boolean|null)
- `requiredQuorum` (string)
- `requiredQuorumFormatted` (string)
- `state` (string)
- `stateIndex` (number)
- `votesAgainst` (string|null)
- `votesAgainstFormatted` (string)
- `votesFor` (string|null)
- `votesForFormatted` (string)
- `votesShortOfQuorum` (string|null)

### `dexe_proposal_list` (~139 tokens)

List proposals on a GovPool

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): GovPool contract address
- `limit` (integer): Max proposals per page.
- `offset` (integer): Proposals to skip; page with `nextOffset`.

Output parameters:

- `govPool` (string)
- `limit` (number)
- `nextOffset` (number)
- `offset` (number)
- `proposals` (array)
- `returned` (number)
- `total` (number)
- `truncated` (boolean)

### `dexe_vote_user_power` (~127 tokens)

User staking + delegation power across VoteTypes

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): GovPool contract address
- `user` (string, required): User wallet address

Output parameters:

- `govPool` (string)
- `power` (object)
- `user` (string)
- `userKeeper` (string)

### `dexe_read_treasury` (~189 tokens)

Treasury or wallet balances (native + ERC20, USD)

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

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string): Alias for `holder` — every other DAO read names the DAO this way
- `holder` (string): Address whose balances we read (a GovPool for a DAO treasury)
- `tokens` (array): Optional explicit ERC20 addresses (at most 50); forces on-chain RPC read of just these

Output parameters:

- `chainId` (number)
- `degraded` (boolean)
- `holder` (string)
- `native` (string)
- `nativeFormatted` (string)
- `source` (string)
- `tokens` (array)
- `totalUsd` (number|null)

### `dexe_read_token_holders` (~134 tokens)

Top holders of an ERC20 token (with balances)

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

Input parameters:

- `chainId` (integer): Chain for the backend lookup: 1 Ethereum, 56 BSC. Testnets are not indexed. Default: the configured chain.
- `pageSize` (integer): Rows per page (backend max 100).
- `pageToken` (string): Prior result's `nextPageToken` for the next page.
- `token` (string, required): ERC20 token contract address

Output parameters:

- `chainId` (number)
- `count` (number)
- `holders` (array)
- `nextPageToken` (string)
- `token` (string)
- `truncated` (boolean)

### `dexe_read_dao_stats` (~195 tokens)

DAO TVL + activity stats time series

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.

Input parameters:

- `chainId` (integer): Chain for the backend lookup: 1 Ethereum, 56 BSC. Testnets are not indexed. Default: the configured chain.
- `govPool` (string, required): GovPool / DAO address
- `maxPoints` (integer): Cap on returned data points; longer series are evenly downsampled (first and last points always kept). The tracker emits ~hourly points — '1 months' is ~740 raw points / ~650 KB, far beyond a usable…
- `period` (string): Duration window, e.g. '24 hours', '7 days', '1 months'

Output parameters:

- `chainId` (number)
- `data` (array)
- `downsampled` (boolean)
- `govPool` (string)
- `period` (string)
- `points` (number): Raw point count returned by the tracker
- `returnedPoints` (number): Points in `data` after downsampling

### `dexe_read_settings` (~103 tokens)

Default + internal proposal settings for a DAO

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

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): DAO GovPool address (dexe_dao_registry_lookup).

Output parameters:

- `defaultSettings`
- `govPool` (string)
- `internalSettings`
- `settings` (string)

### `dexe_ipfs_upload_proposal_metadata` (~99 tokens)

Upload proposal metadata JSON to IPFS (Pinata)

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

Input parameters:

- `description` (string): Proposal body; Markdown supported, converted to the Slate format the frontend expects.
- `extra` (object): Extra fields merged into the metadata object.
- `title` (string, required): Proposal title; becomes `proposalName`.

Output parameters:

- `cid` (string)
- `descriptionURL` (string)
- `pinnedAt` (string)
- `size` (number)

### `dexe_ipfs_upload_file` (~168 tokens)

Upload raw bytes (avatar, attachment, etc.) to IPFS (Pinata)

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

Input parameters:

- `base64` (string): Base64 file bytes — only when the content isn't a local file.
- `contentType` (string): MIME type of the bytes.
- `fileName` (string): Filename to pin it under, with extension.
- `filePath` (string): Absolute path to a local file, max 25 MB — the server reads it. Preferred over base64.
- `normalizeImageExt` (boolean): If contentType starts with image/, rename the extension to .jpeg.

Output parameters:

- `cid` (string): CID v1 base32 — use this as avatarCID.
- `cidV0` (string): Original CID returned by Pinata (usually v0 Qm...). Kept for legacy callers.
- `fileName` (string): Filename actually pinned (possibly normalized to .jpeg).
- `pinnedAt` (string)
- `size` (number)

### `dexe_ipfs_upload_avatar` (~179 tokens)

Upload a DAO avatar (one-shot: pins + returns avatarCID/avatarFileName/avatarUrl)

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.

Input parameters:

- `base64` (string): Base64 image bytes — only when the image isn't a local file.
- `contentType` (string): Caller-claimed MIME type. Informational only — the pinned MIME comes from byte sniffing.
- `fileName` (string): Base filename; extension will be normalized to .jpeg
- `filePath` (string): Absolute path to a local image (JPEG/PNG/WebP/GIF, max 10 MB). Preferred over base64.

Output parameters:

- `avatarCID` (string): CID v1 base32 — pass to upload_dao_metadata as avatarCID.
- `avatarFileName` (string): Filename (always ends with .jpeg).
- `avatarUrl` (string): Full subdomain-gateway URL — what the frontend stores verbatim.
- `detectedFormat` (string): Raster format detected from magic bytes (jpeg|png|webp|gif).
- `pinnedAt` (string)
- `size` (number)

### `dexe_dao_generate_avatar` (~91 tokens)

Generate a deterministic placeholder avatar for a 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.

Input parameters:

- `daoName` (string, required): DAO name; first 1–2 alphanumeric chars become the avatar initials.
- `size` (integer): Output image size in px (square).

Output parameters:

- `avatarCID` (string)
- `avatarFileName` (string)
- `avatarUrl` (string)
- `pinnedAt` (string)
- `size` (number)

### `dexe_ipfs_fetch` (~80 tokens)

Fetch content by CID (dedicated gateway, optional fallback)

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.

Input parameters:

- `cid` (string, required): CID (with or without ipfs:// prefix)
- `timeoutMs` (integer): Per-gateway timeout in ms (default 10000).

Output parameters:

- `attempts` (number)
- `cid` (string)
- `contentType` (string)
- `gateway` (string)
- `json`
- `sizeBytes` (number)
- `truncated` (boolean)

### `dexe_proposal_catalog` (~83 tokens)

List every proposal type DeXe supports

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

Input parameters:

- `category` (string): Restrict to one category; 'all' returns the whole catalog.
- `implementedOnly` (boolean): True to list only types that have an MCP builder.

Output parameters:

- `externalMetadataShape`
- `internalMetadataShape`
- `total` (number)
- `types` (array)

### `dexe_vote_build_erc20_approve` (~281 tokens)

Build ERC20.approve(spender, amount) calldata

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.

Input parameters:

- `amount` (string, required): Allowance in the ERC20 at `token`, that token's own decimals. RAW base units, digits only ('1500000000000000000' = 1.5 at 18 dec); '1.5' is REJECTED — scale it, or use dexe_proposal_create. Unlimited…
- `chainId` (integer): Chain this payload targets: 56 mainnet, 97 testnet. Default: the configured chain.
- `govPool` (string): DAO GovPool. When set, an approve to it (instead of its GovUserKeeper) is refused.
- `spender` (string, required): For deposits: the DAO's GovUserKeeper address (NOT the GovPool)
- `token` (string, required): ERC20 token contract address to approve.

Output parameters:

- `advisories` (array): Deprecated — use warnings.
- `payload` (object)
- `warnings` (array)

### `dexe_vote_build_deposit` (~289 tokens)

Stake tokens/NFTs into a DAO to gain voting power

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.

Input parameters:

- `amount` (string, required): Governance token to stake, in that token's own decimals. RAW base units, digits only ('1500000000000000000' = 1.5 at 18 dec); '1.5' is REJECTED — scale it, or use dexe_proposal_create
- `chainId` (integer): Chain this payload targets: 56 mainnet, 97 testnet. Default: the configured chain.
- `govPool` (string, required): DAO GovPool address (dexe_dao_registry_lookup).
- `nftIds` (array): Your governance NFT token ids, decimal; [] for ERC20-only DAOs.
- `value` (string): Native coin (BNB/ETH, 18 decimals) sent with the tx — native-staking DAOs only. RAW base units, digits only ('1500000000000000000' = 1.5 at 18 dec); '1.5' is REJECTED — scale it, or use dexe_proposal…

Output parameters:

- `advisories` (array): Deprecated — use warnings.
- `payload` (object)
- `warnings` (array)

### `dexe_vote_build_withdraw` (~202 tokens)

Unstake tokens/NFTs from a DAO

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.

Input parameters:

- `amount` (string, required): Governance token to unstake, in that token's own decimals. RAW base units, digits only ('1500000000000000000' = 1.5 at 18 dec); '1.5' is REJECTED — scale it, or use dexe_proposal_create
- `chainId` (integer): Chain this payload targets: 56 mainnet, 97 testnet. Default: the configured chain.
- `govPool` (string, required): DAO GovPool address (dexe_dao_registry_lookup).
- `nftIds` (array): Your governance NFT token ids, decimal; [] for ERC20-only DAOs.
- `receiver` (string, required): Address the unstaked tokens/NFTs are sent to.

Output parameters:

- `advisories` (array): Deprecated — use warnings.
- `payload` (object)
- `warnings` (array)

### `dexe_vote_build_vote` (~294 tokens)

Vote on an external proposal

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

Input parameters:

- `amount` (string, required): Your staked/delegated governance token power to cast, that token's own decimals. RAW base units, digits only ('1500000000000000000' = 1.5 at 18 dec); '1.5' is REJECTED — scale it, or use dexe_proposa…
- `chainId` (integer): Chain this payload targets: 56 mainnet, 97 testnet. Default: the configured chain.
- `govPool` (string, required): DAO GovPool address (dexe_dao_registry_lookup).
- `isVoteFor` (boolean, required): true = vote FOR, false = vote AGAINST.
- `nftIds` (array): Your governance NFT token ids, decimal; [] for ERC20-only DAOs.
- `proposalId` (string, required): On-chain proposal id, 1-indexed decimal (dexe_proposal_list).
- `voter` (string): Your address. When set, the deposit-lock warning is checked against your live power and shown only if your tokens really are locked.

Output parameters:

- `advisories` (array): Deprecated — use warnings.
- `payload` (object)
- `warnings` (array)

### `dexe_vote_build_execute` (~237 tokens)

Execute a passed proposal

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.

Input parameters:

- `chainId` (integer): Chain this payload targets: 56 mainnet, 97 testnet. Default: the configured chain.
- `govPool` (string, required): DAO GovPool address (dexe_dao_registry_lookup).
- `govValidators` (string): Required for scope:'internal' (dexe_dao_info.helpers.validators)
- `proposalId` (string, required): On-chain proposal id, 1-indexed decimal (dexe_proposal_list).
- `scope` (string): 'external' executes on GovPool; 'internal' on GovValidators (needs govValidators).
- `voter` (string): Your address. When set, the deposit-lock warning is checked against your live power and shown only if your tokens really are locked.

Output parameters:

- `advisories` (array): Deprecated — use warnings.
- `payload` (object)
- `warnings` (array)

### `dexe_dao_report` (~410 tokens)

Full DAO report — one call, every section, with a since-diff

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): GovPool / DAO address
- `memberLimit` (integer): Member/delegation rows to fetch (newest joiners first).
- `persist` (boolean): Store this run's snapshot so a later `since` diff has a baseline. Full runs only — a `sections`-narrowed run never overwrites it.
- `proposalLimit` (integer): How many of the NEWEST proposals to walk for state, outcomes and turnout.
- `sections` (array): Narrow the report. Default: all of identity, settings, treasury, membership, delegation, experts, validators, proposals, turnout, activity, deadlines.
- `since` (string): Diff anchor: ISO-8601 ('2026-08-01T00:00:00Z'), Unix seconds ('1785000000' / 'unix:…'), a block number ('block:62000000'; a bare integer below 1e9 is read as a block), or 'last' to diff against this…
- `user` (string): Optional wallet. Adds per-user deadline items: proposals in Voting this user has NOT voted on, and claimable rewards.

Output parameters:

- `blockNumber` (number|null)
- `chainId` (number)
- `changes`
- `degraded` (string|null)
- `followUps` (array)
- `generatedAt` (string)
- `generatedAtUnix` (number)
- `govPool` (string)
- `sections` (object)
- `since`
- `snapshotPersisted` (boolean)
- `sources` (object)
- `unavailable` (array)

### `dexe_read_dao_list` (~164 tokens)

Discover and list DAOs (subgraph)

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `limit` (integer): Max rows per page.
- `offset` (integer): Rows to skip (pagination).
- `query` (string): Name search (case-insensitive, empty = all)

### `dexe_read_dao_members` (~161 tokens)

List DAO members with voting power (subgraph)

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): GovPool address (lowercased for subgraph)
- `limit` (integer): Max rows per page.
- `offset` (integer): Rows to skip (pagination).

### `dexe_read_delegation_map` (~233 tokens)

Delegation relationships — outgoing or incoming (subgraph)

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.

Input parameters:

- `addresses` (array, required): Voter WALLET addresses (plain 0x…40-hex). Composite VoterInPool ids ('govPool-voter' or 80-hex 'voter+pool' concatenations) are also accepted — the voter part is extracted automatically.
- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `direction` (string): outgoing = who I delegated to; incoming = who delegated to me
- `limit` (integer): Max rows per page.
- `offset` (integer): Rows to skip (pagination).

### `dexe_read_token_sales` (~203 tokens)

List a DAO's token sale 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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): GovPool address
- `tokenSaleProposal` (string): TokenSaleProposal helper address. Omit when the local state records it; otherwise dexe_dao_predict_addresses or the deploy receipt.

### `dexe_otc_list_sales_for_dao` (~122 tokens)

List a DAO's token sale tiers (old name)

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

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `govPool` (string, required): GovPool address
- `tokenSaleProposal` (string): TokenSaleProposal helper address. Omit when the local state records it; otherwise dexe_dao_predict_addresses or the deploy receipt.

### `dexe_graph_query` (~236 tokens)

Free-form GraphQL query against a DeXe subgraph

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `query` (string, required): GraphQL query document (read-only)
- `subgraph` (string, required): Which DeXe subgraph to query
- `variables` (object): GraphQL variables referenced by the query

### `dexe_graph_schema` (~251 tokens)

Introspect a DeXe subgraph schema

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `entity` (string): Type name to expand, e.g. 'Proposal', 'VoterInPool', 'DaoPool_filter', 'Proposal_orderBy'. Omit for the root query field map.
- `subgraph` (string, required): Which DeXe subgraph to introspect

### `dexe_tx_send` (~302 tokens)

Sign and broadcast a transaction

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

Input parameters:

- `chainId` (integer): Chain to broadcast on; needs an RPC for it. Default: the MCP's default chain.
- `data` (string): ABI-encoded calldata (0x-prefixed hex)
- `gasLimit` (string): Optional gas limit override (decimal string)
- `payload` (object): A dexe_*_build_* `payload` object verbatim ({to,data,value,chainId}). Fills to/data/value and payloadChainId when the flat fields are omitted.
- `payloadChainId` (integer): The TxPayload's own `chainId`, copied verbatim — a mismatch REFUSES the send.
- `signerKey` (string): Signer: omit = primary DEXE_PRIVATE_KEY (never an agent); 'agent<n>'/address = keyring.
- `to` (string): Destination contract address (or pass the builder's `payload` object)
- `value` (string): Wei value as decimal string
- `waitConfirmations` (integer): Confirmations to wait (0 = fire-and-forget)

### `dexe_tx_status` (~80 tokens)

Transaction status

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.

Input parameters:

- `chainId` (integer): Chain to look the receipt up on. Default: the MCP's default chain.
- `txHash` (string, required): Transaction hash to look up

### `dexe_tx_approval_status` (~83 tokens)

Keystore approval status

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

Input parameters:

- `approvalId` (string, required): `approval.approvalId` of the awaiting_approval result
- `waitMs` (integer): Long-poll up to this many ms for a change

### `dexe_get_config` (~57 tokens)

Resolved server config

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

Input parameters:

- `_placeholder` (boolean): Unused; tool takes no input.

### `dexe_doctor` (~136 tokens)

Diagnose env setup

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.

Input parameters:

- `_placeholder` (boolean): Unused; tool takes no input.
- `probePin` (boolean): Probe pin to Pinata (added, then removed) — use when an IPFS upload fails with HTTP 403.

### `dexe_wc_status` (~65 tokens)

WalletConnect session state

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

Input parameters:

- `chainId` (integer): Unused; reserved.

### `dexe_wc_connect` (~95 tokens)

Connect a wallet by QR

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.

Input parameters:

- `chainId` (integer): Chain to request in the session namespace. Defaults to the MCP's default chain.

### `dexe_wc_disconnect` (~44 tokens)

Disconnect the wallet

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

Input parameters:

- `_placeholder` (boolean): Unused; tool takes no input.

### `dexe_proposal_create` (~1059 tokens)

Create a proposal

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.

Input parameters:

- `actionsOnFor` (array): Actions run when the proposal passes. Required for proposalType:'custom'.
- `allowDuplicate` (boolean): The create is SKIPPED when a live proposal already carries the same IPFS metadata URL (a resumed run). True mints a second identical proposal on purpose.
- `category` (string): Proposal category (included in IPFS metadata).
- `chainId` (integer): Target chain (56 mainnet, 97 testnet); needs an RPC for it. Default: the MCP's default chain.
- `confirmRisky` (boolean): Required when the built proposal carries a DANGER governance-safety advisory. Without it the flow refuses BEFORE any transaction.
- `description` (string): Proposal description (markdown supported)
- `dryRun` (boolean): Preview: no broadcast, no IPFS pin, no Pinata key needed. The metadata CID is right but unpinned — do NOT broadcast this calldata.
- `flowContext` (object): Guided-flow position from dexe_guide's step templates. Adds flowProgress + next to the result and persists it.
- `govPool` (string, required): DAO GovPool address (dexe_dao_registry_lookup).
- `newAvatarBase64` (string): Base64 image bytes — only when the image isn't a local file.
- `newAvatarCID` (string): modify_dao_profile: IPFS CID of an already-pinned avatar.
- `newAvatarFileName` (string): modify_dao_profile: file name stored with newAvatarCID.
- `newAvatarPath` (string): Local avatar image path (JPEG/PNG/WebP/GIF, max 10 MB) — the server validates and pins it for you.
- `newDaoDescription` (string): modify_dao_profile: the DAO's new description (markdown).
- `newDaoName` (string): modify_dao_profile: the DAO's new display name.
- `newSocialLinks` (array): modify_dao_profile: [[network, url], ...].
- `newWebsiteUrl` (string): modify_dao_profile: the DAO's new website URL.
- `params` (object): Type-specific builder inputs for the chosen proposalType (recipes: tool description / dexe://playbook).
- `proposalMetadataExtra` (object): Extra fields merged into IPFS metadata.
- `proposalType` (string): What kind of proposal to create — required in practice. 'custom' means you supply actionsOnFor. Unsure? Call dexe_proposal_catalog.
- `signerKey` (string): Keyring signer: omit = primary key; 'agent<n>' or address = a DEXE_AGENT_PK_* key.
- `title` (string, required): Proposal title
- `user` (string): User address. Required when DEXE_PRIVATE_KEY not set.
- `voteAmount` (string): Auto-vote amount: raw wei (digits only) or human units with a decimal point ('12.5'). Default: all available power.
- `voteNftIds` (array): Your governance NFT token ids, decimal; [] for ERC20-only DAOs.

### `dexe_proposal_vote_and_execute` (~478 tokens)

Vote on and execute a proposal

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.

Input parameters:

- `autoExecute` (boolean): Attempt execute if proposal passes after vote
- `chainId` (integer): Target chain (56 mainnet, 97 testnet); needs an RPC for it. Default: the MCP's default chain.
- `depositFirst`: 'auto': deposit exactly what is missing when deposited power is short. true: deposit the whole wallet balance. false: never deposit.
- `driveValidatorRound` (boolean): With autoExecute, drive the validator stage too: moveProposalToValidators, cast the signer's validator vote if it is one, then execute. False stops after the member vote.
- `dryRun` (boolean): If true, return ordered TxPayloads even when DEXE_PRIVATE_KEY is set (preview without broadcasting).
- `flowContext` (object): Guided-flow position from dexe_guide's step templates. Adds flowProgress + next to the result and persists it.
- `govPool` (string, required): DAO GovPool address (dexe_dao_registry_lookup).
- `isVoteFor` (boolean): Vote for (true) or against (false)
- `proposalId` (string|number, required): On-chain proposal id, 1-indexed decimal (dexe_proposal_list).
- `signerKey` (string): Keyring signer: omit = primary key; 'agent<n>' or address = a DEXE_AGENT_PK_* key.
- `user` (string): User address. Required when DEXE_PRIVATE_KEY not set.
- `voteAmount` (string): Vote amount: raw wei (digits only) or human units with a decimal point ('12.5'). Default: ALL available power (deposited + wallet).
- `voteNftIds` (array): Your governance NFT token ids, decimal; [] for ERC20-only DAOs.

### `dexe_dao_create` (~1089 tokens)

Deploy a new DAO

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').

Input parameters:

- `avatarCID` (string): IPFS CID of an already-pinned JPEG avatar (dexe_ipfs_upload_avatar)
- `avatarFileName` (string): File name stored alongside avatarCID.
- `avatarPath` (string): Local avatar image path (JPEG/PNG/WebP/GIF ≤10 MB) — server validates + pins it. Preferred over avatarCID.
- `chainId` (integer): Target chain id. Defaults to the MCP's default chain. Use 97 (BSC testnet) to validate; 56 = BSC mainnet (real funds).
- `confirm` (boolean): True to actually broadcast; without it SIMPLE mode and any mainnet deploy return a review-only preview. Pass it on the FIRST call when the user has already approved the deploy.
- `confirmRisky` (boolean): Proceed despite a governance-safety refusal. Read the returned `risks` to the user FIRST — such a config cannot be repaired after deploy, because repairing it needs a proposal passed under it. Ignore…
- `daoDescription` (string): DAO description (markdown; uploaded to IPFS as slate)
- `daoName` (string, required): DAO name (also the deployGovPool pool name)
- `deployer` (string): tx.origin that sends the deploy (needed for address prediction). Defaults to the signer address.
- `documents` (array): External documents shown on the DAO profile, e.g. [{ name: "Whitepaper", url: "https://..." }]
- `dryRun` (boolean): Preview: no broadcast, no IPFS pin, no Pinata key needed. CIDs are right but unpinned — do NOT broadcast this calldata.
- `durationSeconds` (integer): SIMPLE mode: voting duration. Default 86400 (1 day).
- `earlyCompletion` (boolean): SIMPLE mode: end voting as soon as the quorum is reached. Default true.
- `executionDelaySeconds` (integer): SIMPLE mode: delay before execution. Default 0.
- `flowContext` (object): Guided-flow position from dexe_guide's step templates. Adds flowProgress + next to the result and persists it.
- `minVotesTokens` (string): SIMPLE mode: min tokens to vote AND create proposals, WHOLE tokens. Default '1'. Must be ≤ the largest holder's allocation.
- `params` (object): ADVANCED mode: the full deployGovPool params struct. Prefer SIMPLE mode. Field-by-field schema: dexe_dao_build_deploy (needs DEXE_TOOLSETS=core,dev).
- `poolFactory` (string): PoolFactory override; defaults to ContractsRegistry lookup
- `quorumPercent` (number): SIMPLE mode: quorum, percent 0-100. Omit and the tool picks (default 51). Must be >=50 and clearable by at most 80% turnout — a quorum equal to the votable share freezes the DAO forever.
- `recipients` (array): SIMPLE mode: split the votable share across wallets (default: deployer only). Percents are of TOTAL supply and must sum to 100 − treasuryPercent.
- `signerKey` (string): Keyring signer: omit = primary key; 'agent<n>' or address = a DEXE_AGENT_PK_* key.
- `socialLinks` (array): [[network, url], ...]
- `symbol` (string): SIMPLE mode: gov token symbol (e.g. 'GENA'). Required when `params` is omitted.
- `totalSupply` (string): SIMPLE mode: total token supply in WHOLE tokens (e.g. '1000000'). Required when `params` is omitted.
- `treasuryPercent` (number): SIMPLE mode: treasury share, percent 0-100 (implicit remainder; it cannot vote). Omit and the tool picks one that leaves a real voting margin (default 30).
- `voteModel` (string): SIMPLE mode: vote-power model. LINEAR = 1 token = 1 vote (default). POLYNOMIAL = meritocratic curve.
- `websiteUrl` (string): DAO website URL shown on its profile.

### `dexe_context` (~160 tokens)

Session context

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.

Input parameters:

- `daoLimit` (integer): Recorded DAOs to return, newest first.
- `proposalLimit` (integer): Recorded proposals to return, newest first.
- `user` (string): Wallet address: adds its deposited voting power in the newest recorded DAO (one extra RPC call).

### `dexe_write_context` (~151 tokens)

Signer and write posture

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.

Input parameters:

- `includeAgentBalances` (boolean): Probe each persona's native balance (one eth_getBalance per signer, default chain).
- `includeDepositedPower` (boolean): Read the signer's deposited power in the newest recorded DAO (one extra RPC call).

### `dexe_guide` (~222 tokens)

Flow plans and pitfalls

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.

Input parameters:

- `chainId` (integer): Target chain (56 mainnet / 97 testnet). Defaults to the last-used, then the configured default chain.
- `flow` (string): Exact flow or topic id. Takes precedence over `intent`; omit both for the menu.
- `intent` (string): The user's request in free text — matched against the flow triggers (e.g. 'create a token and sell 20% via OTC').

### `dexe_otc_dao_open_sale` (~493 tokens)

Open an OTC token sale

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.

Input parameters:

- `acknowledgeVestingBlocked` (boolean): Refused by default: opt into vestingPercentage > 0; the vested leg is stranded (F15).
- `buildOnly` (boolean): Return only the envelope (actions + metadata + merkle roots); skips IPFS and DAO reads.
- `chainId` (integer): Target chain id. Defaults to the MCP's default chain.
- `dryRun` (boolean): Preview: no broadcast, no IPFS pin. CIDs are right but unpinned — do NOT broadcast.
- `flowContext` (object): Guided-flow position from dexe_guide's step templates. Adds flowProgress + next to the result and persists it.
- `govPool` (string, required): GovPool address
- `latestTierId` (string): Current `latestTierId()` on the sale; new tiers start after it.
- `proposalDescription` (string): Proposal body; Markdown supported.
- `proposalName` (string): Proposal title in the DAO UI.
- `signerKey` (string): Keyring signer: omit = primary key; 'agent<n>' or address = a DEXE_AGENT_PK_* key.
- `tiers` (array, required): Tier specs for `createTiers`, in order; at least one.
- `tokenSaleProposal` (string): TokenSaleProposal helper address. Omit for a DAO this install deployed (recorded at deploy); otherwise dexe_dao_predict_addresses or the deploy receipt.
- `user` (string): Acting address; defaults to the configured signer.
- `voteAmount` (string): Vote size: whole tokens ('12.5') or raw wei. Omit to vote with all available power.
- `voteNftIds` (array): Your governance NFT token ids, decimal; [] for ERC20-only DAOs.

### `dexe_read_token_sale_position` (~172 tokens)

Token sale position for a wallet

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.

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `tierIds` (array, required): Tier ids to report on, decimal strings (1 to 50).
- `tokenSaleProposal` (string, required): TokenSaleProposal helper address
- `user` (string, required): Buyer address to report state for.
- `whitelists` (array): Optional per-tier whitelist (for MerkleWhitelist proof generation).

### `dexe_otc_buyer_status` (~143 tokens)

Token sale position for a wallet (old name)

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

Input parameters:

- `chainId` (integer): Chain to read from: 56 mainnet, 97 testnet. Needs an RPC for it. Default: the configured chain.
- `tierIds` (array, required): Tier ids to report on, decimal strings (1 to 50).
- `tokenSaleProposal` (string, required): TokenSaleProposal helper address
- `user` (string, required): Buyer address to report state for.
- `whitelists` (array): Optional per-tier whitelist (for MerkleWhitelist proof generation).

### `dexe_otc_buyer_buy` (~333 tokens)

Buy from an OTC tier

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.

Input parameters:

- `amount` (string, required): Amount to spend: human units ('100.5'), or digits-only = 18-decimal-normalized.
- `chainId` (integer): Target chain id. Defaults to the MCP's default chain.
- `dryRun` (boolean): If true, return ordered TxPayloads even when DEXE_PRIVATE_KEY is set.
- `proof` (array): Merkle proof for a gated tier; [] when not gated.
- `signerKey` (string): Keyring signer: omit = primary key; 'agent<n>' or address = a DEXE_AGENT_PK_* key.
- `simulateFirst` (boolean): eth_call-simulate buy() first; aborts with the revertReason if the sim fails.
- `tierId` (string, required): Tier to buy from, decimal string.
- `tokenSaleProposal` (string, required): TokenSaleProposal helper address
- `tokenToBuyWith` (string, required): Payment token; native BNB = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE (0x0 is an alias).
- `user` (string): Buyer address; defaults to the configured signer.
- `whitelistUsers` (array): Optional whitelist for proof gen

### `dexe_otc_buyer_claim_all` (~247 tokens)

Claim all OTC purchases

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.

Input parameters:

- `chainId` (integer): Target chain id. Defaults to the MCP's default chain.
- `dryRun` (boolean): If true, return ordered TxPayloads even when DEXE_PRIVATE_KEY is set.
- `includeVesting` (boolean): Attempt `vestingWithdraw` too; it reverts on every current pool (upstream F15).
- `signerKey` (string): Keyring signer: omit = primary key; 'agent<n>' or address = a DEXE_AGENT_PK_* key.
- `tierIds` (array, required): Tier ids to sweep, decimal strings.
- `tokenSaleProposal` (string, required): TokenSaleProposal helper address
- `user` (string): Claimer address; defaults to the configured signer.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/edward-arinin-web-dev-dexe-mcp/dexe-mcp#diagnostics

## Score history

- 2026-10-25: 85
- 2026-10-24: 85
- 2026-10-23: 84
- 2026-10-22: 84
- 2026-10-21: 80
- 2026-10-20: 80
- 2026-10-19: 80
- 2026-10-18: 80
- 2026-10-17: 80
- 2026-10-16: 80
- 2026-10-15: 80
- 2026-10-14: 80
- 2026-10-13: 49
- 2026-10-12: 49

## Common questions

### What is the DeXe DAO governance MCP server?

DeXe DAO governance is an MCP server listed in the public MCP registry as io.github.edward-arinin-web-dev/dexe-mcp. DeXe Protocol DAOs for AI agents: create DAOs, proposals, votes, OTC token sales, on-chain reads. This page covers its npm package (dexe-mcp).

### Is the DeXe DAO governance MCP server safe to use?

DeXe DAO governance scores 85 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 25 October 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the DeXe DAO governance MCP server expose?

DeXe DAO governance exposes 48 tools: dexe_dao_predict_addresses, dexe_dao_registry_lookup, dexe_dao_info, dexe_proposal_state, dexe_proposal_list, and 43 more. Their descriptions and schemas cost roughly 10,524 tokens of context every time the server is loaded.

### Is the DeXe DAO governance MCP server still maintained?

DeXe DAO governance is still listed as active in the MCP registry. We last reached this channel on 25 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the DeXe DAO governance MCP server under?

DeXe DAO governance declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/dexe-mcp
- Socket report: https://socket.dev/npm/package/dexe-mcp
- Repository: https://github.com/edward-arinin-web-dev/dexe-mcp
- Changelog RSS feed: https://verifymcp.io/servers/edward-arinin-web-dev-dexe-mcp/dexe-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/edward-arinin-web-dev-dexe-mcp/dexe-mcp.json
- HTML version of this page: https://verifymcp.io/servers/edward-arinin-web-dev-dexe-mcp/dexe-mcp