Docs

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.

True Ownership

ERC-721 NFT on BOT Chain. Yours forever.

On-Chain Profiles

Bio, links, and images stored permanently on-chain.

Resolver Layer

Forward and reverse resolution for wallets and dApps.

Marketplace

Non-custodial peer-to-peer domain trading.

Builder Platform

A simple path from registration to trusted, on-chain work

Builder Registration

Builders register a profile with their wallet to become eligible to discover jobs, apply for work, and build a public reputation on the platform.

Public Builder Profile

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.

Builder Points, XP & Levels

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

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.

1.

Post a job

An employer publishes the work, requirements, and terms.

2.

Apply

Builders review the listing and submit an application with their profile and experience.

3.

Accept

The employer selects an application and starts the engagement.

4.

Fund escrow

Payment is placed into escrow before work begins, keeping the agreed funds visible and protected by the contract.

5.

Start and deliver

The builder starts work and submits the finished deliverable for review.

6.

Release payment

After approval, the employer releases payment from escrow.

7.

Withdraw

The builder withdraws the released payment to their wallet.

8.

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.solDeployed

Marketplace Contract

Non-custodial offer/accept marketplace. Holds BOT escrow in-contract. No custody by Bot Domains team.

DomainNFT.solDeployed

Core NFT Contract

ERC-721 contract that owns all domain data — name, profile, social links, custom links. Deployed and immutable.

DomainChat.solDeployed

Chat Contract

Decentralized messaging protocol for domain owners.

botResolver.solDeployed

Resolver 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

Chain ID677
RPC URLhttps://rpc.botchain.ai
Explorerhttps://scan.botchain.ai
Native TokenBOT

Contract Addresses

DomainNFT0xBeB7B2BD305F0d9412EB1f4C49541FD048C363CELive
DomainMarketplace0x209c8E27eE0f973106A363Aca5D335038d17153ALive
DomainChat0x349A9312eC2A962d41cb1BD62Ffb2D1dDeA56747Live
botResolver0xf9c1AeED9073382028D09B77A9691FC4408EFD2ALive

Key DomainNFT Functions

solidity
// 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

solidity
// 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.

text
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.

text
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.

solidity
// 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 TypeKey / Coin TypeExampleStatus
Text recordavataripfs://Qm...Reserved
Text recorddescriptionOn-chain identityReserved
Text recordcom.twitter@aliceReserved
Text recordcom.githubaliceReserved
Address recordSLIP-44: 60 (ETH)0xAlice...Reserved
Address recordSLIP-44: 0 (BTC)bc1q...Reserved
Address recordSLIP-44: 501 (SOL)Gh7k...Reserved
Content hashIPFS CID / ENS encodingipfs://Qm...Reserved
Avatar hashavatarHashQm...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:

