Decentralized Verifiable Data Science
And nobody can prove how they decided.
Smart contracts written in real Python — not a DSL, not Solidity.
scikit-learn models executed deterministically on-chain via panda.ml.
Native messaging across Ethereum, Solana, Panda L2 and Panda Hub.
Proof-backed compute and rollup architecture from day one.
@contract decoratorclass State for storage@call mutates · @query readsself.emit() for indexable eventsfrom panda import contract, constructor, call, query, event
@contract
class Counter:
class State:
count: int = 0
owner: str = ""
last_caller: str = ""
@constructor
def deploy(self, ctx, initial_count: int = 0):
self.state.owner = ctx.sender
self.state.count = initial_count
@call
def increment(self, ctx):
self.state.count += 1
self.state.last_caller = ctx.sender
self.emit(event.CountChanged(new_count=self.state.count))
@query
def get_count(self) -> int:
return self.state.countctx you've been waiting forOne object. Everything you need to build trust-minimised logic.
@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)Wraps scikit-learn for deterministic on-chain execution.
Models serialise to state. Re-loaded for every prediction.
Every predict() is reproducible by every validator.
@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.
Two patterns: fire-and-forget, or async/await.
@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.
Browser IDE, Python syntax, deploy & interact panels.
TypeScript & Python, programmatic contract management.
Simulate cross-chain messages, replay async calls offline.
Every event emitted via self.emit(), queryable.
AI is eating software every decision.
Verifiability is the only path to trust at scale.
Pandachain is built for that future.
Open the playground. Deploy in 60 seconds.