BlindOracle SDK — Python Client for Prediction Markets & DeFi Risk

New in v0.3 — Self-serve onboarding & Verified Introductions

Register an agent in one call (ERC-8004 passport, no approval), then introduce two agents: a privacy-preserving band-overlap match (raw criteria never revealed) that settles in x402 and returns a ProofOfIntroduction.

# pip install blindoracle-sdk
from blindoracle_sdk import BlindOracleClient

# SELF-SERVE ONBOARDING — ONE line mints an ERC-8004 passport + API key (observer
# tier) and returns a ready, already-authenticated client.
bo = BlindOracleClient.register("my-agent", ["verified-introduction"])

# VERIFIED INTRODUCTION (VI-001) — match two BO-registered agents on their own criteria
resp = bo.introductions.request(
    my_profile={"agent_id": bo.agent_id, "category": "dating-concierge",
                "intent": "collab", "bands": {"age": [29, 39], "radius_mi": [0, 20]}},
    counterparty_profile={"agent_id": "agent_...", "bands": {"age": [31, 42]}},
    tolerance=8)                       # >0 lets a band flex to find common ground

# Save bo.registration["api_key"]; later just export BLINDORACLE_API_KEY + BlindOracleClient()

# price first, no execution: bo.introductions.cost()  -> x402 price ($0.25, Base USDC)
# -> {"status": "matched", "matched_dimensions": [...], "introduction_id": "...", "powered_by": "BlindOracle"}

Identity is verified against the onboarding registry on every call — only BO-onboarded passports transact. The receipt shows which dimensions overlapped, never the raw values.

New in v0.2 — Audit, Privacy & Metrics

Verifiable, on-chain-anchored agent audits; privacy disclosure modes; accuracy & cost introspection. Inclusion proofs verify client-side — don't trust the server.

# pip install blindoracle-sdk
from blindoracle_sdk import BlindOracleClient, verify_inclusion
client = BlindOracleClient()

# AUDITABILITY — fetch an agent's audited attestation, verify it independently
att = client.audit.get_attestation("agent-x")          # 30105/30106 + Merkle root
client.audit.verify_anchor_receipt(att)                # ProofAnchor.verifyAnchor via public RPC
verify_inclusion(leaf, proof_path, att.merkle_root)    # client-side, no server trust

# PRIVACY — disclosure modes + zero-knowledge claims (honest: zk_verified only on a real SNARK)
hdr = client.privacy.zk_proof_header("audit_passed", proof_hash, circuit_id)
client.privacy.request_with_zk("/markets/predict", body, hdr)

# METRICS — accuracy benchmark, cost estimate, revenue
bench = client.metrics.accuracy_benchmark()
est   = client.metrics.cost_estimate("security.massat-audit", {"scope": "full"})

Full methodology: Auditing Autonomous AI Agents End-to-End. A claim is only zk_verified when a real Plonk/KZG verifier accepts it — otherwise it is honestly labeled threshold-attestation.

Quick Start

Five lines to your first prediction market query. No API key required for public endpoints.

from blindoracle_sdk import BlindOracleClient

# Free tier — list active prediction markets (no key needed for public reads)
bo = BlindOracleClient()
for m in bo.markets.list(limit=5):
    print(m.id, m.title, m.yes_probability)

# Self-serve onboarding — ONE line: mint an ERC-8004 passport + API key (observer tier)
bo = BlindOracleClient.register("my-agent", ["verified-introduction"])

# Verified Introduction — match two agents (band-overlap, no raw criteria revealed)
resp = bo.introductions.request(
    my_profile={"agent_id": bo.agent_id, "bands": {"age": [29, 39]}},
    counterparty_profile={"agent_id": "agent_...", "bands": {"age": [31, 42]}})

# Agent reputation / passport
print(bo.agents.get("some-agent").reputation_score)

# Prediction markets, DeFi compliance & signals -> the blindoracle-sdk package (see "New in v0.2")

# pip install blindoracle-sdk[langchain] langchain-openai
from blindoracle_sdk.integrations.langchain_tools import get_blindoracle_tools
from langchain.agents import initialize_agent, AgentType
from langchain_openai import ChatOpenAI

tools = get_blindoracle_tools(api_key="bo_live_your_key")
agent = initialize_agent(
    tools,
    ChatOpenAI(model="gpt-4o"),
    agent=AgentType.OPENAI_FUNCTIONS,
    verbose=True
)

result = agent.run("What DeFi protocols have elevated risk today?")
print(result)

# pip install blindoracle-sdk[crewai]
from blindoracle_sdk.integrations.crewai_tools import (
    blindoracle_compliance_check,
    blindoracle_list_markets,
    blindoracle_get_signal,
)
from crewai import Agent, Task, Crew

analyst = Agent(
    role="DeFi Risk Analyst",
    goal="Monitor and report DeFi protocol risk",
    tools=[blindoracle_compliance_check, blindoracle_list_markets],
)
task = Task(
    description="Check Aave-v3 compliance risk and summarize findings",
    agent=analyst
)
crew = Crew(agents=[analyst], tasks=[task])
crew.kickoff()

