Pandachain
Decentralized Verifiable Machine Learning
Models decidewho gets a loan,a job,a diagnosis.
And nobody can prove how they decided.
the vision
What is Pandachain_
Python-native
No Solidity. No Rust. Smart contracts in the language you already know.
Verifiable ML
scikit-learn, TensorFlow, PyTorch, and XGBoost — deterministic on-chain via panda.ml.
Cross-chain
Deploy once, message across Ethereum, Solana, Panda L2, and Panda Hub.
ZK + Rollups
RISC Zero, Halo2, and SP1 proof backends with rollup architecture from day one.
Real Python.
On a real chain.
@contractdecorator- typed
class Statefor storage @callmutates ·@queryreadsself.emit()for indexable events
from panda import contract, constructor
from panda import call, query, event
@contract
class Counter:
class State:
count: int = 0
@constructor
def deploy(self, ctx, start: int = 0):
self.state.count = start
@call
def increment(self, ctx):
self.state.count += 1
self.emit(event.CountChanged(
new_count=self.state.count
))The ctx you've been waiting for
One object. Everything you need to build trust-minimised logic.
PRC-20. Tokens in pure Python.
@contract
class PRC20Token:
class State:
token: dict = {}
mint_authority: str = ""
freeze_authority: str = ""
frozen: dict = {}
@call
def transfer(self, ctx, to: str, value: int):
# transfer logic with frozen-account checks
self.emit(event.Transfer(_from=ctx.sender,
_to=to, _value=value))
@query
def balance_of(self, owner: str) -> int:
return self._t().balance_of(owner)Machine learning, on-chain.
panda.ml
The full scientific Python stack — scikit-learn, TensorFlow, PyTorch, XGBoost — running deterministically inside smart contracts.
save_model / load_model
Model weights serialize to contract state. Loaded fresh for every prediction with cryptographic proof of every computation.
Verifiable inference
Six-layer determinism enforcement ensures every predict() is identical across every validator, every time.
A fraud detector that anyone can audit.
@contract
class FraudDetector:
class State:
model: dict = {}
is_trained: bool = False
@call
def train(self, ctx, features: list, labels: list):
model = LogisticRegression()
model.fit(features, labels)
self.state.model = save_model(model)
self.state.is_trained = True
@query
def predict(self, features: list) -> list:
model = load_model(self.state.model)
return model.predict_proba(features)Training data, weights, and predictions — all on-chain. All verifiable.
Cross-chain_
Two patterns: fire-and-forget, or async/await.
Whitelist a chain. Receive a message. Done.
@receiver(chains=["ethereum"])
def on_tokens_locked(self, ctx, amount: int, sender: str):
self.state.balances[sender] += amount
@receiver() # any chain
def on_any_message(self, ctx, data: str):
self.emit(event.MessageReceived(payload=data))
async def bridge(self, ctx, to: str, value: int):
result = await Chain.ethereum().call(
contract="0xBridge", method="release", to=to, value=value)
return result@receiver methods cannot be invoked via @call — cross-chain context is required.
Tooling that doesn't get in your way
Playground
Browser IDE with Python syntax highlighting. Write, deploy, and interact — all in one tab.
SDKs
TypeScript & Python SDKs for programmatic deploy, call, and query.
ContractTestRunner
Full local test harness — simulate cross-chain messages, replay async calls, assert state changes.
Live Indexer
Real-time event stream. Every self.emit() indexed, filterable, and queryable via API.
Ship in minutes.
- 01 Hello World
- 02 PRC-20 fungible token
- 03 PRC-721 NFT collection
- 04 AMM swap contract
- 05 Voting / governance
- 06 On-chain ML model
The stack
why now
AI is eating software every decision.
Verifiability is the only path to trust at scale.
Pandachain is built for that future.
Build verifiable.
Open the playground. Deploy your first contract in 60 seconds.