WDK on Monad

Build self-custodial wallets and payments on Monad with Tether's Wallet Development Kit. Add local, on-device AI with QVAC if your idea needs it.

WDK

JavaScript modules for building self-custodial wallets. One seed phrase derives accounts on EVM chains like Monad, plus Solana, TON, Tron and more. Read balances, quote fees, sign, send. Keys stay with the user, never with a server.

Quick start

Node.js 22+.

git clone https://github.com/portdeveloper/wdk-qvac-monad-starter
cd wdk-qvac-monad-starter
npm install       # ~240 MB
npm run setup     # new seed in .env + 1 testnet MON from the devnads faucet
npm run mint      # 100 test USDC + USDT
npm run send -- 0xRecipient 5 USDC

Use the wallet

The starter's createWallet() wraps WDK with Monad config, token helpers and a write queue that keeps back-to-back sends safe (see gotchas).

import { createWallet } from './src/wallet.js'

const wallet = await createWallet() // reads WDK_SEED + MONAD_NETWORK from env (node --env-file=.env)
console.log(wallet.address, await wallet.balances())

await wallet.transfer('USDC', '0x…', '5')
await wallet.sendTransaction({ to: contract, data }) // any contract call

Or use WDK directly. Monad is a standard EVM chain to it: register @tetherto/wdk-wallet-evm with a Monad RPC.

import WDK from '@tetherto/wdk'
import WalletManagerEvm from '@tetherto/wdk-wallet-evm'

const wdk = new WDK(process.env.WDK_SEED)
  .registerWallet('monad', WalletManagerEvm, {
    provider: 'https://testnet-rpc.monad.xyz', // mainnet: https://rpc.monad.xyz
    chainId: 10143,                            // mainnet: 143
  })

const account = await wdk.getAccount('monad', 0)
console.log(await account.getAddress(), await account.getBalance())

const { hash } = await account.sendTransaction({ to: '0x…', value: 10n ** 16n }) // 0.01 MON

What to build

Ideas sized for one day. The bar: WDK holds the keys (no MetaMask), and the demo makes at least one real transaction on Monad testnet.

Tip bot

A Telegram or Discord bot where every member gets a wallet derived from one seed (account index = user). /tip @friend 5 USDT. The bot holds the seed, so keep it on testnet.

Claim links

Send USDT as a link: the link carries a fresh one-time key holding the funds (plus a little MON for gas), and whoever opens it sweeps them into their own wallet. Red packets, giveaways, onboarding friends.

Checkout with per-order addresses

A shop derives a new address for every order from one seed, watches it for the USDT payment, marks the order paid, then tops it up with MON for gas and sweeps the funds to the treasury.

Pay-per-call API

Your API answers 402 with a price. The client pays in USDT on Monad with WDK, retries with the tx hash, and the server checks the receipt. Fees of a fraction of a cent make per-request pricing work.

Wallet MCP server

Give Claude, ChatGPT or any agent a wallet: an MCP server exposing balance, quote and send tools backed by WDK, with spending limits enforced in code, not in the prompt.

Split and settle

A group expense ledger that computes who owes whom and settles every debt in one go. The starter's write queue keeps the burst of back-to-back transfers safe on Monad.

Game with a real wallet

Every player gets a WDK wallet. Rewards are test USDT, items are the ERC-1155s from /tokens, and trades between players are real transfers.

One seed, many chains

One recovery phrase, accounts on Monad and Solana (or TON, Tron): a wallet that pays from whichever chain has the funds.

Monad gotchas

Back-to-back sends reuse nonces

Monad's public RPC returns the same pending and latest nonce: it doesn't count txs still in the mempool. WDK uses the pending nonce, so two sends within ~200 ms get the same one. Identical txs are silently deduplicated (same hash returned, only one lands); different ones fail with "nonce has already been used" or "could not coalesce error". The starter serializes writes and waits for each receipt (~0.4–1 s on Monad).

The quoted fee is a ceiling

WDK quotes gasLimit × maxFeePerGas, roughly 2× the base fee plus tip. A plain MON send quotes 0.004242 MON and is charged 0.002142 MON.

Monad charges for the gas limit, not gas used

WDK sets the limit from eth_estimateGas, so leave it alone. Hardcoding a generous gasLimit means paying for all of it. Monad docs

Empty wallets can't quote

With 0 MON, quotes fail with "missing revert data". The RPC is rejecting gas estimation for insufficient balance. Fund the wallet first.

Public RPCs are rate limited

Set MONAD_RPC_URL to your own endpoint if you hit 429s during a demo.

Networks

