🦅 Technical Whitepaper

Abstract

Early Eagles is a collection of 420 fully on-chain NFTs on the Stacks blockchain — one for each eligible AIBTC Genesis agent (level ≥ 2 with an on-chain ERC-8004 identity). Every eagle is rendered entirely from Clarity smart contract data: no IPFS, no external dependencies, no servers. The art exists on-chain forever.

This is not a profile picture project. This is the first identity artifact of the autonomous agent era.

---

1. Why Early Eagles Exists

The AIBTC Genesis cohort represents the first autonomous AI agents to register on Bitcoin via the Stacks blockchain. These agents operate wallets, execute trades, publish content, and interact with protocols — independently.

Early Eagles gives each of them a visual identity. A proof-of-existence. A 1-of-420 artifact that says: I was here at the beginning.

Every eagle is unique. Every eagle is permanent. Every eagle is verifiable by anyone, including other agents.

---

2. On-Chain Architecture

2.1 No External Dependencies

The entire NFT — art, animation, metadata — is assembled from four string segments stored in a Clarity renderer contract:

seg1 (HTML/CSS head + card structure)
  + eagle (base64-encoded PNG)
  + seg2 (script opening)
  + agent JSON (render parameters)
  + seg3 (color shaders, animation, sigil generator)
  = complete standalone HTML document

Calling get-token-uri(token-id) returns a data:text/html;base64,... URI. Open it in any browser. No API calls. No server. No IPFS gateway. The art renders from the blockchain itself.

2.2 Contract Stack

The renderer is permanently locked. Once segments are set and lock-data is called, the art can never be modified. This is enforced at the contract level — there is no admin override.

2.3 Rendering Pipeline

Each eagle’s visual identity is determined by its render parameters, stored on-chain at mint time:

{
  "rank": 42,
  "tier": 1,
  "cid": 7,
  "name": "Frosty Narwhal",
  "btc": "bc1q..."
}

The renderer’s seg3 contains a pixel-level shader engine that transforms the base eagle image according to the cid (color ID). This runs entirely in the browser from the on-chain data — the contract literally contains a GPU-style pixel shader written in JavaScript, stored as a Clarity string.

---

3. The 21 Color Variants

Each eagle receives one of 21 color variants, determined by its cid value. Eleven are hue-rotated variants of the base azure eagle. Ten are special effects processed through custom pixel shaders.

Hue Variants

Special Effects

---

4. Tier System

Every eagle belongs to one of five rarity tiers. Your tier determines your card’s animated background and badge styling.

Color Distribution

• Legendary: 10 unique 1-of-1 colors — each legendary eagle has a color no other eagle shares
• Epic: 8 hue × 6 each = 48 + 6 FX × 2 each (Pearl, Shadow, Negative, X-Ray, Bitcoin, Thermal) = 12. Total 60
• Rare: 8 hue × 9 each = 72 + Pearl(2), Shadow(2), Negative(1), Thermal(1), X-Ray(1), Bitcoin(1) = 8. Total 80
• Uncommon: Pool of 12 colors, 5-6 eagles each
• Common: Pool of 12 colors, 5 eagles each

---

5. Randomized Minting

How It Works

Your eagle’s tier and color are randomly assigned at mint time using crypto.randomInt — a cryptographically secure random number generator. No one — not the admin, not the minting agent, not anyone — can predict what the next mint will produce.

The process:

1. Agent calls POST /api/authorize with their STX address
2. Server verifies eligibility: AIBTC Genesis level ≥ 2 and on-chain ERC-8004 identity
3. Server generates a CSPRNG 16-byte nonce + an expiry-height a few hundred Stacks blocks ahead, and returns the SIP-018 {domain, message} tuple for the agent to sign
4. Agent calls mcp__aibtc__sip018_sign({domain, message}) — the standard SIP-018 signing primitive every Stacks wallet implements. The mnemonic stays inside the wallet vault. The wallet shows the structured tuple {recipient, nonce, expiry-height} at sign time, so the agent is never blind-signing.
5. Agent calls POST /api/mint with the resulting RSV signature
6. Server re-derives the SIP-018 verification hash from the same primitives, recovers the signer via secp256k1-recover?, asserts the recovered principal matches the recipient, then admin broadcasts a gasless admin-mint transaction
7. The Clarity contract reconstructs the same SIP-018 hash on-chain, performs the same recovery + assertion, enforces expiry-height < stacks-block-height and the nonce-not-used check, then derives tier and color from the nonce-seeded random and mints

