Lux Session - Private Permissionless Session Execution Layer

package main

    "fmt"
    "log"

    "github.com/luxfi/session/crypto"
)

func main() {
    // Generate PQ identity (ML-KEM-768 + ML-DSA-65)
    alice, err := crypto.GenerateIdentity()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Alice Session ID:", alice.SessionID) // "07" + 64 hex chars

    bob, err := crypto.GenerateIdentity()
    if err != nil {
        log.Fatal(err)
    }

    // Encrypt message from Alice to Bob (KEM encapsulate + XChaCha20)
    plaintext := []byte("hello from alice")
    ciphertext, err := alice.EncryptTo(bob.PublicIdentity(), plaintext)
    if err != nil {
        log.Fatal(err)
    }

    // Bob decrypts (KEM decapsulate + XChaCha20)
    decrypted, err := bob.DecryptFrom(ciphertext)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Decrypted:", string(decrypted))

    // Sign and verify
    signed, err := alice.SignMessage(plaintext)
    if err != nil {
        log.Fatal(err)
    }

    msg, valid := alice.PublicIdentity().VerifyMessage(signed)
    fmt.Println("Valid:", valid, "Message:", string(msg))
}

package main

    "context"
    "fmt"
    "log"

    "github.com/luxfi/session/core"
    "github.com/luxfi/session/daemon"
)

func main() {
    svc := daemon.New(daemon.DefaultConfig())
    if err := svc.Start(context.Background()); err != nil {
        log.Fatal(err)
    }
    defer svc.Stop()

    serviceID := core.Hash([]byte("my-service"))
    txID := core.Hash([]byte("tx-001"))
    committee := []core.ID{core.Hash([]byte("node-1")), core.Hash([]byte("node-2")), core.Hash([]byte("node-3"))}

    session, err := svc.CreateSession(serviceID, 1, txID, committee)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Session ID:", session.ID.String())
    fmt.Println("State:", session.State) // pending

    if err := svc.StartSession(session.ID); err != nil {
        log.Fatal(err)
    }
    fmt.Println("State:", session.State) // running
}

github.com/luxfi/session
├── core/                    # Canonical types shared by VM and daemon
│   ├── id.go               # 32-byte ID type, domain-separated hashing
│   ├── session.go           # Session struct (committee, steps, state machine)
│   └── step.go              # Step types (compute, read/write external), oracle request IDs
├── crypto/
│   ├── identity.go          # PQ identity (ML-KEM-768 + ML-DSA-65 keypairs)
│   └── identity_test.go     # Crypto tests and benchmarks
├── vm/                      # Lux VM plugin (encrypted messaging)
│   ├── vm.go                # SessionVM: sessions, messages, channels, JSON-RPC handlers
│   ├── service.go           # RPC methods: CreateSession, GetSession, SendMessage, CloseSession, Health
│   ├── factory.go           # VM factory, VMID constant
│   └── vm_test.go           # VM unit tests
├── daemon/
│   └── service.go           # sessiond: session runner, oracle requests, attestation handling
├── network/
│   ├── peer.go              # Peer management, connection state, latency tracking
│   └── transport.go         # Transport interface, message types, router, binary framing
├── protocol/
│   ├── domain.go            # Attestation domains (oracle/write, oracle/read, session/complete, epoch/beacon)
│   ├── attestation.go       # Threshold attestations, equivocation detection
│   ├── oracle.go            # Oracle requests/records, Merkle tree, inclusion proofs
│   └── receipt.go           # Delivery receipts, receipt Merkle proofs
├── storage/
│   ├── store.go             # KV store interface (Get/Put/Delete/Has), batch, iterator, namespaces
│   ├── memory.go            # In-memory store implementation
│   └── encoding.go          # Binary codec for Session and Step serialization
├── swarm/
│   ├── registry.go          # Service node registry (register, activate, suspend, slash, exit)
│   └── assignment.go        # Epoch-based committee assignment via deterministic VRF selection
├── plugin/
│   └── main.go              # Lux VM plugin entry point (HTTP server on :9652)
├── cmd/sessiond/
│   └── main.go              # Standalone daemon entry point (flags: -listen, -data-dir, -max-sessions)
├── e2e/                     # End-to-end tests
├── messaging/               # Empty (reserved)
├── session/                 # Empty (reserved)
└── docs/                    # Architecture, crypto, integration docs

pending -> running -> waiting_io -> running -> ... -> finalized
                  \-> failed

active -> expired (TTL exceeded)
       -> closed  (explicit close)

{
  "sessionTTL": 86400,
  "maxMessages": 10000,
  "maxChannels": 1000,
  "retentionDays": 30,
  "idPrefix": "07"
}