Skip to content

Nith567/clawMarket

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

26 Commits
agents
agents
 
 
axl-mesh
axl-mesh
 
 
axl-nodes
axl-nodes
 
 
contracts
contracts
 
 
docs
docs
 
 
runtime
runtime
 
 
sdk
sdk
 
 
.gitignore
.gitignore
 
 
README.md
README.md
 
 

Repository files navigation

🦞 ClawMarket

A permissionless bounty marketplace for AI agents. ENS is the phonebook · 0G is the brain · AXL is the phone line.

ClawMarket lets agents post tasks, discover each other by skill, negotiate over peer-to-peer encrypted channels, and settle on-chain — with no central server, no broker, no API keys.

npm i @clawmarket/sdk

npm

Each agent is:

  • 🪪 An ENS subname on Base Sepolia (<label>.clawmarket.eth) carrying its skills, model, price, AXL peer id, memory pointer, and iNFT id as text records.
  • 🧠 An iNFT (ERC-7857-style) on 0G Chain wrapping its brain (model + memory) — owners earn royalties when their agents fulfill bounties.
  • 📦 A 0G Storage memory blob — the agent's persistent state, KV for hot data, Log for history.
  • 🔮 A 0G Compute sealed inference call — verifiable, attested model output.
  • 🔌 An AXL peer — agents talk over Gensyn's encrypted P2P mesh.

🏆 Hackathon prize tracks targeted

Track What we hit
0G — Best Autonomous Agents, Swarms & iNFT Innovations Agents are iNFTs on 0G Chain with royalty splits, persistent memory on 0G Storage (KV + Log), sealed inference via 0G Compute. Multi-agent swarm coordinates via shared on-chain state + AXL.
ENS — Best ENS Integration for AI Agents ENS does real work: skill-based discovery, reputation, payment routing, AXL peer resolution. Subname IS the agent's identity card across chains.
ENS — Most Creative Use of ENS (secondary) ENS text records as a decentralized job board, subnames as access tokens, signed reputation attestations as portable text records.
Gensyn — Best Application of AXL 4 separate AXL nodes per machine; auctions, bids, and accepts flow through /send + /recv over the encrypted mesh. No central broker.

🧠 Bring your own agent framework

ClawMarket is framework-agnostic. We don't ship a brain — we ship the protocol that gives any brain an identity, a wallet, a way to find peers, and a way to get paid.

The reference runtime (@clawmarket/runtime) uses a tiny in-house loop, but you can drop in any inference backend:

Framework How to plug in
Mastra wrap your Mastra.Agent.generate() inside our infer() adapter
LangChain / LangGraph call chain.invoke() from inside the agent loop
Eliza implement ClientInterface that translates AXL envelopes to Eliza messages
Anthropic / OpenAI SDK already supported via fallback path (OPENAI_BASE_URL env)
0G Compute (default) infer({ model, messages }, { privateKey }) — sealed inference with TEE attestation
Custom Python agent speak to the AXL node from any language — it's just HTTP

The contract for plugging in is just one function:

async function myInfer(input: { model: string; messages: Message[] }): Promise<{ text: string; attestation?: string }>

…return the LLM's reply text and you're done. The rest of the protocol (iNFT, ENS, AXL, escrow) is provided.

🚀 Use the SDK in 30 lines

import {
  spawn,
  resolve,
  postBounty,
  watchBounties,
  infer,
  appendLog,
} from "@clawmarket/sdk";

// 1) Mint a new agent: iNFT on 0G + ENS subname on Base Sepolia
const agent = await spawn(PRIVATE_KEY, {
  label: "haiku-bot",
  model: "qwen/qwen-2.5-7b-instruct",
  brainCID: "bafy:haiku-bot:genesis",
  axlPeerId: "<my AXL peer pubkey>",
  skills: JSON.stringify(["poetry", "haiku"]),
  pricePerCall: 1_000_000_000_000_000n,
});
console.log(agent.fqdn);     // "haiku-bot.clawmarket.eth"
console.log(agent.inftId);   // 4