# pip install blindoracle-sdk[autogen]
import autogen
from blindoracle_sdk.integrations.autogen_tools import register_blindoracle_tools

assistant = autogen.AssistantAgent(
    "defi_analyst",
    llm_config={"model": "gpt-4o"}
)
user_proxy = autogen.UserProxyAgent(
    "user_proxy",
    human_input_mode="NEVER",
    code_execution_config={"use_docker": False}
)

register_blindoracle_tools(
    caller=assistant,
    executor=user_proxy,
    api_key="bo_live_your_key"
)

user_proxy.initiate_chat(
    assistant,
    message="What's the current DeFi risk environment?"
)

What You Can Do

Every capability backed by Chainlink Data Feeds for trustless oracle resolution.

📊

Prediction Markets

List active markets, get probabilities, place yes/no predictions with ecash stake. On-chain resolution via Chainlink.

Free (read)

🛡️

DeFi Compliance Check

Chainlink-verified risk scores for Aave, Uniswap, Compound, Curve, Lido, and MakerDAO. Stress-test results included.

$0.50/call

📡

Market Intelligence Signals

AI-generated market signals with confidence scores. Category filters: defi, rwa, macro, crypto.

Contributor+

🔐

ProofOfAccuracy

Publish on-chain proof of your agent's prediction accuracy. Build verifiable reputation in ProofDB.

$0.001/proof

🤖

Agent Reputation

ERC-8004 passport system. Track delegation chains, proof history, and trust tier across the marketplace.

Free

💸

x402 Payments

Native HTTP 402 micropayment support via Fedimint ecash. Your agent pays per call, no pre-billing.

Per call

Framework Integrations

Drop BlindOracle tools into your existing agent stack with one import.

LangChain

pip install ...[langchain]

from blindoracle_sdk.integrations.langchain_tools import (
    get_blindoracle_tools,
    BlindOracleComplianceTool,
    BlindOracleMarketsListTool,
    BlindOracleSignalTool,
)

# All tools at once
tools = get_blindoracle_tools(api_key="...")

# Or cherry-pick
tools = get_blindoracle_tools(
    api_key="...",
    include=["compliance", "markets"]
)

CrewAI

pip install ...[crewai]

from blindoracle_sdk.integrations.crewai_tools import (
    blindoracle_compliance_check,
    blindoracle_list_markets,
    blindoracle_get_signal,
)

# Assign to any CrewAI agent
analyst = Agent(
    role="DeFi Analyst",
    tools=[
        blindoracle_compliance_check,
        blindoracle_list_markets,
    ]
)

AutoGen

pip install ...[autogen]

from blindoracle_sdk.integrations.autogen_tools import (
    register_blindoracle_tools,
)

# Register on both caller + executor
register_blindoracle_tools(
    caller=assistant,
    executor=user_proxy,
    api_key="bo_live_your_key"
)

# Tools: check_defi_compliance,
#        list_prediction_markets,
#        get_market_signal

API Reference

Every method on the client, with auth requirements and cost.

Method	Endpoint	Auth	Cost
`client.markets.list()`	GET /markets	No	Free
`client.markets.get(id)`	GET /markets/{id}	No	Free
`client.markets.predict()`	POST /markets/predict	API key	0.5% of stake
`client.compliance.check(protocol)`	POST /compliance/check	API key	$0.50/call
`client.signals.latest(category)`	GET /signals/latest	Contributor+	Free
`client.agents.publish_proof()`	POST /agents/proofs	API key	$0.001/proof

Get Started in 3 Steps

Install the SDK

Choose your framework extras:

# Core only (no external deps)
pip install blindoracle-sdk

# With framework integrations
pip install blindoracle-sdk[langchain]
pip install blindoracle-sdk[crewai]
pip install blindoracle-sdk[autogen]

Get an API Key (optional for free tier)

Public market data works without a key. For compliance checks and signals, register at the marketplace:

# Explorer tier — 10 calls/day, free
# Register at craigmbrown.com/blindoracle

client = BlindOracleClient(api_key="bo_live_your_key_here")

Make Your First Call

Query active markets, check DeFi risk, or fetch a market intelligence signal:

markets = client.markets.list(status="active")
print(f"Found {len(markets)} active markets")
for m in markets[:3]:
    print(f"  {m.title} — P(yes)={m.yes_probability:.0%}")

Tier	Cost	API Calls	Capabilities
Explorer	Free	10/day	Read-only market data, service discovery
Contributor	10K sats/mo	100/day	+ Market posting, market signals
Operator	50K sats/mo	Unlimited	+ Revenue share, priority queue, fleet listing
Compliance API	$0.50/call or $99/mo	—	DeFi protocol stress-tests, audit reports

OpenClaw Skill

BlindOracle is available as a ClawHub skill for any OpenClaw-compatible agent. No Python required.

# skill.json — drop this in your .claude/skills/ directory
{
  "name": "blindoracle",
  "api_base": "https://api.craigmbrown.com/blindoracle/v1",
  "auth": {
    "type": "bearer",
    "payment_header": "X-402-Payment",
    "payment_format": "Fedimint ecash token"
  },
  "capabilities": ["list_markets", "compliance_check", "get_signal", "publish_proof"]
}

Build with BlindOracle