《游戏服务端架构·品类、状态与拓扑》6.3 经济系统与随机数的可信边界

开局前   服务端生成 serverSeed，公布 commit = SHA256(serverSeed)
         玩家提交 clientSeed（或在对局开始时固定）
结算时   rand = HMAC(serverSeed, clientSeed || round)
         按 rand 在掉落表当前版本中取结果
公布后   服务端公布 serverSeed
         玩家校验 SHA256(serverSeed) == commit，并自行重算 rand

掉落：  player:1  +100     system:faucet  -100
消费：  player:1   -30     system:sink     +30
补偿：  player:1   +50     system:support  -50

// file: internal/economy/economy.go
// tier: L1
// verify: go test ./internal/economy/
package economy

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/binary"
	"encoding/hex"
	"errors"
	"fmt"
	"sort"
)

// Commit seals a server seed before the round starts. SHA-256 is enough here
// because the seed is 32 random bytes, not a guessable user value.
func Commit(serverSeed []byte) string {
	sum := sha256.Sum256(serverSeed)
	return hex.EncodeToString(sum[:])
}

func Reveal(serverSeed []byte, commit string) bool { return Commit(serverSeed) == commit }

// Roll derives a uint64 from both seeds and the round number. HMAC keeps the
// server seed from being recoverable from published outcomes.
func Roll(serverSeed, clientSeed []byte, round uint64) uint64 {
	var buf [8]byte
	binary.BigEndian.PutUint64(buf[:], round)
	mac := hmac.New(sha256.New, serverSeed)
	mac.Write(clientSeed)
	mac.Write(buf[:])
	sum := mac.Sum(nil)
	return binary.BigEndian.Uint64(sum[:8])
}

type Entry struct {
	Item   string
	Weight int
}

// DropTable is immutable. A rebalance creates a new version instead of editing
// an existing one, so historical draws can always be re-derived.
type DropTable struct {
	Name    string
	Version int
	entries []Entry
	total   int
}

func NewTable(name string, version int, entries []Entry) (*DropTable, error) {
	if name == "" {
		return nil, errors.New("economy: empty table name")
	}
	if version < 1 {
		return nil, errors.New("economy: version must be >= 1")
	}
	if len(entries) == 0 {
		return nil, errors.New("economy: empty drop table")
	}
	t := &DropTable{Name: name, Version: version, entries: append([]Entry(nil), entries...)}
	seen := make(map[string]bool, len(entries))
	for _, e := range t.entries {
		if e.Item == "" {
			return nil, errors.New("economy: empty item name")
		}
		if e.Weight <= 0 {
			return nil, fmt.Errorf("economy: item %s has non-positive weight", e.Item)
		}
		if seen[e.Item] {
			return nil, fmt.Errorf("economy: duplicate item %s", e.Item)
		}
		seen[e.Item] = true
		t.total += e.Weight
	}
	return t, nil
}

func (t *DropTable) Total() int { return t.total }

// Draw maps an already-derived random value onto the table. Callers must pass a
// value from Roll, never a client-supplied index.
func (t *DropTable) Draw(rand uint64) (string, error) {
	if t.total <= 0 {
		return "", errors.New("economy: table has no weight")
	}
	roll := int(rand % uint64(t.total))
	acc := 0
	for _, e := range t.entries {
		acc += e.Weight
		if roll < acc {
			return e.Item, nil
		}
	}
	return "", errors.New("economy: roll outside table")
}

// TableSet keeps every published version. Get is how an audit re-runs an old
// draw; Latest is how live traffic picks the current table.
type TableSet struct {
	tables map[string][]*DropTable
}

func NewTableSet() *TableSet {
	return &TableSet{tables: make(map[string][]*DropTable)}
}

func (s *TableSet) Add(t *DropTable) error {
	for _, old := range s.tables[t.Name] {
		if old.Version == t.Version {
			return fmt.Errorf("economy: table %s version %d already exists", t.Name, t.Version)
		}
	}
	s.tables[t.Name] = append(s.tables[t.Name], t)
	sort.Slice(s.tables[t.Name], func(i, j int) bool {
		return s.tables[t.Name][i].Version < s.tables[t.Name][j].Version
	})
	return nil
}

