B20 Token Launcher & B20Kit
From B20 token creation to utility-enabled token workflows. GitLumen introduces a staged B20 infrastructure path to help builders launch, inspect, manage, and later add utility to B20 tokens on Base.
B20Kit depends on a healthy base of B20 tokens.
Before users can add payment flows, review credits, token facts, or application-level utility, they first need a simple way to create and inspect B20 tokens. The B20 Token Launcher is the entry point.
The launcher is intentionally focused. It does not attempt to introduce all B20Kit features at once. Its purpose is to make B20 issuance accessible, visible, and understandable.
The launcher helps users
- Create B20 tokens on supported Base networks
- Understand the B20 token standard
- Choose between available token variants
- Inspect token metadata
- View token ownership and configuration
- Scan deployed B20 tokens
- Manage tokens created through GitLumen’s B20 interface
- Automatically generate a B20 Agent for each launched token
- Prepare tokens for future B20Kit utility features
Launch and explore B20 tokens on Base.
At the current stage, GitLumen B20 is focused on launch and exploration. Every B20 token launched through GitLumen automatically gets its own B20 Agent.
Token Deployment
Deploy B20 tokens on supported testnet environments — name, symbol, variant, supply cap, metadata, and network.
Token Management
Revisit tokens with address, variant, decimals, supply, admin status, metadata status, and deployment history.
Token Scanner
Inspect any B20 token by address — validity, initialization, roles, policies, pause status, and supply.
My Tokens
See the tokens you have created or interacted with through GitLumen’s B20 interface.
B20 Agent
An automatically generated, token-specific AI Agent for every token launched through GitLumen.
GitLumen checks readiness before enabling sensitive actions.
B20 adoption depends on network readiness. GitLumen should not assume that every B20 feature is active on every network.
If a network is not ready, the interface should clearly communicate that B20 deployment or B20Kit utility features are unavailable. This protects users from failed transactions.
Runtime readiness may include
- B20 activation status
- Supported network
- B20Factory availability
- Token variant availability
- Valid & initialized token detection
- B20 Agent generation availability
- Agent access to verified token facts
- Simulation before transaction submission
From token creation to real application utility.
Launcher: How do I create and inspect a B20 token?
B20Kit: How do I use a B20 token inside a real application workflow?
The B20 Token Launcher is the first step. B20Kit is the next layer — it expands the launcher into a utility infrastructure layer for B20 tokens.
B20Kit is designed to support memo-based token payments, review credit invoices, webhook confirmations, token facts pages, B20 Agent interfaces, issuer operations, token scanning, app-level credit systems, and optional SDK/API access for other projects.
The first internal use case is GitLumen Review Credits. Broader external utility is introduced after the internal GitLumen integration is stable.
Two clear responsibilities, kept separate.
GitLumen — Review Intelligence
- Pull request ingestion
- Diff parsing
- Context indexing
- Review intelligence & risk mapping
- Review chapters & decision questions
- Merge-readiness signals
- GitHub synchronization
B20Kit — Token Utility
- Review credit creation
- Memo generation & payment confirmation
- Credit consumption
- Token facts & B20 Agent context
- Issuer visibility
- Webhook delivery
- Audit logs for token-enabled actions
Connect an offchain review run to an onchain payment.
A review credit represents access to a token-enabled GitLumen workflow such as advanced review intelligence, deeper risk analysis, or high-complexity PR review — without exposing repository data onchain.
Review run created
A GitLumen review run is initiated for a pull request.
B20Kit invoice generated
An invoice is created for the review credit.
Privacy-safe memo created
An opaque memo links the invoice to the payment.
User pays with B20 memo transfer
Payment is sent as a Transfer with the generated memo.
B20Kit detects Transfer + Memo
The payment and memo are matched onchain.
Payment confirmed
B20Kit validates the transfer against the invoice.
GitLumen unlocks advanced review
The token-enabled workflow becomes available.
Credit consumed
The credit lifecycle completes.
Only opaque memo values are written onchain.
B20Kit uses B20 memo transfers to connect token activity with application activity. For GitLumen, this means a payment can be linked to a review run without exposing sensitive information.
secret, reviewRunId, teamId,
chainId, tokenAddress, amount,
expiresAt, nonce
) ✓ bytes32
Never written onchain
Repository Name
Never exposed in memo or transfer data.
PR Number & Org Name
Kept entirely offchain.
Username & Team Metadata
Stored only in GitLumen’s offchain mapping.
Code, Diffs & Review Output
File paths, code, diffs, and vulnerability details stay offchain.
A deterministic lifecycle for token-enabled access.
created
The invoice for the review credit is created.
awaiting_payment
B20Kit waits for a matching onchain transfer.
submitted
A transaction referencing the memo is observed.
detected
Transfer and memo are matched to the invoice.
confirmed
Chain ID, token, recipient, amount, and memo are validated.
consumed
The credit unlocks its GitLumen workflow.
Alternative states
A payment should not be marked confirmed only because a transaction exists. B20Kit validates chain ID, token address, recipient, amount, memo, invoice expiration, confirmation threshold, duplicate usage, and invoice status.
Notify GitLumen when a token-enabled action is confirmed.
Example events
- review_credit.created
- review_credit.awaiting_payment
- review_credit.submitted
- review_credit.detected
- review_credit.confirmed
- review_credit.consumed
- review_credit.expired
- review_credit.refunded
- review_credit.failed
Webhook delivery includes an HMAC signature, timestamp, idempotency key, retry logic, replay protection, delivery logs, and manual replay controls.
The most important event for GitLumen is payment.confirmed. After this event is received, GitLumen unlocks the relevant advanced review workflow.
Every B20 token gets its own AI Agent.
The B20 Agent is not a generic chatbot. It is generated from the token’s actual launch context — token details, mint data, network, supply, metadata, admin configuration, scanner status, and token facts.
At the launcher stage, the agent stays explanation-first and safety-aware. It describes observable token data and guides users through issuer tools without implying investment value or guaranteed security.
Create a B20 token on GitLumen, and you automatically get a B20 Agent for it.
A transparency layer for tokens created through GitLumen.
Token facts describe what is observable onchain without implying endorsement, investment value, or security guarantees.
Read-only first, write operations added gradually.
Read-Only Today
- Token profile
- Role & policy visibility
- Supply visibility
- Pause state & metadata view
- Token facts preview
- B20 Agent preview
- Scanner history
Potential Future Write Ops
- Metadata & contract URI updates
- Supply cap updates
- Policy & role management
- Pause or unpause actions
- Agent context refresh
High-risk operations always require clear warnings, transaction simulation, confirmation steps, and audit logs.
A reusable B20 utility toolkit for builders on Base.
Although B20Kit begins inside GitLumen, it can later be opened as an optional utility layer for other projects using B20 tokens. The recommended path is to prove B20Kit inside GitLumen first, then gradually open it to external projects.
Token Launch & Inspection
B20 token launch, token inspection, and scanning.
Memo Invoices & App Credits
Memo-based invoices and application-level token utility.
Webhook Confirmations
Payment status tracking for external workflows.
Token Facts & Agent Pages
Reusable transparency and AI Agent surfaces.
Issuer Dashboards
Issuer-facing dashboards for external teams.
From token launcher to public B20Kit toolkit.
Stage One — B20 Token Launcher
Deploy, manage, and scan B20 tokens, view my tokens, auto-generate a B20 Agent, and show network readiness. Goal: help users create and understand B20 tokens.
Stage Two — Launcher Plus
Token facts page, role and policy visibility, pause status, scanner improvements, and B20 Agent explanation view. Goal: help users understand token configuration and readiness.
Stage Three — B20Kit Alpha
Memo invoices, review credit invoices, Transfer + Memo detection, payment confirmation, and basic credit lifecycle. Goal: connect token payments to real application workflows.
Stage Four — GitLumen Review Credits
Review run invoice, privacy-safe memo, payment confirmation, and advanced review unlock. Goal: power GitLumen’s token-enabled review credits.
Stage Five — Public B20Kit Toolkit
API keys, SDK helpers, webhook documentation, embeddable components, and an issuer console. Goal: let other projects use B20Kit for token utility.
A utility layer, not a financial product.
B20Kit supports token creation, review credits, advanced access, memo-based payment accounting, token facts, B20 Agents, issuer operations, and application-level utility.
It should not be framed as investment infrastructure, yield infrastructure, or a promise of future token value. GitLumen’s core product remains review intelligence — B20Kit adds a token utility path for users and builders who want B20-based workflows on Base.
Launch first, utility next.
Launch First, Utility Next
The launcher is the entry point; B20Kit is the expansion layer.
Product Utility Over Speculation
Built around application usage, review credits, and payment reconciliation — not price or yield.
Privacy by Default
Only opaque memo values are written onchain. Repository and review data stay offchain.
Runtime Safety
Network readiness and token validity are checked before enabling deployment, payment, or utility features.
Agent Grounding
B20 Agents are grounded in token data, scanner output, and token facts — no unsupported claims.
Gradual Expansion
B20Kit proves itself inside GitLumen first, then expands to external projects.
Launch B20 tokens. Then make them useful.
GitLumen B20 begins as a B20 Token Launcher: a focused interface for creating, managing, inspecting, and explaining B20 tokens on supported Base networks. Every token launched through GitLumen automatically gets its own B20 Agent.
As B20 adoption matures, the launcher evolves into B20Kit: a utility layer for memo payments, review credits, webhook confirmations, token facts, B20 Agents, and issuer operations — inside GitLumen first, and later, inside other projects on Base.