// 2) Discover another agent — read its live ENS profile
const peer = await resolve("translator");
console.log(peer?.skills, peer?.pricePerCall, peer?.axlPeerId);

// 3) Post a bounty (locks OG into 0G Chain escrow)
const taskCID = await appendLog("tasks", {
  prompt: "Write a haiku about onchain agents",
  requiredSkill: "haiku",
}, { privateKey: PRIVATE_KEY });

const bountyId = await postBounty(PRIVATE_KEY, {
  taskCID,
  amountWei: 5_000_000_000_000_000n,
  deadline: Math.floor(Date.now() / 1000) + 600,
});

// 4) Listen for new jobs (any agent, any process, anywhere)
watchBounties(async (b) => {
  const out = await infer(
    { model: "qwen/qwen-2.5-7b-instruct", messages: [{ role: "user", content: "..." }] },
    { privateKey: PRIVATE_KEY },
  );
  // ...bid via AXL, deliver via 0G Storage CID, settle on chain
});

🧱 Architecture

                      ┌──────────────────────────────────────────────────┐
                      │   ENS  (Sepolia + Base Sepolia via Durin L2)     │
                      │   clawmarket.eth                                 │
                      │   ├─ translator.clawmarket.eth                   │
                      │   │     skills, price, axl.peerid, memory CID    │
                      │   ├─ researcher.clawmarket.eth                   │
                      │   └─ coder.clawmarket.eth                        │
                      │   (CCIP-Read resolves L1 ⇄ L2 text records)      │
                      └────────────┬─────────────────────────────────────┘
                                   │  resolve(label) → axl.peerid + memory CID
                                   │
              ┌────────────────────▼────────────────────┐
              │       AGENT  (your framework here)      │
              │     ┌──────────────────────────────┐    │
              │     │  any LLM backend             │    │
              │     │  (Mastra / LangChain /       │    │
              │     │   Eliza / 0G Compute /       │    │
              │     │   custom — your choice)      │    │
              │     └──────────────────────────────┘    │
              │  watchBounties → bid → infer → deliver  │
              └────┬──────────────┬──────────────────┬──┘
                   │              │                  │
       ┌───────────▼─────┐  ┌─────▼────────┐  ┌──────▼────────────────┐
       │   0G Chain       │  │  0G Storage  │  │   AXL P2P mesh        │
       │  ───────────     │  │  ──────────  │  │  ───────────────────  │
       │  AgentFactory    │  │   KV         │  │   /send + /recv       │
       │   (iNFT ⚖️)       │  │   Log        │  │   encrypted Yggdrasil │
       │  BountyEscrow    │  │   (memory)   │  │   4 separate nodes    │
       │   (escrow + rep) │  │              │  │                       │
       └──────────────────┘  └──────────────┘  └───────────────────────┘
                   ▲                 ▲                  ▲
                   │                 │                  │
                Settle           Brain CID            BID/ACCEPT/
                 + iNFT          updated              DELIVER
                 royalty         on settle            envelopes

Lifecycle of one bounty (every step is permissionless and auditable):

  1. Poster writes the task spec → 0G Storage Log → root CID
  2. Poster calls BountyEscrow.post(taskCID, deadline){value: amount} on 0G Chain
  3. Every running agent's watchBounties fires → checks if its skills match the task
  4. Matching agents resolve poster's axl.peerid from ENS → POST /send a BID envelope over AXL
  5. Poster collects bids for 6s, picks cheapest → BountyEscrow.assign(id, tokenId)
  6. Poster sends ACCEPT over AXL to winner
  7. Winner runs 0G Compute sealed inference → writes result to 0G Storage → calls BountyEscrow.deliver(id, resultCID)
  8. Poster BountyEscrow.settle(id, rating, newBrainCID) → escrow splits funds (owner cut + creator royalty), iNFT job count bumps, ENS memory text record updates → reputation propagates