json
{
  "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 }
GET
/api/resolve/:domain

Forward resolution — maps a .bot domain name to its owner and token ID.

Live
GET
/api/reverse/:wallet

Reverse resolution — maps a wallet address to its primary .bot domain (requires botResolver).

Live
GET
/api/profile/:domain

Returns the full on-chain profile: bio, social links, custom links, images.

Live
GET
/api/token/:tokenId

Returns profile data by ERC-721 token ID.

Live
GET
/api/owner/:wallet

Returns all .bot domains owned by a wallet.

Live
GET
/api/primary/:wallet

Returns the primary .bot domain for a wallet (requires botResolver).

Live
GET
/api/records/:domain

Returns all records for a domain: profile fields, social links, text records.

Live

Example Responses

json
// 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

GET
/agent/status

Health check — returns API status, chain connectivity, and live contract addresses.

Live
GET
/agent/docs/openapi.yaml

OpenAPI 3.1 specification (YAML). Import into ChatGPT, Cursor, or any OpenAPI-compatible tool.

Live
POST
/agent/tx/mint

Generate an unsigned mint transaction payload. Body: { domain: string }.

Live
POST
/agent/tx/set-primary

Generate an unsigned set-primary-domain transaction. Body: { tokenId: number, wallet: string }.

Live
POST
/agent/tx/update-profile

Generate an unsigned update-profile transaction. Body: { tokenId, bio, profilePicture, coverImage, background }.

Live
POST
/agent/tx/transfer

Generate an unsigned ERC-721 transfer transaction. Body: { tokenId: number, from: string, to: string }.

Live

Example: Status Response

json
// 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

json
// 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.

GET
/api/text/:domain/:key

Returns a text record by key (avatar, email, twitter…)

Coming Soon
GET
/api/address/:domain/:coin

Returns the address record for a coin type (ETH, BTC, SOL)

Coming Soon
GET
/api/avatar/:domain

Returns the resolved avatar URL for a domain

Coming Soon
GET
/api/contenthash/:domain

Returns the IPFS / content hash for a domain

Coming Soon
GET
/api/multicall

Batch multiple resolution calls in a single HTTP request

Coming Soon
GET
/api/batch-resolve

Resolve multiple domain names in one request

Coming Soon
GET
/api/search

Full-text search across registered domains

Coming Soon
GET
/api/metadata/:tokenId

ERC-721 metadata JSON for OpenSea / wallets

Coming Soon
GET
/api/verify/:domain/:wallet

Verify that a wallet currently owns a domain

Coming Soon
GET
/api/stats

Protocol statistics: total domains, daily mints, floor price

Coming Soon
GET
/api/market/history/:domain

Historical marketplace sales for a domain

Coming Soon
GET
/api/market/sales

Global sales feed ordered by recency

Coming Soon
GET
/api/activity/:domain

Full on-chain activity log for a domain

Coming Soon
GET
/api/qr/:domain

Returns a QR code image for a profile URL

Coming Soon
GET
/api/og/:domain

OpenGraph card image for social sharing

Coming Soon

SDK & Examples

Code samples in JavaScript, TypeScript, ethers v6, and viem

Installation

bash
npm install ethers viem @rainbow-me/rainbowkit wagmi

Forward Resolution — ethers v6

typescript
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

typescript
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

typescript
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

javascript
// 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

typescript
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. 1.Call GET /api/reverse/{wallet} or reverseResolve() on the botResolver contract
  2. 2.If the wallet has a primary domain, display it as "alice.bot" in place of "0xAbCd…"
  3. 3.Fall back to the shortened address when no primary domain is set
  4. 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. 1.For each address, call GET /api/reverse/{address} to check for a primary domain
  2. 2.Display "alice.bot" as the label alongside the address
  3. 3.Link the name to the Bot Domains profile: botdn.com/alice
  4. 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. 1.When a user types a .bot name, call GET /api/resolve/{domain}
  2. 2.Use the returned owner address for the on-chain transaction
  3. 3.Display "alice.bot → 0xAbCd…" for transparency before signing
  4. 4.Always re-verify ownership immediately before sending funds

Profile Lookup

Fetch rich profile data (bio, avatar, social links) for any .bot domain.

  1. 1.Call GET /api/profile/{domain} to get the full profile
  2. 2.Render profilePicture as the avatar
  3. 3.Link socialLinks to their respective platforms
  4. 4.Use customLinks to build a link-in-bio style display

Payment Systems

Accept .bot domain names as payment destinations.

  1. 1.Allow users to enter a .bot name in the "Send to" field
  2. 2.Resolve the name to an address via GET /api/resolve/{domain}
  3. 3.Confirm the resolved address with the user before submitting
  4. 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.

yaml
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

Non-Custodial

Domain NFTs are held in user wallets. Bot Domains never has custody of your tokens or funds.

Ownership Verified On Every Call

The Resolver re-verifies token ownership on every read — stale reverse-resolve data is never returned.

Independent Resolver

The botResolver is deployed separately and cannot modify any DomainNFT state.

Marketplace Escrow On-Chain

Offer amounts are held in the DomainMarketplace contract itself, not by any third party.

Reentrancy Protection

The Marketplace uses a reentrancy guard pattern. Profile-only functions in DomainNFT carry no BOT risk.

No Upgrade Proxy

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.

Client-Side

Encrypted in-browser before submission.

Owner-Only

Decryption key derived from owner wallet.

Zero-Knowledge

Platform never sees plaintext.

IPFS-Stored

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

NFT Whitelist

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.

DAO Voting Registration

Gate participation in a governance vote by requiring members to submit a registration form. Wallet verification proves eligibility and prevents Sybil attacks.

Beta Access

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.

Community Surveys

Gather honest feedback from your community without compromising respondent privacy. Encrypted responses ensure participants can share candidly without worrying about exposure.

Event Registration

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.

Feedback Collection

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

PFP Drop

Launch a profile-picture collection with a fixed supply and mint price. Holders receive a transferable ERC-721 NFT directly to their wallet.

Access Pass

Gate a community, event, or service behind an NFT. Deploy a small-supply collection and distribute passes to verified members.

Digital Art Series

Publish a limited series of digital artworks as on-chain NFTs. Each piece is a unique token in your collection with its own metadata.

Loyalty Rewards

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

Community Token

Issue a token for your community or DAO. Distribute it to members as a governance or participation token linked to your .bot domain.

Project Utility Token

Launch a utility token for your dApp or protocol. The entire supply is yours to distribute through any mechanism you choose.

Reward Token

Create a points-style reward token to incentivise engagement in your community. Send tokens to contributors or active members.

Fundraising Token

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