Governance

The state chain implements DAO governance through multisig blocks. A quorum of DAO members must sign each block before it can be applied to the chain. The DAO keyset -- the set of authorised signers and their quorum threshold -- is stored in the chain's own KV store, making governance self-referential: the keyset governs changes to itself.

#DAOKeyset

type DAOKeyset struct {    Keys      []string // hex-encoded ed25519 public keys (64 hex chars each)    Threshold int      // minimum number of valid signatures required}

The keyset is stored under the sys.dao_keyset key in the state chain's KV store. It is set in the genesis block and can be updated by subsequent blocks (signed by the current keyset).

#Block structure

1type Block struct {2    Index      uint64           `json:"index"`3    PrevHash   string           `json:"prev_hash"`4    Ops        []Op             `json:"ops"`5    Signatures []BlockSignature `json:"signatures"`6    Hash       string           `json:"hash"`7    Timestamp  int64            `json:"timestamp"`8}

#BlockSignature

type BlockSignature struct {    PublicKey string `json:"public_key"` // hex-encoded ed25519 public key    Sig       string `json:"signature"`  // hex-encoded ed25519 signature}

Each signature is over the block's Hash field. The signer must be a member of the current DAOKeyset.

#Multisig validation

When AddBlock processes a new block, it validates the multisig:

1. Hash verification -- recompute the hash from ops and compare to block.Hash.
2. Duplicate check -- reject blocks with the same signer appearing twice.
3. Keyset membership -- every signer's public key must be in the current DAOKeyset.Keys.
4. Signature verification -- each ed25519.Verify(pubkey, hash, signature) must pass.
5. Threshold check -- the count of valid signatures must be >= DAOKeyset.Threshold.

Block arrives    │    ▼Verify block hash (recompute from ops)    │    ▼For each signature:    ├── Duplicate signer? → reject    ├── Not in keyset? → reject    └── Signature invalid? → reject    │    ▼Valid count >= threshold? → accept

#Chain management

#NewChain

func NewChain(store StateChainStore, genesis *Block) (*Chain, error)

Creates a new chain instance:

1. Validates the genesis block.
2. Creates an empty KV store.
3. Applies genesis ops (must include sys.dao_keyset).
4. Replays all stored blocks to rebuild KV state.
5. Verifies a valid keyset exists after replay.

#AddBlock

func (c *Chain) AddBlock(b *Block) error

Validates and applies a new block:

1. Verify hash -- recompute and compare.
2. Duplicate/fork check -- if the block's index is at or below the tip, check for duplicate or fork.
3. Gap check -- index must be exactly tip.Index + 1.
4. PrevHash check -- must match the tip's hash.
5. Timestamp monotonicity -- must be >= previous block's timestamp.
6. Op validation -- each operation is validated (key format, value size, JSON validity).
7. Block size check -- serialized block must not exceed MaxBlockSize.
8. Multisig validation -- using the current keyset.
9. Persist and apply -- store the block, update KV state, advance tip.

#Fork detection

If a block arrives with the same index as an existing block but a different hash, a fork is detected:

1. The incoming block's multisig is verified (to filter out garbage).
2. If valid, the forkCallback is invoked with both the existing and incoming blocks.
3. The fork is rejected -- the chain does not switch branches.

#Chain struct

1type Chain struct {2    store        StateChainStore3    kv           *KVStore           // in-memory key-value state4    tip          *Block             // latest block5    genesis      *Block             // genesis block (index 0)6    onBlock      func(*Block)       // callback on new block applied7    forkCallback func(existing, incoming *Block) // fork alert8}

#Size limits