NetworkChain IDRPCTokens in starter
Testnet10143https://testnet-rpc.monad.xyzTest USDC, USDT (mint at /tokens)
Mainnet143https://rpc.monad.xyzUSDC, USDT0

Verified

Tested November 2026 with @tetherto/wdk 1.0.0-beta.22 and @tetherto/wdk-wallet-evm 1.0.0-beta.25. WDK is in beta; the starter pins exact versions.

FeatureTestnetMainnet
Seed, HD derivation, chain detection✓✓
Balances, token balances (multicall), allowances✓✓
sign / signTypedData + verify✓✓
Fee quotes✓✓
MON sends (EIP-1559), receipts✓✓
ERC-20 transfer✓fork only
Parallel sends with the starter's write queue✓✓

WDK + QVAC

Optional. QVAC runs AI models on the user's own device: LLM chat with tool calling, speech-to-text, text-to-speech, translation, embeddings/RAG and OCR, offline, in Node.js or Expo. No API key, no cloud.

Why combine them

QVAC decides what to do, WDK signs and sends it. Inference and signing both happen on your machine, so an agent can hold a wallet without handing keys or prompts to a third party; only the signed transaction leaves it.

Run the agent

The starter's agent lives in examples/qvac-agent with its own install, so teams that only use WDK skip the download.

npm run agent:install   # ~2 GB (QVAC native runtimes), do it before the venue
npm run agent           # first run downloads a ~1.1 GB model, then it's cached

It turns plain English into a tool call, WDK quotes it, and nothing is sent until you confirm.

you> pay 2 usdc to 0xa982dEFe14513bd83e8cFdF083AD6d3e867D45f0
agent> transfer 2 USDC to 0xa982…45f0? max fee 0.012983954 MON [y/N] y
agent> done: https://testnet.monadvision.com/tx/0xc4cc8d09…

Keep the confirmation. In testing, "pay 1 usdt" once came back as a 0.5 USDT transfer: small models misread amounts.

Add an agent tool

Tools are zod schemas. QVAC's Qwen3 1.7B model picks the tool and fills the arguments; your handler calls WDK.

// examples/qvac-agent/agent.js: one entry in TOOLS = one new agent capability
tx_status: {
  description: 'Look up a transaction by its hash',
  parameters: z.object({ hash: z.string().regex(/^0x[0-9a-fA-F]{64}$/) }),
  run: ({ hash }) => wallet.account.getTransaction(hash),
},
// On-chain writes also set write: true plus quote() and summary(),
// so the agent shows the fee and asks before sending (see send_mon).

What to build with QVAC

The bar: QVAC makes a decision that changes what happens, and WDK holds the keys. A chatbot with a send button is the starter, not a project.

Pay-per-prompt AI

One laptop runs a bigger model and charges 0.001 test USDT per answer. Your agent pays automatically with WDK on every request. Serve it over QVAC's P2P layer or plain HTTP.

Explain before you sign

Before WDK signs, a local model reads the transaction and says what it does in plain words: "this lets contract X spend all your USDC forever." Anything over a limit needs a spoken confirmation.

Receipt splitter

Photo of the bill, QVAC OCR reads the items, the model splits them per person, WDK sends each share in test USDT.

Voice wallet in your language

"Send 5 dollars to Ali" in Turkish or Spanish. Speech-to-text and translation run locally, WDK pays, text-to-speech reads back the confirmation.

Allowance wallet

A parent (or a developer) writes spending rules in plain English: "max 10 USDT a day, no gambling." A local model checks every spend before WDK signs it.

Bounty bot

Post a task, submit the work, the model judges it against the task, WDK pays the bounty after a human approves.

Private bill payer

Point it at a folder of invoices. Amounts, due dates and addresses are extracted on your machine and queued as WDK payments for one-click approval. Your financial documents never touch a cloud.

Live talk tip jar

Speech-to-text runs on a talk, and listeners' agents tip the speaker when they mention a topic you flagged: "tip 0.1 when they say Monad."

Offline market stall

The seller says the price, the app shows a QR, the buyer pays. All the AI works offline; only the transaction needs a connection.

AI dungeon with real loot

A local LLM runs a text adventure. Finding treasure sends test tokens or mints NFTs to the player's WDK wallet (the /tokens contracts are already deployed).

Probably too big for a day: training or fine-tuning models, autonomous trading (a 1.7B model shouldn't make that call), cross-chain bridging.

Verified with @qvac/sdk 0.23.0 on testnet: tool calls, balance lookups and token transfers through WDK. QVAC ships builds for macOS, Linux and Windows; we ran it on Linux.