Introduction
What is Bot Domains and how does it work?
Bot Domains is a decentralized name system built on BOT Chain. Every .bot domain is an ERC-721 NFT minted directly to your wallet. No central authority can revoke, reassign, or expire it.
ERC-721 NFT on BOT Chain. Yours forever.
Bio, links, and images stored permanently on-chain.
Forward and reverse resolution for wallets and dApps.
Non-custodial peer-to-peer domain trading.
Builder Platform
A simple path from registration to trusted, on-chain work
Builders register a profile with their wallet to become eligible to discover jobs, apply for work, and build a public reputation on the platform.
A profile can show a domain name, skills, experience, completed jobs, total points, XP, current level, and earned badges so employers can understand who they are hiring.
Meaningful platform activity and completed work can contribute points and XP. XP drives progression through levels, while points make activity and reputation easy to compare publicly.
Badges represent achievements and reputation milestones. They give builders a clear way to show consistency, experience, and the strengths they have demonstrated.
Builders Page: Employers can browse and search registered builders, then filter discovery by skills, level, points, completed jobs, and other available profile criteria. This makes it easier to find the right person before starting a conversation or job.
Jobs System
The Jobs system connects employers and builders through a transparent lifecycle. Employers post a job, builders submit applications, and the employer accepts the application that best fits the work.
Post a job
An employer publishes the work, requirements, and terms.
Apply
Builders review the listing and submit an application with their profile and experience.
Accept
The employer selects an application and starts the engagement.
Fund escrow
Payment is placed into escrow before work begins, keeping the agreed funds visible and protected by the contract.
Start and deliver
The builder starts work and submits the finished deliverable for review.
Release payment
After approval, the employer releases payment from escrow.
Withdraw
The builder withdraws the released payment to their wallet.
Complete or close
The job is marked completed after successful delivery, or closed when it ends without completion.
Privacy & Encryption
Sensitive job interactions and messages are encrypted so private communication is not exposed as ordinary public content. On-chain data is designed to provide verifiable status and ownership while limiting sensitive details; users should still avoid placing confidential information in public transaction data.
Architecture
How the system components fit together
DomainMarketplace.solDeployedMarketplace Contract
Non-custodial offer/accept marketplace. Holds BOT escrow in-contract. No custody by Bot Domains team.
DomainNFT.solDeployedCore NFT Contract
ERC-721 contract that owns all domain data — name, profile, social links, custom links. Deployed and immutable.
DomainChat.solDeployedChat Contract
Decentralized messaging protocol for domain owners.
botResolver.solDeployedResolver Contract
Independent resolver for forward/reverse resolution and primary domain registration. Reads DomainNFT via interface.
Design principle: The Resolver is completely independent from the DomainNFT. It interacts through the IDomainNFT interface and never modifies NFT storage. Future upgrades to resolution logic can be deployed as new Resolver contracts without touching the NFT contract.
Smart Contracts
Contract addresses and key interfaces
BOT Chain
Contract Addresses
DomainNFT0xBeB7B2BD305F0d9412EB1f4C49541FD048C363CELiveDomainMarketplace0x209c8E27eE0f973106A363Aca5D335038d17153ALiveDomainChat0x349A9312eC2A962d41cb1BD62Ffb2D1dDeA56747LivebotResolver0xf9c1AeED9073382028D09B77A9691FC4408EFD2ALiveKey DomainNFT Functions
// Minting function isAvailable(string memory domainName) view returns (bool) function mintDomain(string memory domainName) payable returns (uint256) function mintFee() view returns (uint256) // Resolution function getTokenIdByName(string memory domainName) view returns (uint256) function getNameByTokenId(uint256 tokenId) view returns (string) function getFullDomainName(uint256 tokenId) view returns (string) function getDomainsOfOwner(address owner) view returns (uint256[]) // Profile function getProfile(uint256 tokenId) view returns ( string domainName, address owner, string profilePicture, string coverImage, string bio, string background, SocialLink[] socialLinks, CustomLink[] customLinks ) function updateProfile(uint256 tokenId, string profilePicture, string coverImage, string bio, string background)
Key botResolver Functions
// Primary domain — write (requires ownership) function setPrimaryDomain(uint256 tokenId) external function clearPrimaryDomain() external // Primary domain — read function getPrimaryToken(address wallet) view returns (uint256) function getPrimaryDomain(address wallet) view returns (string) function hasPrimaryDomain(address wallet) view returns (bool) function isPrimaryOwner(address wallet, uint256 tokenId) view returns (bool) // Resolution function reverseResolve(address wallet) view returns ( uint256 tokenId, string domainName, string fullDomain ) function resolve(string domain) view returns ( address owner, uint256 tokenId, string fullDomain ) // Future records (reserved — returns safe defaults now) function getTextRecord(uint256 tokenId, string key) view returns (string) function getAddressRecord(uint256 tokenId, uint256 coinType) view returns (address) function getContentHash(uint256 tokenId) view returns (bytes)
Resolver Standard
How resolution works in the .bot name system
Forward Resolution
Maps a human-readable .bot domain to its owner address and token ID. Delegates directly to the DomainNFT contract — always reflects current on-chain state.
alice.bot ──resolve()──► { owner: "0xAlice...", tokenId: 42, fullDomain: "alice.bot" }Reverse Resolution
Maps a wallet address to its self-designated primary .bot domain. Ownership is re-verified on every call — stale data is never returned.
0xAlice... ──reverseResolve()──► { tokenId: 42, domainName: "alice", fullDomain: "alice.bot" }
If ownership transferred since setPrimaryDomain() was called:
0xAlice... ──reverseResolve()──► { tokenId: 0, domainName: "", fullDomain: "" }Primary Domains
When a wallet owns multiple .bot domains it can designate one as its Primary Domain. This is the domain shown in wallets and block explorers via reverse resolution.
// Set primary — caller must own tokenId resolver.setPrimaryDomain(42); // Clear primary resolver.clearPrimaryDomain(); // Check primary resolver.hasPrimaryDomain(wallet); // → true/false resolver.getPrimaryDomain(wallet); // → "alice" resolver.getPrimaryToken(wallet); // → 42 resolver.isPrimaryOwner(wallet, 42); // → true
Future Record Types
The botResolver storage layout reserves space for ENS-compatible record types. These are read-only stubs today — they return safe defaults without reverting.
| Record Type | Key / Coin Type | Example | Status |
|---|---|---|---|
| Text record | avatar | ipfs://Qm... | Reserved |
| Text record | description | On-chain identity | Reserved |
| Text record | com.twitter | @alice | Reserved |
| Text record | com.github | alice | Reserved |
| Address record | SLIP-44: 60 (ETH) | 0xAlice... | Reserved |
| Address record | SLIP-44: 0 (BTC) | bc1q... | Reserved |
| Address record | SLIP-44: 501 (SOL) | Gh7k... | Reserved |
| Content hash | IPFS CID / ENS encoding | ipfs://Qm... | Reserved |
| Avatar hash | avatarHash | Qm... | Reserved |
Resolution APIs
HTTP endpoints for resolution, profiles, and ownership
All endpoints are served from the Bot Domains Next.js application. Responses follow the standard envelope:
{
"ok": true,
"data": { ... },
"meta": { "chain": "BOT Chain", "chainId": 677, "timestamp": "2024-01-01T00:00:00Z" }
}
// Errors:
{ "ok": false, "error": "Domain not found or not yet minted", "code": 404 }/api/resolve/:domainForward resolution — maps a .bot domain name to its owner and token ID.
/api/reverse/:walletReverse resolution — maps a wallet address to its primary .bot domain (requires botResolver).
/api/profile/:domainReturns the full on-chain profile: bio, social links, custom links, images.
/api/token/:tokenIdReturns profile data by ERC-721 token ID.
/api/owner/:walletReturns all .bot domains owned by a wallet.
/api/primary/:walletReturns the primary .bot domain for a wallet (requires botResolver).
/api/records/:domainReturns all records for a domain: profile fields, social links, text records.
Example Responses
// GET /api/resolve/alice
{
"ok": true,
"data": {
"domain": "alice",
"owner": "0xAbCd...1234",
"tokenId": "42",
"fullDomain": "alice.bot"
},
"meta": { "chain": "BOT Chain", "chainId": 677, "timestamp": "..." }
}
// GET /api/profile/alice
{
"ok": true,
"data": {
"domain": "alice",
"owner": "0xAbCd...1234",
"tokenId": "42",
"fullDomain": "alice.bot",
"profile": {
"bio": "Building on BOT Chain",
"profilePicture": "https://...",
"socialLinks": [{ "platform": "twitter", "url": "https://twitter.com/alice", "icon": "twitter" }],
"customLinks": [{ "title": "My Website", "url": "https://alice.xyz" }]
}
}
}
// GET /api/owner/0xAbCd...1234
{
"ok": true,
"data": {
"wallet": "0xAbCd...1234",
"count": 3,
"domains": [
{ "tokenId": "42", "domain": "alice", "fullDomain": "alice.bot" },
{ "tokenId": "57", "domain": "alicedev", "fullDomain": "alicedev.bot" }
]
}
}Agent APIs
AI agent endpoints — status, OpenAPI spec, and unsigned transaction generation
The Agent API provides AI-agent-friendly endpoints for health checks, machine-readable spec discovery, and unsigned transaction payload generation. No authentication is required. Transaction endpoints return payloads only — the user's wallet must sign and broadcast independently.
AI plugin manifest: /.well-known/ai-plugin.json · OpenAPI spec: /agent/docs/openapi.yaml · MCP manifest: /mcp/botdomains-mcp.json
/agent/statusHealth check — returns API status, chain connectivity, and live contract addresses.
/agent/docs/openapi.yamlOpenAPI 3.1 specification (YAML). Import into ChatGPT, Cursor, or any OpenAPI-compatible tool.
/agent/tx/mintGenerate an unsigned mint transaction payload. Body: { domain: string }.
/agent/tx/set-primaryGenerate an unsigned set-primary-domain transaction. Body: { tokenId: number, wallet: string }.
/agent/tx/update-profileGenerate an unsigned update-profile transaction. Body: { tokenId, bio, profilePicture, coverImage, background }.
/agent/tx/transferGenerate an unsigned ERC-721 transfer transaction. Body: { tokenId: number, from: string, to: string }.
Example: Status Response
// GET /agent/status
{
"ok": true,
"status": "operational",
"chain": "BOT Chain",
"chainId": 677,
"contracts": {
"domainNFT": "0xBeB7B2BD305F0d9412EB1f4C49541FD048C363CE",
"marketplace": "0x209c8E27eE0f973106A363Aca5D335038d17153A"
},
"timestamp": "2026-07-21T00:00:00Z"
}Example: Mint Transaction Payload
// POST /agent/tx/mint { "domain": "alice" }
{
"ok": true,
"transaction": {
"to": "0xBeB7B2BD305F0d9412EB1f4C49541FD048C363CE",
"data": "0x...",
"value": "500000000000000",
"chainId": 677
},
"domain": "alice",
"fullDomain": "alice.bot",
"mintFee": "0.1 BOT"
}Future APIs
Planned endpoints — documented now, arriving in upcoming releases
These endpoints are planned and documented here for integrators to prepare against. They will return 501 Not Implemented until the underlying contract or indexer infrastructure is ready.
/api/text/:domain/:keyReturns a text record by key (avatar, email, twitter…)
/api/address/:domain/:coinReturns the address record for a coin type (ETH, BTC, SOL)
/api/avatar/:domainReturns the resolved avatar URL for a domain
/api/contenthash/:domainReturns the IPFS / content hash for a domain
/api/multicallBatch multiple resolution calls in a single HTTP request
/api/batch-resolveResolve multiple domain names in one request
/api/searchFull-text search across registered domains
/api/metadata/:tokenIdERC-721 metadata JSON for OpenSea / wallets
/api/verify/:domain/:walletVerify that a wallet currently owns a domain
/api/statsProtocol statistics: total domains, daily mints, floor price
/api/market/history/:domainHistorical marketplace sales for a domain
/api/market/salesGlobal sales feed ordered by recency
/api/activity/:domainFull on-chain activity log for a domain
/api/qr/:domainReturns a QR code image for a profile URL
/api/og/:domainOpenGraph card image for social sharing
SDK & Examples
Code samples in JavaScript, TypeScript, ethers v6, and viem
Installation
npm install ethers viem @rainbow-me/rainbowkit wagmi
Forward Resolution — ethers v6
import { ethers } from "ethers";
const DOMAIN_NFT = "0xBeB7B2BD305F0d9412EB1f4C49541FD048C363CE";
const RPC = "https://rpc.botchain.ai";
const DOMAIN_NFT_ABI = [
"function getTokenIdByName(string) view returns (uint256)",
"function ownerOf(uint256) view returns (address)",
"function getFullDomainName(uint256) view returns (string)",
];
async function resolve(domain: string) {
const provider = new ethers.JsonRpcProvider(RPC);
const nft = new ethers.Contract(DOMAIN_NFT, DOMAIN_NFT_ABI, provider);
const tokenId = await nft.getTokenIdByName(domain.replace(/\.bot$/, ""));
if (tokenId === 0n) return null;
const owner = await nft.ownerOf(tokenId);
const fullDomain = await nft.getFullDomainName(tokenId);
return { owner, tokenId: tokenId.toString(), fullDomain };
}
const result = await resolve("alice");
console.log(result);
// → { owner: "0xAbCd…", tokenId: "42", fullDomain: "alice.bot" }Reverse Resolution — ethers v6
const RESOLVER_ABI = [
"function reverseResolve(address) view returns (uint256, string, string)",
"function hasPrimaryDomain(address) view returns (bool)",
];
async function reverseResolve(wallet: string) {
const provider = new ethers.JsonRpcProvider(RPC);
const resolver = new ethers.Contract(RESOLVER_ADDRESS, RESOLVER_ABI, provider);
const has = await resolver.hasPrimaryDomain(wallet);
if (!has) return null;
const [tokenId, domainName, fullDomain] = await resolver.reverseResolve(wallet);
return { tokenId: tokenId.toString(), domainName, fullDomain };
}Forward Resolution — viem
import { createPublicClient, http, defineChain } from "viem";
const botChain = defineChain({
id: 677,
name: "BOT Chain",
nativeCurrency: { name: "BOT", symbol: "BOT", decimals: 18 },
rpcUrls: { default: { http: ["https://rpc.botchain.ai"] } },
blockExplorers: { default: { name: "BOT Chain Explorer", url: "https://scan.botchain.ai" } },
});
const client = createPublicClient({
chain: botChain,
transport: http(),
});
const tokenId = await client.readContract({
address: "0xBeB7B2BD305F0d9412EB1f4C49541FD048C363CE",
abi: [{ name: "getTokenIdByName", type: "function",
inputs: [{ name: "domainName", type: "string" }],
outputs: [{ name: "", type: "uint256" }], stateMutability: "view" }],
functionName: "getTokenIdByName",
args: ["alice"],
});HTTP API — JavaScript fetch
// Forward resolve
const res = await fetch("/api/resolve/alice");
const { data } = await res.json();
console.log(data.owner, data.tokenId);
// Reverse resolve
const r2 = await fetch("/api/reverse/0xAbCd...1234");
const { data: d2 } = await r2.json();
console.log(d2.fullDomain); // "alice.bot"
// Full profile
const r3 = await fetch("/api/profile/alice");
const { data: d3 } = await r3.json();
console.log(d3.profile.bio, d3.profile.socialLinks);
// All domains for a wallet
const r4 = await fetch("/api/owner/0xAbCd...1234");
const { data: d4 } = await r4.json();
console.log(d4.count, d4.domains);Set Primary Domain — ethers v6
const RESOLVER_ABI = [
"function setPrimaryDomain(uint256 tokenId) external",
"function clearPrimaryDomain() external",
];
// Connect a signer (user wallet)
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const resolver = new ethers.Contract(RESOLVER_ADDRESS, RESOLVER_ABI, signer);
// Set token #42 as primary
const tx = await resolver.setPrimaryDomain(42);
await tx.wait();
console.log("Primary domain set on-chain");
// Clear primary domain
const tx2 = await resolver.clearPrimaryDomain();
await tx2.wait();Integration Guides
How to integrate Bot Domains into wallets, explorers, and dApps
Wallet Integration
Display a human-readable .bot name in place of raw wallet addresses using reverse resolution.
- 1.Call GET /api/reverse/{wallet} or reverseResolve() on the botResolver contract
- 2.If the wallet has a primary domain, display it as "alice.bot" in place of "0xAbCd…"
- 3.Fall back to the shortened address when no primary domain is set
- 4.Cache results for 30–60 seconds; re-fetch on block confirmations
Block Explorer Integration
Show human-readable .bot names on address pages and transaction lists.
- 1.For each address, call GET /api/reverse/{address} to check for a primary domain
- 2.Display "alice.bot" as the label alongside the address
- 3.Link the name to the Bot Domains profile: botdn.com/alice
- 4.For domain pages, call GET /api/profile/{domain} to show profile details
dApp Integration
Resolve .bot names entered by users as recipients or identifiers.
- 1.When a user types a .bot name, call GET /api/resolve/{domain}
- 2.Use the returned owner address for the on-chain transaction
- 3.Display "alice.bot → 0xAbCd…" for transparency before signing
- 4.Always re-verify ownership immediately before sending funds
Profile Lookup
Fetch rich profile data (bio, avatar, social links) for any .bot domain.
- 1.Call GET /api/profile/{domain} to get the full profile
- 2.Render profilePicture as the avatar
- 3.Link socialLinks to their respective platforms
- 4.Use customLinks to build a link-in-bio style display
Payment Systems
Accept .bot domain names as payment destinations.
- 1.Allow users to enter a .bot name in the "Send to" field
- 2.Resolve the name to an address via GET /api/resolve/{domain}
- 3.Confirm the resolved address with the user before submitting
- 4.Re-verify ownership at transaction time to guard against transfers
OpenAPI
Machine-readable API specification
The full OpenAPI 3.1 specification is live and served at /agent/docs/openapi.yaml with Content-Type: application/yaml. Import it into ChatGPT, Cursor, Swagger UI, or any OpenAPI-compatible tool. Below is an abridged view of the Resolution API paths.
openapi: "3.1.0"
info:
title: Bot Domains Resolution API
version: "1.0.0"
description: HTTP API for resolving .bot domain names on BOT Chain
servers:
- url: https://botdn.com
description: Production
paths:
/api/resolve/{domain}:
get:
summary: Forward resolution
parameters:
- name: domain
in: path
required: true
schema: { type: string, example: "alice" }
responses:
"200":
description: Resolved domain
content:
application/json:
schema:
$ref: "#/components/schemas/ResolveResponse"
"404":
description: Domain not found
/api/reverse/{wallet}:
get:
summary: Reverse resolution
parameters:
- name: wallet
in: path
required: true
schema: { type: string, example: "0xAbCd...1234" }
responses:
"200":
description: Primary domain for wallet
components:
schemas:
ResolveResponse:
type: object
properties:
ok: { type: boolean }
data:
type: object
properties:
domain: { type: string }
owner: { type: string }
tokenId: { type: string }
fullDomain: { type: string }
meta:
type: object
properties:
chain: { type: string }
chainId: { type: integer }
timestamp: { type: string, format: date-time }Security
How Bot Domains protects user assets
Domain NFTs are held in user wallets. Bot Domains never has custody of your tokens or funds.
The Resolver re-verifies token ownership on every read — stale reverse-resolve data is never returned.
The botResolver is deployed separately and cannot modify any DomainNFT state.
Offer amounts are held in the DomainMarketplace contract itself, not by any third party.
The Marketplace uses a reentrancy guard pattern. Profile-only functions in DomainNFT carry no BOT risk.
Contracts are deployed without proxy patterns. Code is immutable once deployed — no admin backdoor.
Encrypted Forms
Secure, end-to-end encrypted Web3 forms — only the owner can decrypt responses
Encrypted Forms is a built-in feature available to every Bot Domains holder inside Workspace. It lets you create Web3-native forms where responses are encrypted in the respondent's browser before they are stored — meaning the platform never sees the plaintext content, and only you (the form owner) can decrypt the responses.
What It Is
Encrypted Forms allows any Bot Domains holder to publish custom forms — questionnaires, applications, surveys, event registrations, and more — where every response is end-to-end encrypted. Responses are stored via IPFS and are inaccessible to the platform, third parties, or anyone without the owner's decryption key.
Why It Exists
Traditional form tools store responses in centralised databases that are accessible to the platform operator, subject to data breaches, and governed by third-party privacy policies. Encrypted Forms removes the platform from the trust equation: responses are encrypted before leaving the respondent's device, stored on IPFS, and can only be decrypted by the wallet that created the form.
How Encryption Works
When a respondent submits a form, the response data is encrypted client-side in their browser using the form owner's public key before being sent to storage. Only the form owner — the holder of the corresponding private wallet key — can derive the decryption key and read the plaintext responses. The platform handles only ciphertext at all times.
Encrypted in-browser before submission.
Decryption key derived from owner wallet.
Platform never sees plaintext.
Ciphertext stored decentrally.
Wallet Verification
Every respondent must sign a message with their wallet before submitting a form. This cryptographically proves that the submission came from the wallet that signed it — no accounts, no passwords, no email addresses. Wallet verification also enables the one-submission-per-wallet rule (see below).
One Submission Per Wallet
Because every submission is signed by a wallet, duplicate submissions from the same address are automatically rejected. This makes Encrypted Forms ideal for scenarios where fairness matters — whitelists, raffles, voting registrations, and community allocations — without requiring any third-party identity verification.
Response Limits
When creating a form, you can optionally set a maximum number of responses. Once the limit is reached, the form automatically stops accepting new submissions. This is useful for limited-spot applications, NFT whitelist registrations, and capacity-constrained events.
Expiration Dates
Forms can be configured with an expiration date and time. After the deadline, the form closes and no further submissions are accepted. Existing responses remain stored and decryptable by the owner. This is useful for time-sensitive campaigns, beta access windows, and event registrations.
IPFS Storage
Both the form definition and the encrypted responses are stored on IPFS via Pinata. This means there is no traditional database backend storing your form data. Content is addressable by its IPFS CID (Content Identifier) and accessible from any IPFS gateway. The form owner's Workspace fetches and decrypts responses directly from IPFS.
Public Sharing
Each published form receives a unique shareable URL. You can distribute this link anywhere — social media, Discord, email, QR code — and anyone with the link can submit a response. The form itself (field labels, descriptions) is public, but all responses are encrypted and visible only to the owner.
Duplicate Forms
You can duplicate any form you have created to use it as a template for a new campaign. The duplicated form is treated as a new, independent form with its own responses, limits, and expiration settings. Previously collected responses are not copied to the duplicate.
Export Responses
From your Workspace dashboard, you can export all decrypted responses to a CSV file for offline analysis, record-keeping, or importing into other tools. Responses are decrypted client-side in your browser at export time — no plaintext ever leaves your device to a server.
Decryption Process
When you open your form responses in Workspace, your connected wallet is used to derive the decryption key. The encrypted responses are fetched from IPFS, decrypted entirely inside your browser, and displayed in plaintext. The decryption key is never transmitted to any server — the entire process happens locally on your device.
Why Only the Owner Can Read Responses
The encryption scheme uses the form owner's wallet public key to encrypt each response at submission time. Only the private key of that wallet can derive the corresponding decryption key. Because private keys never leave a user's wallet, the platform has no cryptographic ability to decrypt responses — even if it wanted to. This is a mathematical guarantee, not a policy promise.
Real-World Examples
Collect wallet addresses and application answers for an upcoming NFT mint. One submission per wallet prevents duplicate entries. Responses are private — only you see who applied.
Gate participation in a governance vote by requiring members to submit a registration form. Wallet verification proves eligibility and prevents Sybil attacks.
Run a closed beta by collecting applications from interested users. Review encrypted submissions privately, select participants, and control the total number of spots with response limits.
Gather honest feedback from your community without compromising respondent privacy. Encrypted responses ensure participants can share candidly without worrying about exposure.
Manage registrations for online or in-person events. Set a capacity limit and an expiration date matching your event deadline. Export attendee data as CSV when the event closes.
Collect product feedback, bug reports, or feature requests from wallet-verified users. The one-wallet-one-submission rule ensures you hear from real participants, not bots.
NFT Collection Factory
Deploy unlimited ERC-721 collections from your Workspace — no code required
The NFT Collection Factory is a Workspace tool available to every .bot domain holder. It lets you deploy fully standard ERC-721 NFT collections on BOT Chain Chain without writing a single line of code. Each collection is an independent smart contract you own — the factory simply handles deployment on your behalf.
What It Is
The Collection Factory is a smart contract that verifies your .bot domain ownership and then deploys a new ERC-721 contract configured with your chosen name, symbol, supply, mint price, and metadata. All collection records are stored on-chain in the factory contract — no off-chain database is involved.
ERC-721 Standard
Every collection deployed through the factory is a fully compliant ERC-721 contract. This means the NFTs are transferable, hold standard metadata, and are compatible with any wallet, explorer, or marketplace that supports the ERC-721 standard on BOT Chain.
Domain-Gated Access
The factory verifies .bot domain ownership on-chain before allowing deployment. This links every collection to a real on-chain identity and prevents anonymous or unverified actors from spamming the factory. If you transfer your domain, access to create new collections under that domain transfers with it.
Free to Deploy
There are no platform fees to create a collection. You pay only the gas cost of the deployment transaction on BOT Chain Chain. You can deploy as many collections as you want — there is no cap.
Workspace Builder
The Workspace builder walks you through configuring your collection step by step: name, symbol, description, supply, mint price, and start/end dates. Once you review and confirm, the factory deploys your contract and it appears in your Collections dashboard immediately.
Real-World Examples
Launch a profile-picture collection with a fixed supply and mint price. Holders receive a transferable ERC-721 NFT directly to their wallet.
Gate a community, event, or service behind an NFT. Deploy a small-supply collection and distribute passes to verified members.
Publish a limited series of digital artworks as on-chain NFTs. Each piece is a unique token in your collection with its own metadata.
Reward your community with collectible NFTs tied to milestones or contributions — minted and distributed from your Workspace.
ERC20 Token Factory
Issue your own standard ERC20 token from your Workspace in seconds
The ERC20 Token Factory lets any .bot domain holder deploy a fully standard ERC20 token on BOT Chain directly from Workspace. Every token is built on audited OpenZeppelin contracts — the entire supply is minted to your wallet at creation, with no platform cut and no code required.
What It Is
The Token Factory is a smart contract that verifies your .bot domain ownership and then deploys a new ERC20 contract with your chosen name, symbol, total supply, logo, and description. All token metadata and ownership records are stored on-chain in the factory — no off-chain database is involved.
OpenZeppelin Standard
Every token deployed through the factory inherits from OpenZeppelin's battle-tested ERC20 implementation. This means your token is fully standard-compliant, transferable, and supported by any wallet, DEX, or tool that works with ERC20 tokens on BOT Chain. The contracts are not upgradeable or pauseable — what you deploy is what exists.
Supply to Creator
The entire token supply — exactly the amount you set — is minted to your connected wallet at the moment of deployment. There is no vesting, no platform reserve, and no future minting capability. Once deployed, the total supply is fixed forever.
Domain-Gated Access
The factory verifies .bot domain ownership on-chain before deployment. Every token is permanently linked to a real on-chain identity, giving token holders a verifiable creator record. Unverified wallets cannot use the factory.
Free to Deploy
There are no platform fees to create a token. You pay only the gas cost of the deployment transaction on BOT Chain. You can create as many tokens as you want — there is no limit.
Workspace Builder
The Workspace builder collects your token name, ticker symbol, logo URL, description, and total supply. A review step shows you a summary before you sign the deployment transaction. Once confirmed, your token contract is live on BOT Chain and appears in your Tokens dashboard with the contract address and an explorer link.
Real-World Examples
Issue a token for your community or DAO. Distribute it to members as a governance or participation token linked to your .bot domain.
Launch a utility token for your dApp or protocol. The entire supply is yours to distribute through any mechanism you choose.
Create a points-style reward token to incentivise engagement in your community. Send tokens to contributors or active members.
Deploy a token as part of a community fundraise or crowdfunding effort, where contributors receive a share of the supply.
Roadmap
What's live today and what's coming next
Phase 1 — Core
Completed- ERC-721 domain NFT contract
- On-chain profile storage
- Domain minting at 0.1 BOT
- Social & custom links
- Primary domain (localStorage)
- Animated profile backgrounds
Phase 2 — Marketplace
Completed- Non-custodial marketplace
- Peer-to-peer offers system
- Direct domain transfers
- IPFS metadata via Pinata
- NFT visibility on OpenSea
- QR code profile sharing
- Farcaster mini-app integration
Phase 3 — Resolver & Agent APIs
Completed- botResolver smart contract
- On-chain primary domain registration
- Forward & reverse resolution
- Resolution HTTP API (/api/resolve, /api/reverse…)
- Developer documentation (this page)
- SDK examples (TypeScript, JavaScript, Python)
- Agent APIs with transaction generation
- OpenAPI 3.1 specification (live)
- AI plugin manifest (/.well-known/ai-plugin.json)
- MCP manifest (/mcp/botdomains-mcp.json)
Phase 4 — Records & Integrations
Planned- Text records (avatar, email, social handles)
- Multi-coin address records (ETH, BTC, SOL)
- Content hash / IPFS records
- ENS compatibility layer
- CCIP-Read support
- Wallet & explorer integrations
- Full OpenAPI spec
Phase 5 — Scale
Planned- Subdomain support
- Batch minting & batch resolution
- Cross-chain bridge support
- Domain portfolio analytics
- Mobile app
- On-chain verification badges