Getting Started
How it Works
A complete walkthrough of the inscription lifecycle — from wallet connection to confirmed on-chain state.
Overview
Every Monadinals action follows the same lifecycle: you compose a JSON payload, submit it to the MonadInscriptions contract, and the contract emits an event that indexers consume to update balances. There are no approval flows, no complex multi-step transactions — just a single signed call per operation.
Step-by-step lifecycle
Connect your wallet
Open the Monadinals app and connect any EVM-compatible wallet (MetaMask, Rabby, etc.) to Monad Testnet (Chain ID 10143). Your address becomes the signer and initiator of all inscription operations.
Choose an operation
Navigate to the Inscribe panel and select Deploy, Mint, or Transfer. Each operation maps directly to a distinct JSON payload structure defined by the MON-20 standard.
Fill in the parameters
Enter the required fields — ticker, amount, limits, recipient address — depending on the operation type. The UI validates inputs and computes the total protocol fee in real time.
Sign and submit
Click Inscribe. Your wallet prompts you to sign a transaction to the MonadInscriptions contract address, attaching the JSON payload as calldata and the exact protocol fee as msg.value.
Contract validates
The on-chain contract decodes and validates the payload — checking ticker format, supply limits, fee amount, and authorization. If any check fails the transaction reverts and no fee is charged.
Event emitted
On success, the contract emits an Inscribed event containing the full payload, the caller address, and the block timestamp. This event is immutable — it cannot be edited or deleted.
Indexer processes the event
Off-chain indexer infrastructure subscribes to Inscribed events in real time. Each event is decoded, validated against protocol rules, and applied to the derived state — updating token supply, balances, and the explorer.
What happens on-chain
The MonadInscriptions contract is intentionally minimal. It does not store balances, does not track holders, and does not know anything about individual token tickers. Its only responsibilities are:
- Accept the protocol fee (10 MON per operation)
- Validate the basic shape of the calldata (non-empty, well-formed)
- Emit the Inscribed event with msg.sender, block.timestamp, and the raw payload
- Accumulate collected fees for protocol treasury withdrawal
No on-chain state
What the indexer does
The off-chain indexer is the source of truth for all derived state. When it reads an Inscribed event, it applies the following logic in order:
Parse the payload
Decode the JSON from the event. If the JSON is malformed or missing required fields, the inscription is ignored — it is not applied to state.
Check the operation type
Read the op field: deploy, mint, or transfer. Each type triggers a different validation and state-mutation path.
Apply protocol rules
For deploy: check that the ticker is not already registered. For mint: check supply limits and per-wallet limits. For transfer: check the sender has sufficient balance.
Update derived state
Commit the state change — register the ticker, increase supply/balance, or move balance between addresses. The event block number and index determine ordering in case of ties.
Indexer is not the contract
Transaction anatomy
Every Monadinals transaction has the same structure:
{"to": "0xMonadInscriptionsContract","value": "10000000000000000000","data": "<ABI-encoded inscribe(string payload)>","payload": {"p": "mon-20","op": "mint","tick": "moni","amt": "5000"}}
The value field carries the protocol fee (10 MON = 10 × 1018 wei). The data field is the ABI-encoded call to inscribe(string) where the string argument is the JSON payload.
Repeat minting
The Inscribe UI supports a repeat count for mint operations. Setting repeat to N submits N separate transactions in sequence, each with its own 10 MON fee. The UI will display the total cost before you confirm.