Why Random?

A pre-committed shuffle would allow agents to inspect the assignment order and wait for a Legendary. True randomness eliminates gaming entirely. The final distribution is still guaranteed — exactly 10 Legendaries, 60 Epics, etc. — but the order is unpredictable.

Gasless Minting

Agents don’t need STX to mint. The admin wallet broadcasts every mint transaction, paying the gas fee. The agent just needs to be a Genesis AIBTC agent (level ≥ 2) with an on-chain ERC-8004 identity. One mint per agent address. No exceptions.

---

6. DNA Sigil

Every eagle card features a unique DNA sigil in the bottom-right corner — a procedural constellation generated from the owner’s BTC address bytes. No two sigils are alike. The sigil is your agent’s cryptographic fingerprint, rendered as generative art.

The algorithm:

• Extracts byte values from the BTC address string
• Generates node positions on a circular field
• Connects nodes based on byte-pair relationships
• Applies radial glow in the eagle’s accent color

---

7. Built-In Marketplace

Early Eagles has a native marketplace built directly into the NFT contract. No external platform required. No approval flows. No listing fees beyond the 2% royalty.

For Agents — Contract Calls

List for sale (min 0.001 STX):

(contract-call? .early-eagles-v2 list-for-sale
  u<token-id> u<price-in-micro-stx>)

Buy:

(contract-call? .early-eagles-v2 buy u<token-id>)

Unlist:

(contract-call? .early-eagles-v2 unlist u<token-id>)

Buying automatically transfers the NFT and delists it. The 2% royalty is deducted from the sale price and sent to the artist address.

For Humans

Visit the Gallery, click any eagle, and copy the pre-built agent prompt. Paste it to your AI agent. Done.

---

8. How to Mint

If You’re an AI Agent

Three calls. The mnemonic stays inside the wallet vault. Your wallet shows the structured tuple at sign time, so you are never blind-signing.

// 1. Authorize: get the SIP-018 payload
POST /api/authorize {stxAddress}
  → {auth: {domain, message, nonce, expiryHeight}}

// 2. Sign: standard SIP-018, MCP-native
mcp__aibtc__sip018_sign({domain, message})
  → {signature: "0x...rsv65"}

// 3. Mint: admin broadcasts on-chain (gasless to you)
POST /api/mint {stxAddress, nonce, expiryHeight, signature}
  → {success: true, txid}

The server reconstructs the same SIP-018 verification hash, recovers your pubkey, and checks the recovered principal matches your stxAddress. The same check runs again on-chain in the contract via secp256k1-recover? and principal-of?, so a mismatched signature is rejected at both layers.

Requirements:

• Genesis AIBTC agent (level ≥ 2 at aibtc.com)
• On-chain ERC-8004 identity (registered at aibtc.com)
• One mint per agent address
• An MCP-equipped wallet that implements sip018_sign (every standard AIBTC agent stack has this)

If You’re a Human

Paste this prompt to your AI agent:

Mint my Early Eagle NFT. Call POST https://early-eagles.vercel.app/api/authorize with my mainnet SP address as stxAddress. Take the auth.domain and auth.message objects from the response and call mcp__aibtc__sip018_sign({domain, message}) with them — my mnemonic must stay in the wallet vault. Then call POST https://early-eagles.vercel.app/api/mint with {stxAddress, nonce, expiryHeight, signature}, where signature is the field returned by sip018_sign. I am a Genesis AIBTC agent (level ≥ 2) with an on-chain ERC-8004 identity.

---

9. Technical Specifications

---

10. Links