func (s *TableSet) Get(name string, version int) (*DropTable, error) {
	for _, t := range s.tables[name] {
		if t.Version == version {
			return t, nil
		}
	}
	return nil, fmt.Errorf("economy: table %s version %d not found", name, version)
}

func (s *TableSet) Latest(name string) (*DropTable, error) {
	versions := s.tables[name]
	if len(versions) == 0 {
		return nil, fmt.Errorf("economy: table %s not found", name)
	}
	return versions[len(versions)-1], nil
}

type Posting struct {
	Account string
	Amount  int64
}

// Journal is one balanced transaction. Positive amounts debit, negative
// amounts credit; the names are bookkeeping, not game semantics.
type Journal struct {
	ID       string
	Round    uint64
	Memo     string
	Postings []Posting
}

var (
	ErrUnbalanced = errors.New("economy: journal does not sum to zero")
	ErrDuplicate  = errors.New("economy: duplicate journal id")
	ErrNoPostings = errors.New("economy: journal has no postings")
)

// Ledger is an append-only double-entry book. Balances are a cache derived from
// journals; Verify rebuilds them to catch accidental direct writes.
type Ledger struct {
	balances map[string]int64
	journals []Journal
	seen     map[string]bool
}

func NewLedger() *Ledger {
	return &Ledger{balances: make(map[string]int64), seen: make(map[string]bool)}
}

func (l *Ledger) Post(j Journal) error {
	if j.ID == "" {
		return errors.New("economy: empty journal id")
	}
	if l.seen[j.ID] {
		return ErrDuplicate
	}
	if len(j.Postings) == 0 {
		return ErrNoPostings
	}
	var sum int64
	for _, p := range j.Postings {
		if p.Account == "" {
			return errors.New("economy: empty account")
		}
		if p.Amount == 0 {
			return errors.New("economy: zero posting")
		}
		sum += p.Amount
	}
	if sum != 0 {
		return ErrUnbalanced
	}
	l.seen[j.ID] = true
	for _, p := range j.Postings {
		l.balances[p.Account] += p.Amount
	}
	copied := j
	copied.Postings = append([]Posting(nil), j.Postings...)
	l.journals = append(l.journals, copied)
	return nil
}

func (l *Ledger) Balance(account string) int64 { return l.balances[account] }

func (l *Ledger) Verify() error {
	rebuilt := make(map[string]int64)
	for _, j := range l.journals {
		var sum int64
		for _, p := range j.Postings {
			rebuilt[p.Account] += p.Amount
			sum += p.Amount
		}
		if sum != 0 {
			return fmt.Errorf("economy: journal %s is unbalanced", j.ID)
		}
	}
	if len(rebuilt) != len(l.balances) {
		return errors.New("economy: account set drift")
	}
	for account, want := range rebuilt {
		if l.balances[account] != want {
			return fmt.Errorf("economy: balance drift on %s", account)
		}
	}
	return nil
}

type Diff struct {
	Account  string
	Ledger   int64
	Snapshot int64
}

// Reconcile compares the ledger with an external snapshot. It reports drift; it
// never "fixes" it, because an automatic fix destroys the evidence needed to
// decide whether the ledger or the snapshot is wrong.
func (l *Ledger) Reconcile(snapshot map[string]int64) []Diff {
	seen := make(map[string]bool, len(l.balances))
	var out []Diff
	for account, balance := range l.balances {
		seen[account] = true
		if snap, ok := snapshot[account]; !ok || snap != balance {
			out = append(out, Diff{Account: account, Ledger: balance, Snapshot: snap})
		}
	}
	for account, snap := range snapshot {
		if !seen[account] {
			out = append(out, Diff{Account: account, Ledger: 0, Snapshot: snap})
		}
	}
	sort.Slice(out, func(i, j int) bool { return out[i].Account < out[j].Account })
	return out
}

$ go test -count=1 ./internal/economy/
ok  	gsarchlab/internal/economy	0.468s