Enforce governance policies as code for Solana DAOs and programs.

The Solana Governance Policy Engine is a rules‑driven enforcement layer for DAOs and on‑chain programs—codifying quorum, role‑based permissions, KYC checks, and escalation paths into a reusable, auditable engine.

MIT Licensed • Open Source

Async Off‑Chain Verification Daemon

Designed for production‑grade DAOs

Open GitHub Template View Multi‑Language Clients

Policy evaluation flow

Solana + Off‑Chain Signals

// Pseudocode: high‑level evaluation pipeline

on_proposal_created(proposal) {
  // 1. Load DAO policy pack
  policy = load_policy(proposal.dao_id)

  // 2. Resolve on‑chain context
  ctx = {
    dao_state: fetch_dao_state(proposal.dao_id),
    stake_snapshot: fetch_stake(proposal.dao_id),
    proposal_meta: proposal.metadata,
  }

  // 3. Pull off‑chain verification signals (KYC, sanctions, risk)
  signals = async_verifier.fetch_signals(proposal.initiator)

  // 4. Evaluate rules
  result = policy_engine.evaluate({
    context: ctx,
    signals: signals,
    action: "CREATE_PROPOSAL",
  })

  // 5. Enforce
  if (!result.allowed) {
    revert("POLICY_VIOLATION", result.reason_code)
  }
}

Deterministic policy evaluation

Composable rule packs

Audit‑ready decision traces

Integration surface

Go • Kotlin • Python • JS

Use the engine from Go, Kotlin, Python, or JavaScript clients, backed by a Python policy API for off‑chain evaluation and async verification.

REST / JSON‑RPC boundary

Solana program hooks

Off‑chain daemon for KYC / risk

Client SDKs

Multi‑language policy clients

The policy engine is designed to be called from multiple runtimes: Go for Solana‑adjacent services, Kotlin for JVM backends, Python for orchestration and analytics, and JavaScript for dashboards and admin consoles. All clients speak a simple JSON policy‑evaluation contract over HTTP.

Language‑agnostic policy API

Deterministic request / response schema

Trace IDs for audits

Client examples

Copy‑paste ready

JavaScript

Python

Kotlin

// JavaScript client (browser / Node)

async function evaluatePolicy(payload) {
  const res = await fetch("https://your-policy-api.example.com/evaluate", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      action: "CAST_VOTE",
      dao_id: payload.daoId,
      wallet: payload.wallet,
      proposal_id: payload.proposalId,
      stake: payload.stakeLamports,
      context: {
        slot: payload.slot,
        cluster: payload.cluster,
      },
    }),
  });

  if (!res.ok) {
    throw new Error("Policy API error: " + res.status);
  }

  const body = await res.json();
  if (!body.allowed) {
    console.warn("Vote blocked by policy:", body.reason_code);
  }
  return body;
}

# Python client

import requests

def evaluate_policy(base_url: str, payload: dict) -> dict:
  resp = requests.post(
      f"{base_url}/evaluate",
      json={
          "action": "CREATE_PROPOSAL",
          "dao_id": payload["dao_id"],
          "wallet": payload["wallet"],
          "metadata": payload.get("metadata", {}),
          "context": {
              "cluster": payload.get("cluster", "mainnet-beta"),
              "slot": payload.get("slot"),
          },
      },
      timeout=5,
  )
  resp.raise_for_status()
  body = resp.json()
  if not body.get("allowed", False):
      print("Policy violation:", body.get("reason_code"))
  return body

// Go client

package policy

import (
  "bytes"
  "context"
  "encoding/json"
  "net/http"
  "time"
)

type EvaluateRequest struct {
  Action  string                 `json:"action"`
  DaoID   string                 `json:"dao_id"`
  Wallet  string                 `json:"wallet"`
  Context map[string]interface{} `json:"context,omitempty"`
}

type EvaluateResponse struct {
  Allowed    bool   `json:"allowed"`
  ReasonCode string `json:"reason_code"`
  Trac