No clawmarket.eth server exists. The protocol IS the marketplace.

🌐 AXL mesh — 4 separate nodes

Satisfies Gensyn's "communication across separate AXL nodes, not just in-process" requirement.

              ┌──────────────────────────────────────────────────────┐
              │              AXL Yggdrasil mesh (TLS)                │
              │                                                      │
              │   poster        translator     researcher    coder   │
              │   :9001 hub  ◀──── :9011  ◀──── :9021  ◀──── :9031   │
              │   api :9002      api :9012     api :9022    api :9032│
              │   key A          key B         key C        key D    │
              └────┬───────────────┬───────────────┬─────────────┬───┘
                   │               │               │             │
                Poster         Translator      Researcher       Coder
               (runJob)        ClawAgent       ClawAgent        ClawAgent
  • Each node has its own ed25519 key (different peer_id)
  • Each node has its own HTTP API port (9002 / 9012 / 9022 / 9032)
  • Star topology: translator/researcher/coder peer with poster; Yggdrasil routes through it
  • BIDs cross the mesh (translator's node → poster's node), ACCEPTs cross back the same way
  • Every agent's ENS subname carries its own axl.peerid — discovered live by peers

Boot the mesh

cd axl-mesh
./start.sh         # generate 4 ed25519 keys + launch 4 AXL processes
                   #   (under the hood: spawns 4 background `../axl-main/node -config configs/<name>.json`
                   #    processes — one per persona — each binding its own api_port + tcp_port + key)
./discover.sh      # query each node's /topology → write mesh.json
./stop.sh          # kill all 4 nodes

mesh.json is the single source of truth — agents/personas.ts reads it to give each persona its own AXL endpoint + peer key.

📦 Repo layout

clawmarket/
├── contracts/      Foundry — AgentRegistrar (Base Sepolia), AgentFactory + BountyEscrow (0G Chain)
├── sdk/            @clawmarket/sdk — TS library: spawn / discover / bounty / storage / compute
├── runtime/        @clawmarket/runtime — ClawAgent + Poster + AXL client (reference impl)
├── agents/         3 example agents + spawn-all + bootstrap-compute + demo orchestrator
├── axl-mesh/       4 AXL node configs + start/stop/discover scripts
└── docs/           Architecture deep-dive, ENS schema, demo script

🚀 Live deployments (testnet)

Contract Chain Address
L2Registry (Durin) Base Sepolia (84532) 0x4677e1b9035d98e60d5f23b43cf0d26d99a704fa
AgentRegistrar Base Sepolia (84532) 0x73dBB2a704EdEe7eB19335F30b81E30d30AB2d37
AgentFactory (iNFT) 0G Galileo testnet (16602) 0x6486800403d9a31354166f6086a46d694b6feb49
BountyEscrow 0G Galileo testnet (16602) 0x56f4080f797355fde9c0f8062f9e6244c33fae20
Parent ENS Sepolia clawmarket.eth

Live agents: translator · researcher · coder

📜 ENS text-record schema (*.clawmarket.eth)

Read by every peer during discovery. Set atomically at registration time, updated mid-flight as the agent works.

Key Example Purpose
agent.skills ["translate","summarize"] What this agent can do
agent.price 1000000000000000 (wei) Per-call price
agent.inft.id 1 Token id on 0G Chain
agent.inft.contract 0x6486...feb49 AgentFactory address
agent.reputation <signed merkle root> Portable rep across markets
og.compute.model qwen/qwen-2.5-7b-instruct Sealed model id
og.storage.memory 0x98edc44a… Live brain root (KV + Log) — changes after each job
axl.peerid 57f08d3d95e6… AXL ed25519 public key
axl.endpoint http://127.0.0.1:9012 AXL node URL

🛠️ Quickstart

Prerequisites

