Paste any token address to instantly view its details, permissions, and available actions. Connect your wallet to mint tokens, manage access, update settings, pause activity, or launch a brand-new B20 token.
RWAGMI turns a raw B20 address into a readable control surface: token basics, roles, supported actions, policy settings, and wallet-ready transactions.
Supply, caps, decimals, pauses, and B20 support show up in one readable place.
Check admins, minters, pausers, policy roles, and connected-wallet permissions fast.
RWAGMI only shows the panels a token actually supports, so the workspace stays calm.
Pick a variant, set roles, and review one prepared wallet call before signing.
A practical walkthrough for token lookup, roles, actions, and the checks worth making before you sign.
Read guide ›Keep the canonical behavior close when exact permissions, policy ids, and token mechanics matter.
Open spec ↗RWAGMI comes from a team that likes shipping careful, useful onchain things. Here is what else we make.
An onchain gaming and entertainment ecosystem on Base, where players truly own their games, creators earn instant royalties, and GameFi rewards flow back to the community through $BAES.
Paste a revert, RPC error, wallet failure, trace, AA code, or x402 payload and get the likely meaning, the evidence, and what to do next — backed by an open catalog of 25k+ entries.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, credit cards, or software downloads. Every action is a transparent wallet transaction on Base.
Use this skill to operate RWAGMI without guessing contract calls. RWAGMI is a wallet-facing operator console for Base B20 tokens; it never custodies keys.
AGENTS.md, then read the source files for the task.@b20/sdk builders and ABIs for calldata. Do not hand-roll selectors when an SDK builder exists.decodeB20Error./create and /launch separate:
/create is generic B20Factory token creation./launch is the RWAGMI liquid B20 Asset launcher path.Base MCP is a remote MCP server at:
For Codex, install/connect it with:
For contract writes, use Base MCP send_calls with approvalMode: "url" when available, then the agent polls get_request_status until the request is signed, executed, rejected, or expired.
Use these chain names for Base MCP calls:
If Base MCP tools are not available, stop before live writes and tell the user to connect Base MCP. Read-only work may continue through repo SDK reads or RPC.
Load current facts from these files before building transactions:
contracts/deployments/base-sepolia.jsoncontracts/deployments/base-mainnet.jsonapps/web/lib/launcher-config.tspackages/b20-sdk/src/create.tspackages/b20-sdk/src/writes.tspackages/b20-sdk/src/launch/config.tspackages/b20-sdk/src/launch/addresses.tspackages/b20-sdk/src/uniswap-v4.tsdocs/runbooks/operator-usage.mddocs/runbooks/operator-launcher.mddocs/runbooks/b20-method-coverage.mdDo not copy deployed addresses from memory. Resolve them from the deployment JSON or public env mapping, then verify the target chain.
Most RWAGMI actions produce a PreparedB20Write. Convert it to the raw call shape expected by Base MCP with viem.encodeFunctionData.
Before sending, show the user:
plan.labelplan.chainIdplan.toplan.functionNameplan.value, if presentplan.requiredRole, if presentplan.warnings entryFor plan.requiresExplicitConfirm, get an explicit confirmation before calling Base MCP.
decodeB20Error(error).message and stop.planToBaseMcpCall.send_calls:get_request_status.Never fall back to cast send --private-key for a live write.
packages/b20-sdk/src/reads.ts and detect support with packages/b20-sdk/src/token-detect.ts.packages/ui-domain/src/action-registry.ts.readKnownRolesForAccount.packages/b20-sdk/src/writes.ts:
Never expose a B20 write just because a method name sounds plausible. The token must support the feature and the SDK must know the ABI.
Use this for /create-style token deployment only.
CreateTokenInput and CreateOptions with packages/b20-sdk/src/create.ts.predictB20Address. For generic creation, the deployer is the user's account.prepareCreateB20.Important creation constraints:
initialAdmin = address(0) means adminless. Do not invent a dead-address admin strategy.bootstrap initCalls are ordered by the SDK. Do not reorder them.Use this for /launch-style RWAGMI launches only.
apps/web/lib/launcher-config.ts.resolveRwagmiFeeConfig.launchDraft from the user inputs with packages/b20-sdk/src/launch/config.ts.launchB20Address with packages/b20-sdk/src/launch/config.ts. For RWAGMI launches, the deployer is the launcher contract address, not the user's account.prepareLaunchB20.parseLaunchReceipt./api/launches/index-transaction; otherwise rely on the normal indexer.Launch invariants:
RwagmiHookV2, not the old static hook.msg.value must equal extension value.initialAdmin = address(0).For launched tokens, read reward info from the locker with readLaunchRewardInfo and use these builders:
prepareCollectLaunchRewards: anyone may harvest accrued v4 LP fees into locker accounting.prepareClaimLaunchRewards: each recipient self-claims credited currency.prepareUpdateLaunchRewardRecipient: reward slot admin rotates recipient.prepareUpdateLaunchRewardAdmin: reward slot admin transfers slot admin.Reward bps are immutable after launch. Slot 0 is creator 90%; slot 1 is RWAGMI 10% unless deployment records prove otherwise.
Owner operations are sensitive. Read the owner first. On Base mainnet, the deployment owner may be a Safe. If the owner is a Safe, do not send an owner-only call from a normal EOA. Prepare calldata and route it through the Safe owner flow the user requests.
Owner-only launcher/locker operations include:
When no prepared SDK builder exists, use the ABI from packages/b20-sdk/src/abi, encode with viem.encodeFunctionData, simulate, and send through Base MCP only after explicit user confirmation.
RWAGMI swap is not an arbitrary aggregator. It trades indexed RWAGMI launch pools directly through Uniswap v4 Universal Router. Use packages/b20-sdk/src/uniswap-v4.ts and the /api/swap/quote route. Quote reads must not trigger indexer writes.
Native ETH swaps route through WETH-backed pools and Universal Router value. Do not require ERC20 Permit2 approval for native input mode.
decodeB20Error and report the decoded reason.NotAuctionBlock: wait for the valid block or tell the user swaps are not yet available.Use the smallest check that proves the change:
Use pnpm smoke:base-sepolia only when RPC, wallet funding, and live launch intent are intentionally available.
The wizard keeps public token profile, admin powers, policy overrides, and init calls readable before signing.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, credit cards, or software downloads. Every action is a transparent wallet transaction on Base.
The launch path stays intentionally narrow: Asset B20, WETH pair, shared locker, mandatory auction module.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, credit cards, or software downloads. Every action is a transparent wallet transaction on Base.
B20 is a native token interface built into Base. It extends ERC-20 with supply controls, role-based access, pause mechanics, policy hooks, and optional Asset or Stablecoin capabilities.
B20 tokens are ERC-20 compatible. Standard methods (transfer, approve, transferFrom, balanceOf, totalSupply, allowance) behave as specified in EIP-20.
| Method | Description |
|---|---|
| name() | Token name string. |
| symbol() | Token symbol string. |
| decimals() | Decimal precision. Fixed to 6 for Stablecoin; configurable for Asset (6–18). |
| totalSupply() | Current circulating supply. |
| balanceOf(account) | Balance held by account. |
| transfer(to, amount) | Move tokens from caller to to. |
| approve(spender, amount) | Set spender allowance. |
| transferFrom(from, to, amount) | Move tokens using an allowance. |
| allowance(owner, spender) | Remaining allowance. |
Minting and burning are gated by roles. A cap is optional and immutable once set.
| Method | Description |
|---|---|
| mint(to, amount) | Create new tokens. Gated by MINTER_ROLE. Respects cap() if set. |
| burn(amount) | Destroy tokens from the caller's balance. |
| burnFrom(from, amount) | Destroy tokens from an approved balance. Gated by BURNER_ROLE. |
| cap() | Max supply. Returns 0 if uncapped. Immutable after creation. |
| Method | Description |
|---|---|
| pause() | Halt all transfers, mints, and burns. Gated by PAUSE_ROLE. |
| unpause() | Restore activity. Gated by UNPAUSE_ROLE. |
| paused() | Returns true if currently paused. |
A paused token blocks all activity. Pause and unpause are separate roles so they can be held by different addresses.
B20 uses OpenZeppelin AccessControl. Each role is a bytes32 slot. The DEFAULT_ADMIN_ROLE can grant or revoke any role.
| Role | Purpose |
|---|---|
| DEFAULT_ADMIN_ROLE | Grant or revoke any role. Keep on a hardware wallet or multisig. |
| MINTER_ROLE | Call mint() and batchMint(). |
| BURNER_ROLE | Call burnFrom() on any holder. |
| POLICY_ADMIN_ROLE | Set or clear policy contracts for transfers, mints, and burns. |
| PAUSE_ROLE | Pause the token. |
| UNPAUSE_ROLE | Unpause the token. |
| METADATA_ROLE | Update profile fields and extraMetadata entries. |
| OPERATOR_ROLE | Run Asset flows: multiplier updates and announcements. |
Transfer, mint, and burn calls can be routed through policy contracts registered in PolicyRegistry. Policies are set by POLICY_ADMIN_ROLE.
| Method | Description |
|---|---|
| transferPolicyId() | Active transfer policy id. 0 means no policy. |
| mintPolicyId() | Active mint policy id. |
| burnPolicyId() | Active burn policy id. |
| setTransferPolicyId(id) | Set transfer policy. Gated by POLICY_ADMIN_ROLE. |
| setMintPolicyId(id) | Set mint policy. Gated by POLICY_ADMIN_ROLE. |
| setBurnPolicyId(id) | Set burn policy. Gated by POLICY_ADMIN_ROLE. |
b20Version() returns a uint256 indicating the B20 feature set the token supports. Use this to check capability before calling optional methods.
On-chain metadata readable by wallets and frontends.
| Method | Description |
|---|---|
| profileName() | Human-readable token name (may differ from ERC-20 name). |
| profileDescription() | Short description of the token. |
| profileImage() | URI for a token image (IPFS, HTTPS, or data URI). |
| profileLink() | Project website or social link. |
| updateProfile(name, description, image, link) | Update all profile fields. Gated by METADATA_ROLE. |
The Asset variant adds a multiplier for rebase-style accounting. The multiplier scales raw balances to display balances. Default multiplier is 1e18 (no scaling).
| Method | Description |
|---|---|
| multiplier() | Current scaling factor (1e18 = 1×). |
| toScaledBalance(raw) | Convert raw amount to scaled display value. |
| toRawBalance(scaled) | Convert scaled amount to raw. |
| updateMultiplier(newMultiplier) | Update the multiplier. Gated by OPERATOR_ROLE. |
On-chain disclosure brackets that wrap sensitive operations (e.g. batch mints, multiplier updates) with a public notice period. Gated by OPERATOR_ROLE.
announce(internalCalls, id, description, uri) emits an Announcement event, executes internalCalls, then emits EndAnnouncement. The id must be unique and is enforced forever. Inner call reverts are wrapped in InternalCallFailed.
batchMint(recipients, amounts) mints to multiple recipients in a single call. Gated by MINT_ROLE. Should be wrapped in announce() for transparency.
An arbitrary key/value store for issuer-defined on-chain metadata.
| Method | Description |
|---|---|
| extraMetadata(key) | Read a value by key. |
| updateExtraMetadata(key, value) | Write a value. Gated by METADATA_ROLE. Setting an empty value removes the entry. |
The fixed-decimals, fiat-backed carveout. Decimals are hard-wired to 6 and are not configurable.
Adds currency(), which returns an ISO-style currency code string (e.g. "USD", "EUR"). The code is set once at creation via B20StablecoinCreateParams.currency, restricted to characters A–Z only. It is self-declared and not verified against any external registry.
These addresses are identical on every network where B20 is active (Mainnet, Base Sepolia, Vibenet, and local base-anvil).
| Precompile | Address |
|---|---|
| B20Factory | 0xB20f000000000000000000000000000000000000 |
| Activation Registry | 0x8453000000000000000000000000000000000001 |
| Policy Registry | 0x8453000000000000000000000000000000000002 |
B20 emits the standard ERC-20 events plus extended events for roles, pause, policy, and Asset flows.
| Event | Description |
|---|---|
| Transfer(from, to, value) | Emitted on every token transfer, mint (from = address(0)), and burn (to = address(0)). |
| Approval(owner, spender, value) | Emitted when an allowance is set via approve or transferFrom. |
| RoleGranted(role, account, sender) | Emitted when a role is granted by the admin. |
| RoleRevoked(role, account, sender) | Emitted when a role is revoked by the admin. |
| RoleAdminChanged(role, previousAdmin, newAdmin) | Emitted when a role's admin role is reassigned. |
| Paused(account) | Emitted when the token is paused. |
| Unpaused(account) | Emitted when the token is unpaused. |
| PolicyUpdated(policyType, oldId, newId) | Emitted when a transfer, mint, or burn policy id changes. |
| MultiplierUpdated(oldMultiplier, newMultiplier) | Asset only. Emitted when the multiplier is updated. |
| Announcement(id, description, uri, caller) | Emitted at the start of an announced operation. |
| EndAnnouncement(id) | Emitted after all internal calls in an announcement complete. |
| InternalCallFailed(id, index, reason) | Emitted when an internal call inside an announcement reverts. |
| ProfileUpdated(name, description, image, link) | Emitted when the on-chain profile is updated. |
| ExtraMetadataUpdated(key, value) | Emitted when an extra metadata entry is written or removed. |
B20 uses custom errors. Decode them with decodeB20Error from the SDK. All standard OpenZeppelin and ERC-20 errors are inherited.
| Error | Cause |
|---|---|
| AccessControlUnauthorizedAccount(account, role) | Caller does not hold the required role. |
| EnforcedPause() | Action attempted while the token is paused. |
| ExpectedPause() | unpause() called while not paused. |
| ERC20InsufficientBalance(sender, balance, needed) | Transfer or burn exceeds available balance. |
| ERC20InsufficientAllowance(spender, allowance, needed) | transferFrom exceeds approved allowance. |
| ERC20InvalidSender(sender) | Transfer from address(0). |
| ERC20InvalidReceiver(receiver) | Transfer to address(0). |
| B20CapExceeded(cap, requested) | Mint would push totalSupply above cap(). |
| B20AnnouncementIdUsed(id) | Announcement id has been used before. |
| B20PolicyRejected(policyId, reason) | An active policy contract blocked the operation. |
| B20InvalidMultiplier(value) | Multiplier is zero or below the allowed minimum. |
| B20InvalidCurrencyCode(code) | Stablecoin currency code contains non A–Z characters. |
| B20InvalidDecimals(decimals) | Decimals outside the 6–18 range (Asset only). |
| B20ZeroAddress() | A required address argument is address(0). |
The factory is a precompile at 0xB20f000000000000000000000000000000000000. It creates deterministic B20 tokens from packed params structs. The deployer address is baked into the salt so two accounts cannot collide on the same name.
| Method | Description |
|---|---|
| createB20Asset(params) | Deploy a new B20 Asset token. Returns the token address. |
| createB20Stablecoin(params) | Deploy a new B20 Stablecoin token. Returns the token address. |
| predictB20AssetAddress(deployer, params) | Compute the deterministic address before deployment. |
| predictB20StablecoinAddress(deployer, params) | Compute the deterministic stablecoin address before deployment. |
| isB20(address) | Returns true if the address was deployed by this factory. |
| b20Count(deployer) | Number of tokens deployed by deployer. |
| b20At(deployer, index) | Token address at a deployer's index. |
Create params structs:
| Field | Type | Notes |
|---|---|---|
| name | string | ERC-20 token name. |
| symbol | string | ERC-20 token symbol. |
| decimals | uint8 | 6–18 for Asset. Fixed 6 for Stablecoin. |
| initialAdmin | address | address(0) for adminless immutable token. |
| cap | uint256 | Max supply. 0 = uncapped. Immutable after creation. |
| initCalls | InitCall[] | Bootstrap calls executed atomically on deploy (role grants, policy setup). Ordered by the SDK. |
| currency | string | Stablecoin only. ISO-style currency code. A–Z only. |
initCalls. The SDK orders them to satisfy role dependencies. Reordering may cause deployment to revert.Policy contracts are registered at 0x8453000000000000000000000000000000000002. A policy id is a uint256 assigned at registration. Id 0 is always the null policy (no restriction).
| Method | Description |
|---|---|
| registerPolicy(policy) | Register a new policy contract. Returns the assigned id. Caller becomes the policy owner. |
| getPolicy(id) | Return the policy contract address for a given id. |
| policyCount() | Total number of registered policies (including id 0). |
| policyOwner(id) | Address that registered the policy. |
A policy contract must implement IB20Policy:
| Method | Description |
|---|---|
| checkTransfer(token, from, to, amount) | Called before every transfer. Revert to block. |
| checkMint(token, to, amount) | Called before every mint. Revert to block. |
| checkBurn(token, from, amount) | Called before every burn. Revert to block. |
The Activation Registry at 0x8453000000000000000000000000000000000001 tracks which networks have B20 active and at what version. It is read-only for most callers.
| Method | Description |
|---|---|
| isActive(chainId) | Returns true if B20 is active on the given chain. |
| activationBlock(chainId) | Block number at which B20 was activated. 0 if not yet active. |
| b20Version(chainId) | Feature-set version active on the chain. |
| activeChains() | Array of chain ids where B20 is currently active. |
Read a B20 token using the SDK and viem:
Mint tokens to an address:
Create a generic B20 Asset:
Was this page helpful?
Use this when you want to know what RWAGMI is showing, which role an action needs, and what to check before you sign. Deployment notes live in the repository docs.
burnBlocked(from, amount) for the account you choose.burnBlocked(from, amount) for blocked accounts.RWAGMI is a wallet-facing console for inspecting and preparing Base B20 token transactions. It is not a custodian, broker, exchange, or financial adviser. It does not hold keys, execute transactions on your behalf, or guarantee any outcome.
You control your wallet and every transaction you sign. RWAGMI shows you what will happen before you sign; reviewing that preview is your responsibility. Blockchain transactions are irreversible.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, or credit cards, and does not require software downloads. If a page claiming to be RWAGMI asks for any of these, it is not RWAGMI. Report suspected impersonation to rwagmicom@gmail.com.
B20 tokens and RWAGMI liquid launches are experimental. Token values can go to zero. Immutable launches are permanent. On-chain actions cannot be undone. You accept full responsibility for tokens you create or trades you make.
RWAGMI is provided as-is with no warranty of availability, fitness, or accuracy. The app may be modified or discontinued at any time.
RWAGMI uses Google tag with Google Analytics measurement id G-26DFKY9QK5. Analytics data does not include wallet secrets and is not used to custody assets or alter transactions.
Questions can be sent to rwagmicom@gmail.com.
See the Privacy Policy for data-handling details.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, credit cards, or software downloads. Every action is a transparent wallet transaction on Base.
RWAGMI does not ask for or store seed phrases, private keys, passwords, phone numbers, or credit card numbers.
RWAGMI does not require software downloads and does not custody tokens or wallet accounts.
When you connect a wallet or paste a token address, the app may read public addresses, balances, roles, token metadata, launch events, pool data, quotes, and transaction receipts from Base, public RPCs, and the local RWAGMI launch index.
Public blockchain data is visible to anyone and is not controlled by RWAGMI.
The app may use browser storage for convenience features such as recently visited tokens, local transaction history for this browser session, wallet connector state, and app preferences.
You can clear this data from your browser settings. Clearing it does not remove public blockchain records.
The server may process routine request data such as URL paths, timestamps, IP-derived network information, user agents, and error logs to operate and secure the site.
The launch indexer stores public RWAGMI launch data in SQLite so token and swap pages can read indexed launch pools without triggering write scans from quote requests.
If you use token profile upload features, images and metadata you provide may be sent to configured storage infrastructure such as Pinata/IPFS gateways and become publicly accessible.
Do not upload private, illegal, or sensitive personal information as token metadata.
RWAGMI uses the Google tag with Google Analytics measurement id G-26DFKY9QK5 to understand site traffic, page usage, referrals, device and browser categories, and basic engagement.
Google may process analytics identifiers, approximate location, user agent, page URLs, referrers, and related technical information under its own policies. You can use browser settings, extensions, or Google controls to limit analytics tracking.
Wallets, wallet connector infrastructure, RPC providers, explorers, storage gateways, and Uniswap-related infrastructure may process data under their own policies.
RWAGMI loads Google tag from googletagmanager.com for analytics. It does not use analytics to ask for wallet secrets, custody assets, or change transaction behavior.
Privacy, security, and site-review questions can be sent to rwagmicom@gmail.com.
See the Terms of Service for wallet-use and transaction-risk terms.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, credit cards, or software downloads. Every action is a transparent wallet transaction on Base.
Drop any Base B20 contract address into the lookup box. RWAGMI reads the token name, symbol, supply, cap, decimals, pause state, and B20 version directly from the chain.
RWAGMI reads the key role slots and compares them against your connected wallet. This tells you which action panels are likely to succeed before you sign anything.
Role reads are hints, not guarantees. The chain is always the final authority.
Only the panels this token actually supports are shown. Each panel prepares one wallet call. You read it, then decide whether to sign.
Good habit: verify the token address against a trusted source before interacting. Paste-and-check takes ten seconds and removes the most common mistake.
Enter an amount and a recipient address. RWAGMI prepares the mint call. The minter role is required. Supply cap, if set, is checked before the call goes to your wallet.
Specify an amount to burn from your own wallet. The token must support burnFrom or the holder burns directly. This action is irreversible.
Standard ERC-20 transfer wrapped in a reviewable panel. Transfer policy, if active, may block or restrict the call.
Pause stops all transfers, mints, and burns. Unpause restores them. Both require the respective role. A paused token shows a visible warning on its dashboard.
One call, one review: RWAGMI never batches actions without telling you. You always see exactly what will be sent to your wallet before you tap confirm.
Some actions get one extra checkbox because they can move real power: admin role changes, transfer pause, supply expansion, multiplier updates, and burnBlocked.
Role reads are helpful hints. If a check fails or is unknown, RWAGMI warns you, but the chain is still the final source of truth.
Check policy ids in PolicyRegistry before applying them. The wrong allowlist or blocklist id can freeze normal transfers.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, credit cards, or software downloads. Every action is a transparent wallet transaction on Base.
Each token keeps pool, creator, supply, and launch details. Swaps route through the dedicated trade flow seeded with this token.
Launch a token, then refresh this list. RWAGMI will add confirmed launches as they appear.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, credit cards, or software downloads. Every action is a transparent wallet transaction on Base.
RWAGMI never asks for seed phrases, private keys, passwords, phone numbers, credit cards, or software downloads. Every action is a transparent wallet transaction on Base.