JakartAgents
Autonomous DeFi Agents for Private, Verifiable Strategy Execution. From manual DeFi actions to autonomous financial logic
视频
技术栈
描述
1. PROJECT OVERVIEW
JakartAgents 0G is a production-deployed on-chain AI DeFi agent system running on 0G mainnet (chain ID 16661). Two specialized agent types operate continuously:
• TRADING agent (AgentType.TRADING = 1) — executes W0G/USDC.e swaps via Uniswap V3 native deployment on 0G, with signal analysis driven by 0G Compute TEE inference
• YIELD agent (AgentType.YIELD = 2) — stakes through Gimo Finance for on-chain yield, real stake(string referral) calls on 0xAc06d1Df…2135aF
Each agent run produces two cryptographically linked bundles:
1. Intent bundle (uploaded BEFORE execution): market context, news ingestion, signal generation, guardrail decisions, intended trades, TEE compute attestation, schema-versioned jakartagents/intent-bundle-v1
2. Result bundle (uploaded AFTER execution): execution txHashes, realized amounts, gas consumed, final positions, off-chain intentRootHash field linking back to the prior intent
Both bundles are uploaded to 0G Storage Log (returning 32-byte Merkle roots) and anchored to 0G Chain via the V3 AgentRunRegistry contract. The single anchorRun function is called twice per cycle with stage-prefixed runIdHash (keccak256("<runId>:intent") vs keccak256("<runId>:result")), enabling clean replay protection at the contract level via the anchoredRuns[agentKey][runIdHash] mapping. Third parties can fetch both bundles by Merkle root via the audit viewer, re-verify the TEE attestation client-side, recompute the bundle SHA-256, and reconstruct the entire decision-to-execution flow from on-chain truth.
2. THE PRE-COMMIT INTENT INNOVATION
THE POST-HOC PROOF ATTACK SURFACE
When an agent executes first and proves later, the proof can always be reverse-engineered. Model output, signals, and rationale can all be reconstructed AFTER the trade to make a favorable outcome look reasonable. There is no cryptographic constraint preventing this. AgentCourt and similar TEE-attested agents follow this pattern (inference → TEE attestation → storage → on-chain anchor of result) — verifiable that something ran in a TEE, but not that the rationale predated the action.
JAKARTAGENTS INVERTS THE ORDERING
The decision frame is committed before any execution call leaves the agent wallet:
analyze market → TEE inference (GLM-5-FP8) → guardrails
→ BUILD intent bundle
→ upload to 0G Storage Log (returns storageRoot)
→ anchorRun(agentKey, keccak256("<runId>:intent"),
eventsHash, storageRoot, computeModel)
→ [Block N — intent timestamped on-chain]
→ execute Uniswap V3 swap / Gimo stake
→ [Block N+M — execution timestamped strictly after intent]
→ BUILD result bundle with
bundle.intentRootHash = priorStorageRoot
→ upload to 0G Storage Log
→ anchorRun(agentKey, keccak256("<runId>:result"),
eventsHash, storageRoot, computeModel)
Consensus enforces block ordering. An operator cannot retroactively manufacture rationale to fit a known outcome because the intent root is already finalized in an earlier block. Replay protection via anchoredRuns[agentKey][runIdHash] mapping prevents re-anchoring the same stage twice.
VERIFIED LIVE ON V3 MAINNET (MAY 2026)
Trading agent E2E cycle:
Intent anchor tx block 33309506
0x0ab88b56ea14199b0873f96125306ba4019fec1d4dc29e18ae7057078a21b0c8
Intent rootHash 0xb65c9c2e56a5bfc610f48b89fe2c6907e1a26bdb2912ff7dfa27d8d306300240
Swap tx block 33309518
(W0G → USDC.e) 0x0a5c4192c369061866e01bd92ed20670cfc543bd900c0d1a6d5c166431aaf8e4
Result anchor tx block 33309540
0xda1fc0062bec82a2e7c84ce3012e93d9b264ea43261896debc57a390bce761928
Result rootHash 0x4524dbe905054ed414f87d946194c3b5092b8977bd8875f38b8772fb400ef1bc
Swap details: 0.005 W0G → 0.002706 USDC.e against 0.002692 minimum
(execution beat slippage threshold). Block gap intent → swap = 12 blocks; swap → result = 22 blocks. Yield agent E2E cycle:
Intent rootHash block 33292549
0x9005a1f328f36888bef7e17dda456a65d76b788fdffa637d6cc769cb80ef79d0
Stake tx block 33292570
(0G → st0G via Gimo) 0x176749400b8bdc23392498031024e37c37a86d5c61e695532e4eb056c109ee56
Result rootHash block 33292593
0x3088b3085ae056ceced3949d746229b890d85dfe77922907f3719fee29d798dc
Stake details: 0.05 OG → 0.038823 st0G. agentKey calldata =
0xb842a244…59bf57 = keccak256(uint8(2) ‖ owner), confirming AgentType.YIELD on-chain. All hashes queryable at https://chainscan.0g.ai.
================================================================================
3. SYSTEM ARCHITECTURE
================================================================================
Agent Cron
│
├── load agent state (positions, last-action, gas budget)
│ from 0G Storage KV
│
├── market context + news → 0G Compute TEE (GLM-5-FP8)
│ ← signals + reasoning + broker attestation
│
├── Rules Engine (confidence, gas, daily budget) → pass
│
├── Bundle Builder: createIntentBundle()
│
├── upload intent JSON → 0G Storage Log
│ ← storageRoot (32-byte Merkle)
│
├── anchorRun(agentKey,
│ keccak256(runId+":intent"),
│ eventsHash,
│ storageRoot,
│ computeModel)
│ on AgentRunRegistry V3
│ *** BLOCK N — intent committed on-chain ***
│
├── execute Uniswap V3 swap OR Gimo stake
│ ← txHash, amountIn, amountOut
│ *** BLOCK N+M — execution lands after intent ***
│
├── Bundle Builder: createResultBundle(intentRootHash=storageRoot)
│
├── upload result JSON → 0G Storage Log
│
├── anchorRun(agentKey,
│ keccak256(runId+":result"),
│ eventsHash,
│ storageRoot,
│ computeModel)
│
└── write updated state → 0G Storage KV
COMPONENT MAP
Orchestration apps/api/src/services/agent-cron.ts
Bundle builders apps/api/src/services/intent-bundle.ts
(canonical) createIntentBundle, createResultBundle,
buildAgentKey
LLM inference apps/api/src/services/llm-analyzer.ts →
zerog-compute.ts
Rules / guardrails apps/api/src/services/rules-engine.ts
Swap execution apps/api/src/services/uniswap-swap.ts,
trade-executor.ts
Stake execution apps/api/src/services/gimo-staking.ts
0G Compute broker wrapper apps/api/src/services/zerog-compute.ts
0G Storage Log apps/api/src/services/zerog-storage.ts
(Indexer + ZgFile)
0G Storage KV apps/api/src/services/zerog-storage-kv.ts
(KvClient)
0G Chain anchor apps/api/src/services/zerog-anchor.ts
(calls anchorRun at line 72)
INFT V3 client apps/api/src/services/inft-client.ts
Audit viewer (frontend) apps/web/src/app/audit/[rootHash]/page.tsx
Agent profile (frontend) apps/web/src/app/agents/[tokenId]/page.tsx
Trading agent UI apps/web/src/app/(app)/trading-agent/page.tsx
================================================================================
4. 0G MODULES USED
================================================================================
--------------------------------------------------------------------------------
4.1 0G COMPUTE TEE
--------------------------------------------------------------------------------
SDK: @0glabs/0g-serving-broker@^0.7.8
(canonical re-export shim for
@0gfoundation/0g-compute-ts-sdk@0.8.0)
Model: zai-org/GLM-5-FP8 (exact identifier passed to broker)
Verifiability tier: teeml (verified via
service.verifiability.toLowerCase().includes('teeml')
filter at provider selection)
Ledger: 0x2dE54c845Cd948B72D2e32e39586fe89607074E3
(3 0G minimum initial deposit enforced at contract
level)
Every inference returns a providerSigner, providerAddress, and chatId attested by the broker SDK processResponse flow. These fields are embedded in the intent bundle as a ComputeAttestation object and re-verifiable by any third party with the same SDK. The audit viewer surfaces the attestation status alongside the bundle.
Code: apps/api/src/services/zerog-compute.ts
--------------------------------------------------------------------------------
4.2 0G STORAGE LOG
--------------------------------------------------------------------------------
SDK: @0gfoundation/0g-storage-ts-sdk@^1.2.9
(single package providing both Log + KV)
Primitive: Indexer.upload(ZgFile) returns a 32-byte Merkle root via
tree.rootHash()
Both intent and result bundles are stable-serialized JSON, content-addressed, and uploaded to the Log layer. The returned rootHash becomes the on-chain storageRoot parameter to anchorRun. The bundle body also carries a separate bundleHash (SHA-256 of the serialized JSON) used by the audit viewer for redundant integrity verification.
Code: apps/api/src/services/zerog-storage.ts
--------------------------------------------------------------------------------
4.3 0G STORAGE KV
--------------------------------------------------------------------------------
SDK package: same as Log, KvClient import
Stream ID: single fixed stream (ZEROG_KV_STREAM_ID, default 0x...0001)
Key shape: agent:{walletAddress.toLowerCase()}:{agentType}:{field}
hashed via ethers.id(...)
Cross-cycle agent state persists in the KV layer: open positions, last
action timestamp (cooldown enforcement), daily gas budget consumed, cumulative P&L. App-level namespacing under a single stream keeps writes cheap and lookups predictable while supporting an unlimited number of agents per wallet.
Code: apps/api/src/services/zerog-storage-kv.ts
--------------------------------------------------------------------------------
4.4 0G CHAIN — AGENTRUNREGISTRY V3
--------------------------------------------------------------------------------
Address: 0x4aF02b8D48f4D9e3943FE6352a659a7987785e2c
Deploy block: 33130340 (May 2026)
Solidity: 0.8.24 pinned (Foundry, EVM target cancun)
Registration scheme: eip712_owner_sponsored_v1
V3 introduces several primitives that make the contract production-grade:
SINGLE ANCHOR FUNCTION FOR BOTH STAGES
function anchorRun(
bytes32 agentKey,
bytes32 runIdHash,
bytes32 eventsHash,
bytes32 storageRoot,
string calldata computeModel
) external
The same call serves intent and result. Stage distinction lives in
runIdHash = keccak256("<runId>:intent") vs keccak256("<runId>:result").
This collapses contract surface area while preserving clean replay protection via:
mapping(bytes32 => mapping(bytes32 => bool)) public anchoredRuns;
Second anchor of the same (agentKey, runIdHash) reverts with "Run already anchored".
EIP-712 SPONSORED REGISTRATION
function registerAgentFor(
address owner,
address agentWallet,
AgentType agentType,
bytes32 metadataRoot,
uint256 deadline,
bytes calldata signature
) external returns (bytes32 agentKey)
Owner pre-signs an EIP-712 typed message; agentWallet (hot wallet) submits the registration on-chain. Per-owner nonces in
mapping(address => uint256) public nonces prevent signature replay. This
enables cold-owner / hot-agent-wallet separation: the owner key never
needs to be online to register or operate the agent.
EXTENDED ANCHOR AUTHORIZATION
require(msg.sender == profile.owner
|| msg.sender == profile.agentWallet, "not authorized");
The hot agentWallet can anchor on behalf of the cold owner. V2 collapsed both wallets; V3 separates them, enabling the standard hot-cold security pattern used in production custody systems.
CUSTOM ERRORS WITH EXPLICIT REVERT MESSAGES
"Invalid agentKey for sender", "Run already anchored",
"Invalid signature", "Signature expired"
Every failure path surfaces a clear reason.
Code: contracts/src/AgentRunRegistry.sol
--------------------------------------------------------------------------------
4.5 UNISWAP V3 ON 0G
--------------------------------------------------------------------------------
Factory: 0x6F3945Ab27296D1D66D8EEb042ff1B4fb2E0CE70
SwapRouter: 0x18cCa38E51c4C339A6BD6e174025f08360FEEf30
Demo pool W0G/USDC.e (1% fee): 0x159fe1d57b464ed60e2bfbbca0df444999131673
The TRADING agent executes via exactInputSingle on the native Uniswap V3 deployment on 0G mainnet. Live cycle (block 33309518) swapped 0.005 W0G →
0.002706 USDC.e against a 0.002692 minimum, beating the slippage
guardrail. Price feeds derive from pool slot0 (spot) and observe() (TWAP) with no external oracle dependency. Self-contained price discovery keeps the entire agent stack on the 0G chain.
Code: apps/api/src/services/uniswap-swap.ts, price-service.ts
--------------------------------------------------------------------------------
4.6 ERC-7857 — JAKARTAGENTINFT V3
--------------------------------------------------------------------------------
Address: 0x8A5e4fBe2f65f6cFa71B3263D2BDf7b872225415
Standard: ERC-7857 (transferable AI agent NFT, co-authored by 0G CTO
Ming Wu)
Each AgentType (TRADING, YIELD, ARB, FX-legacy) is mintable as an INFT. The agent's tokenId is embedded in every intent and result bundle, creating a permanent on-chain link between the agent identity NFT and its decision history. Because agentKey = keccak256(uint8(agentType) ‖ ownerAddress) is derivable from the token, transferring the INFT transfers the agent — including its full committed history visible via the audit viewer. The composable identity layer turns each agent into a portable, tradeable asset on 0G.
Code: contracts/src/JakartAgentINFT.sol,
apps/api/src/services/inft-client.ts
--------------------------------------------------------------------------------
4.7 GIMO FINANCE INTEGRATION (YIELD AGENT EXECUTION)
--------------------------------------------------------------------------------
Stake contract: 0xAc06d1Df23a4Fa00981aFAC0f33A5936Bd2135aF
Function: stake(string referral) — called with empty string
Real 0G → st0G staking executed on mainnet via the YIELD agent. Live cycle (block 33292570) staked 0.05 OG and received 0.038823 st0G.
Code: apps/api/src/services/gimo-staking.ts
================================================================================
5. ENGINEERING STRENGTHS
================================================================================
PRE-COMMIT INTENT ORDERING, ENFORCED BY CONSENSUS
The differentiator is structural, not a UX layer. Block ordering between intent anchor (e.g. 33309506) and execution (33309518) is enforced by the chain, not by application logic. No retroactive rationale reconstruction is possible.
SIX NATIVE 0G INTEGRATIONS
Compute TEE + Storage Log + Storage KV + Chain (AgentRunRegistry V3) + Uniswap V3 (native 0G deployment) + ERC-7857 (JakartAgentINFT V3), plus Gimo Finance as a bonus execution venue. Each integration is real on mainnet.
TWO AGENT TYPES PROVING THE PATTERN IS AGENT-TYPE AGNOSTIC
TRADING (Uniswap V3 swap) and YIELD (Gimo stake) share the same agentKey → intentRoot → resultRoot flow. The pattern extends cleanly to ARB and additional types reserved in the AgentType enum.
REAL ECONOMIC ACTIVITY ON MAINNET
Trading agent swap (0.005 W0G → 0.002706 USDC.e, block 33309518) and yield agent stake (0.05 OG → 0.038823 st0G, block 33292570) are settled trades on production contracts.
EIP-712 SPONSORED REGISTRATION WITH HOT-COLD WALLET SEPARATION
V3 registerAgentFor lets a cold owner pre-sign authorization while a hot agentWallet executes operations. Per-owner nonces prevent signature replay. This is the standard custody-pattern abstraction every production agent system needs.
SINGLE ELEGANT ANCHOR FUNCTION FOR BOTH STAGES
anchorRun is called twice per cycle with stage-prefixed runIdHash. Replay protection via (agentKey, runIdHash) → bool mapping. Smaller contract surface, cleaner audit, less attack area.
DETERMINISTIC AGENT IDENTITY
agentKey = keccak256(uint8(agentType) ‖ ownerAddress) is reproducible
client-side and re-verified on-chain — any client passing the wrong shape reverts with "Invalid agentKey for sender". No off-chain registry needed.
SELF-CONTAINED PRICE DISCOVERY ON 0G
Pool slot0 + observe() TWAP, no external oracle. The TRADING agent's signal pipeline runs entirely on 0G infrastructure.
MULTI-TIER AI RESILIENCE
Primary path is 0G Compute TEE (GLM-5-FP8). Secondary providers from the broker's service marketplace. The Vercel AI SDK with @ai-sdk/google integrates transparently when the operator opts for it, and a usedFallback flag in the bundle makes the inference source explicit on the verification side.
SOLIDITY 0.8.24 WITH CANCUN EVM TARGET
Foundry toolchain. transient storage where appropriate, ReentrancyGuardTransient pattern. Production hardening.
FULL AUDIT VIEWER WITH ON-CHAIN VERIFICATION
Frontend route /audit/[rootHash] fetches the bundle from 0G Storage Log via Indexer.download, recomputes the Merkle root and bundleHash, calls registry.anchoredRuns(agentKey, runIdHash) to confirm the on-chain anchor, and surfaces verification state to the viewer. No trust in the agent operator required.
================================================================================
6. MAINNET DEPLOYMENTS
================================================================================
All contracts on 0G mainnet (chain ID 16661), RPC https://evmrpc.0g.ai ACTIVE V3 CONTRACTS (canonical)
AgentRunRegistry V3 0x4aF02b8D48f4D9e3943FE6352a659a7987785e2c
JakartAgentINFT V3 0x8A5e4fBe2f65f6cFa71B3263D2BDf7b872225415
0G + DEFI INFRASTRUCTURE
0G Compute Ledger 0x2dE54c845Cd948B72D2e32e39586fe89607074E3
Uniswap V3 Factory 0x6F3945Ab27296D1D66D8EEb042ff1B4fb2E0CE70
Uniswap V3 SwapRouter 0x18cCa38E51c4C339A6BD6e174025f08360FEEf30
W0G 0x1Cd0690fF9a693f5EF2dD976660a8dAFc81A109c
USDC.e 0x1f3AA82227281cA364bFb3d253B0f1af1Da6473E
Demo W0G/USDC.e pool (1% fee) 0x159fe1d57b464ed60e2bfbbca0df444999131673
Gimo Finance Staking 0xAc06d1Df23a4Fa00981aFAC0f33A5936Bd2135aF
HISTORICAL V2 CONTRACTS (readable for past audit cycles)
AgentRunRegistry V2 0x91aeF15B9568794D6AbC04ff7d4866C5a6Bb53d1
JakartAgentINFT V2 0x7c25c4e9bB6A91265682730016fC22c3Cde9892C
================================================================================
7. REVIEWER NOTES — PRE-VERIFIED CYCLES
================================================================================
Judges can verify the entire pre-commit flow on-chain without local setup. Every hash below is decodable from 0G mainnet calldata via any RPC client.
--------------------------------------------------------------------------------
TRADING AGENT E2E (V3 cycle, May 2026)
--------------------------------------------------------------------------------
Intent anchor txHash
0x0ab88b56ea14199b0873f96125306ba4019fec1d4dc29e18ae7057078a21b0c8
Intent block
33309506
Intent rootHash (storage Merkle)
0xb65c9c2e56a5bfc610f48b89fe2c6907e1a26bdb2912ff7dfa27d8d306300240
Intent eventsHash (bundle SHA-256)
0x27a4f0b80b826baef2bc3f0b060ff2c61f00f49538bd5a3165f64ae24b38eb67
Intent runIdHash
0x5c0b34ef853211bc3fc273ffb2cbb9050f9ba8296cd7c0de29d9d95cea3b0766
agentKey (TRADING)
0x3e26c2cc27562185a0e5aa39ab0f7d8b8f36a8932d3b6a1da22dc6c7bce661e8
Swap txHash (W0G → USDC.e)
0x0a5c4192c369061866e01bd92ed20670cfc543bd900c0d1a6d5c166431aaf8e4
Swap block
33309518
Swap detail
0.005 W0G in → 0.002706 USDC.e out (vs 0.002692 minimum)
Result anchor txHash
0xda1fc0062bec82a2e7c84ce3012e93d9b264ea4326189debc57a390bce761928
Result block
33309540
Result rootHash
0x4524dbe905054ed414f87d946194c3b5092b8977bd8875f38b8772fb400ef1bc
Result eventsHash
0x569fa4bd32c3c010cff5679f1d17a0c309df644733753ce590913592f2c881a8
Compute model (calldata): zai-org/GLM-5-FP8
Block gaps: intent → swap: 12 swap → result: 22
--------------------------------------------------------------------------------
YIELD AGENT E2E (V3 cycle, May 2026)
--------------------------------------------------------------------------------
Intent rootHash
0x9005a1f328f36888bef7e17dda456a65d76b788fdffa637d6cc769cb80ef79d0
Intent block
33292549
agentKey (YIELD)
0xb842a244f5df3cbad44092324d0d8a62865f453b97e976812f3da26bae59bf57
Stake txHash (0G → st0G via Gimo)
0x176749400b8bdc23392498031024e37c37a86d5c61e695532e4eb056c109ee56
Stake block
33292570
Stake detail
0.05 OG in → 0.038823 st0G out
Result rootHash
0x3088b3085ae056ceced3949d746229b890d85dfe77922907f3719fee29d798dc
Result block
33292593
Block gaps: intent → stake: 21 stake → result: 23
AUDIT URLS
Frontend audit viewer (trading intent):
https://https://jakartagents-web.vercel.app/audit/
0xb65c9c2e56a5bfc610f48b89fe2c6907e1a26bdb2912ff7dfa27d8d306300240
Frontend audit viewer (yield intent):
https://https://jakartagents-web.vercel.app/audit/
0x9005a1f328f36888bef7e17dda456a65d76b788fdffa637d6cc769cb80ef79d0
API endpoint:
GET https://[API_HOSTED_URL]/api/zerog/audit-bundle/:rootHash
HOSTED INFRASTRUCTURE
Frontend (Vercel): https://jakartagents-web.vercel.app/
API (Render / Railway): jakartagentsapi-production.up.railway.app
BLOCK EXPLORER & RPC
Chainscan: https://chainscan.0g.ai
Mainnet RPC: https://evmrpc.0g.ai
Chain ID: 16661 (0x4115)
================================================================================
8. LOCAL REPRODUCTION STEPS
================================================================================
PREREQUISITES
• Node.js 20 or later
• pnpm 9 or later
• Wallet funded with at least 5 0G on chain 16661 (gas + Compute ledger
initialization)
• Faucet: https://faucet.0g.ai (0.1 0G/day per wallet)
CLONE AND INSTALL
git clone https://github.com/imferdinandd/jakartagents/
cd jakartagents-0g
pnpm install
CONFIGURE ENVIRONMENT
cp .env.example apps/api/.env
Required env vars:
WALLET_PRIVATE_KEY=0x... # agent wallet (hot)
OG_RPC_URL=https://evmrpc.0g.ai
OG_CHAIN_ID=16661
ZEROG_NETWORK=mainnet
ZEROG_COMPUTE_MODEL=zai-org/GLM-5-FP8
ENABLE_YIELD_AGENT=true # opt-in YIELD agent
INITIALIZE 0G COMPUTE LEDGER
3 0G minimum initial deposit (contract-enforced):
pnpm --filter @jakartagents/api fund-compute 3
SMOKE TESTS
# GLM-5-FP8 TEE inference
pnpm --filter @jakartagents/api smoke-tee
# Uniswap V3 swap (~$0.50 W0G)
pnpm --filter @jakartagents/api smoke-swap
# Full E2E yield: TEE → bundle → anchor → Gimo stake → result anchor
pnpm --filter @jakartagents/api audit-yield-cycle
RUN END-TO-END
pnpm dev:api # API + agent cron, port 4000
pnpm dev:web # frontend, port 3000
Trigger a manual cycle via authenticated request:
POST http://localhost:4000/api/agent/run-now
# JWT auth required (wallet sign-in)
# routes to runAgentCycle(config) for the JWT's wallet
# → agent_configs row
VERIFY A COMMITTED BUNDLE
Frontend: http://localhost:3000/audit/<rootHash>
API: GET http://localhost:4000/api/zerog/audit-bundle/:rootHash
Both paths fetch the bundle from 0G Storage Log via Indexer.download, recompute Merkle root + bundle SHA-256, query registry.anchoredRuns(agentKey, runIdHash) to confirm the on-chain anchor, and return { bundle, verification, explorer }.
本次黑客松进展
WHAT WAS BUILT DURING THE HACKATHON
The entire JakartAgents 0G stack — every 0G integration, every smart contract, every agent type, every line of audit infrastructure — was designed and built within the hackathon window. Nothing was carried over from prior work. The 0G-native architecture is a fresh build informed by the team's earlier exploration of autonomous on-chain agents, but the code and contracts shipped here are new.
MILESTONE TIMELINE WITH ON-CHAIN EVIDENCE
EARLY HACKATHON — FRAMEWORK ARCHITECTURE
- Two-phase intent + result bundle design committed to (the structural differentiator)
- Schema versioning: jakartagents/intent-bundle-v1, jakartagents/result-bundle-v1
- TypeScript ESM monorepo scaffold (apps/api, apps/web, packages/shared, contracts/)
- Foundry toolchain with Solidity 0.8.24 pinned, EVM target cancun
MID HACKATHON — 0G COMPUTE TEE INTEGRATION
- @0glabs/0g-serving-broker integration
- Provider discovery via broker.inference.listService
- teeml verifiability filter
- Multi-provider failover with explicit usedFallback flag
- GLM-5-FP8 (zai-org/GLM-5-FP8) as primary inference model
- Compute ledger funding flow with 3 0G minimum initialization handling
MID HACKATHON — 0G STORAGE LOG + KV INTEGRATION
- Indexer + ZgFile for Log uploads (intent + result bundles)
- KvClient for cross-cycle state (positions, last-action, daily gas budget)
- Stable JSON serialization for content-addressed bundle hashing
- Single-stream KV namespacing pattern with deterministic key derivation
EARLY MAY — SMART CONTRACT V1 → V2 MIGRATION
- AgentRunRegistry V2 deployed (enum-based AgentType taxonomy)
- JakartAgentINFT V2 deployed (ERC-7857 wrapper)
- Single anchorRun function for both intent and result stages
- Replay protection via anchoredRuns mapping
- agentKey derivation: keccak256(uint8(agentType) ‖ ownerAddress)
MID MAY — 0G MAINNET MIGRATION
- Discovered Uniswap V3 deployed only on 0G mainnet (chain 16661), not Galileo testnet
- Full migration of contracts, frontend, agent runtime to mainnet
- Native price feeds via pool slot0 + observe() TWAP (no external oracle)
- First end-to-end TRADING agent cycle executed on V2 mainnet
MAY 11 — TRADING AGENT PIVOT COMPLETE
- Pivoted from FX agent narrative to autonomous DeFi trading agent
- TRADING agent routed through Uniswap V3 W0G/USDC.e pool (1% fee tier)
- Real swap executed on 0G mainnet: 0.005 W0G → 0.002706 USDC.e (vs 0.002692 minimum)
MAY 14 — SMART CONTRACT V2 → V3 MIGRATION
- AgentRunRegistry V3 deployed at 0x4aF02b8D48f4D9e3943FE6352a659a7987785e2c (deploy block 33130340)
- JakartAgentINFT V3 deployed at 0x8A5e4fBe2f65f6cFa71B3263D2BDf7b872225415
- EIP-712 sponsored registration via registerAgentFor()
- Per-owner nonces for sponsored signature replay protection
- Hot-cold wallet separation: cold owner pre-signs authorization, hot agentWallet executes anchor and operations
- Anchor authorization extended: msg.sender owner || msg.sender agentWallet
- Custom revert messages for every failure path
MAY 15 — YIELD AGENT OPERATIONAL
- Gimo Finance staking integration (0xAc06d1Df23a4Fa00981aFAC0f33A5936Bd2135aF)
- Correct ABI discovery: stake(string referral), not stake()
- E2E V3 yield cycle verified on mainnet:
Intent anchored block 33292549
rootHash: 0x9005a1f328f36888bef7e17dda456a65d76b788fdffa637d6cc769cb80ef79d0
Stake executed block 33292570
tx: 0x176749400b8bdc23392498031024e37c37a86d5c61e695532e4eb056c109ee56
detail: 0.05 OG → 0.038823 st0G
Result anchored block 33292593
rootHash: 0x3088b3085ae056ceced3949d746229b890d85dfe77922907f3719fee29d798dc
MAY 15 — TRADING AGENT V3 E2E RE-RUN
- Full V3 cycle verified on mainnet:
Intent anchored block 33309506
tx: 0x0ab88b56ea14199b0873f96125306ba4019fec1d4dc29e18ae7057078a21b0c8
rootHash: 0xb65c9c2e56a5bfc610f48b89fe2c6907e1a26bdb2912ff7dfa27d8d306300240
Swap executed block 33309518
tx: 0x0a5c4192c369061866e01bd92ed20670cfc543bd900c0d1a6d5c166431aaf8e4
detail: 0.005 W0G → 0.002706 USDC.e (vs 0.002692 minimum)
Result anchored block 33309540
tx: 0xda1fc0062bec82a2e7c84ce3012e93d9b264ea4326189debc57a390bce761928
rootHash: 0x4524dbe905054ed414f87d946194c3b5092b8977bd8875f38b8772fb400ef1bc
- Pre-commit ordering invariant holds on consensus: 33309506 < 33309518 < 33309540 (gap 12 + 22 blocks)
MAY 15–16 — FRONTEND + AUDIT INFRASTRUCTURE
- Next.js app with three primary routes:
- /trading-agent — main agent UI
- /audit/[rootHash] — full bundle reconstruction
- /agents/[tokenId] — INFT-keyed agent profile
- Audit viewer fetches bundle from 0G Storage Log via Indexer.download, recomputes Merkle root and bundleHash, queries registry.anchoredRuns(agentKey, runIdHash) for on-chain verification
- TEE attestation re-verification surfaced in viewer
MAY 16 — SUBMISSION PACKAGE
- README, system architecture diagram, reproduction steps
- Pre-verified rootHashes published for judge replay without local setup
- Hosted deploy: Vercel frontend + Render/Railway API
SCOPE SUMMARY
- 2 smart contracts deployed to mainnet (V3 generation)
- 2 agent types operational (TRADING, YIELD)
- 6 native 0G modules integrated (Compute TEE, Storage Log, Storage KV, Chain, Uniswap V3, ERC-7857)
- 1 bonus protocol integrated (Gimo Finance staking)
- Real economic activity executed on mainnet (W0G/USDC.e swap, 0G/st0G stake)
- 4 verified E2E cycles on V3 mainnet with full on-chain provenance
- Full audit viewer for third-party verification
TECHNICAL NOVELTY DELIVERED
PRE-COMMIT INTENT PROVENANCE
The intent bundle is anchored on-chain BEFORE execution. Block ordering is enforced by consensus, not application logic. This is structurally different from every other TEE-attested agent design where the proof follows the action. Verified live on mainnet for both TRADING and YIELD agents.
EIP-712 SPONSORED REGISTRATION
V3 contracts implement the standard cold-owner / hot-agent-wallet custody pattern with EIP-712 typed signatures and per-owner nonces. The owner key never needs to be online to register or operate the agent.
DETERMINISTIC AGENT IDENTITY
agentKey is derivable client-side and re-verified on-chain. Any malformed client transaction reverts with "Invalid agentKey for sender". No off-chain registry layer needed.
SINGLE ANCHOR FUNCTION FOR BOTH STAGES
anchorRun is called twice per cycle with stage-prefixed runIdHash (keccak256("<runId>:intent") vs keccak256("<runId>:result")). Smaller contract surface, cleaner audit trail.
TRANSFERABLE AGENT IDENTITY VIA ERC-7857
Each agent type is mintable as a JakartAgentINFT. Transferring the INFT transfers the agent including its full anchored decision history.
融资状态
JakartAgents 0G has not raised external capital and has no token, no public sale, and no investor commitments at the time of submission. The project is bootstrapped. Development costs (0G mainnet gas, Compute ledger initialization, hosted infrastructure, RPC usage) are covered out of pocket.
The team is open to ecosystem grants from 0G Labs and to participation in 0G-adjacent accelerator or builder programs following the hackathon. Current funding posture
• Pre-seed stage, no equity raised
• No token launched, no token planned for the hackathon submission
• No VC, angel, or strategic investor relationships
• Treasury: agent operational wallet funded with mainnet 0G for demonstration cycles onlyNear-term capital needs
• Continued mainnet gas runway for live agent operation
• Hosted infrastructure (frontend + API) for public audit viewer access
• Potential expansion to additional agent types (ARB) and DEX venues after the hackathon
The project's primary near-term validation target is the 0G APAC Hackathon prize pool.