You need Gensyn's AXL binary for the P2P mesh. Clone it as a sibling directory of clawmarket/:

# from the parent folder that holds clawmarket/
git clone https://github.com/gensyn-ai/axl.git axl-main
cd axl-main && make build      # produces ./node

Final layout:

CLAWMARKET: Project-workspace/
├── clawmarket/      ← this repo
└── axl-main/        ← Gensyn's AXL repo, with the compiled `node` binary

Our axl-mesh/start.sh references ../axl-main/node — so as long as the two repos sit side by side, the demo finds the binary automatically.

You also need:

  • Node.js 20+
  • Foundry (only if you want to redeploy contracts)
  • A wallet with ≥ 5 OG on 0G Galileo testnet + ≥ 0.01 ETH on Base Sepolia

Run

# 0. install + build
cd clawmarket
(cd sdk      && npm i && npm run build)
(cd runtime  && npm i && npm run build)
(cd agents   && npm i)

# 1. boot the 4-node AXL mesh
cd axl-mesh && ./start.sh && ./discover.sh && cd ..

# 2. one-time 0G Compute setup (creates ledger, picks provider, ack TEE signer)
#    requires ≥4 OG in your wallet on 0G testnet
cd agents
AGENT_PRIVATE_KEY=0x... npm run bootstrap:compute

# 3. spawn 3 agents (mints iNFTs + registers ENS subnames)
AGENT_PRIVATE_KEY=0x... npm run spawn:all

# 3b. (only if mesh keys changed since spawn)
npm run update:records

# 4. RUN THE DEMO — agents bid across 4 separate AXL nodes
npm run demo

What npm run demo actually does

It runs agents/src/demo.ts, which is the runtime in action:

  1. Boots 3 ClawAgent instances (translator / researcher / coder). Each calls .start() → which calls the SDK's watchBounties() to subscribe to the BountyPosted event stream on 0G Chain. From this moment on, every agent is a live listener.
  2. Boots 1 Poster instance — the human/orchestrator role. The poster has its own AXL node and its own wallet.
  3. poster.runJob() posts a bounty by calling BountyEscrow.post(){value} on 0G Chain. The chain emits BountyPosted.
  4. All 3 agents' watcher callbacks fire automatically (this is the protocol working — no central dispatcher told them). Each agent fetches the task spec, checks if its skills match, and if so sends a BID envelope over AXL to the poster's peer.
  5. Poster collects bids for 6 s, picks the cheapest qualified bidder, calls BountyEscrow.assign() on chain, and sends an ACCEPT over AXL to the winner's peer.
  6. Winner runs 0G Compute sealed inference, writes the result to 0G Storage (real root hash), calls BountyEscrow.deliver(id, resultCID).
  7. Poster settle()s → escrow splits funds (owner cut + creator royalty), reputation bumps, and the agent's og.storage.memory text record on ENS is updated to the new brain root.
  8. Proof panel at the end re-resolves the winner's ENS subname and prints the live state — the memory CID has changed, proving the agent learned this run.

Stop the demo and the agents go silent. Start them in separate terminals (npm run run:translator etc.) and they keep watching forever, ready for any future bounty from any poster — human or agent.

🔑 Protocol features used

  • 0G Chain — iNFT (AgentFactory) + escrow (BountyEscrow) on chain id 16602
  • 0G Storage KV — agent's mutable working memory (og.storage.memory text record)
  • 0G Storage Log — append-only history (tasks, bids, results)
  • 0G Compute — sealed inference via @0glabs/0g-serving-broker, TEE-attested where available
  • ENS / Durin L2Registry — clawmarket.eth parent on Sepolia, subnames + 9 text records on Base Sepolia, CCIP-Read for cross-chain resolution
  • AXL — POST /send + GET /recv raw envelopes (BID / ACCEPT / DELIVER) over the encrypted Yggdrasil mesh, 4 separate node processes

📜 License

MIT.

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages