mirror of
https://github.com/QuilibriumNetwork/ceremonyclient.git
synced 2026-02-22 02:47:26 +08:00
861 lines
21 KiB
Go
861 lines
21 KiB
Go
package global
|
||
|
||
import (
|
||
"bytes"
|
||
_ "embed"
|
||
"encoding/base64"
|
||
"encoding/binary"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"fmt"
|
||
"io"
|
||
"math/big"
|
||
"net/http"
|
||
"slices"
|
||
"time"
|
||
|
||
"github.com/iden3/go-iden3-crypto/poseidon"
|
||
pcrypto "github.com/libp2p/go-libp2p/core/crypto"
|
||
"github.com/libp2p/go-libp2p/core/peer"
|
||
"github.com/mr-tron/base58"
|
||
"go.uber.org/zap"
|
||
hgcrdt "source.quilibrium.com/quilibrium/monorepo/hypergraph"
|
||
globalintrinsics "source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/global"
|
||
"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/global/compat"
|
||
"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/token"
|
||
hgstate "source.quilibrium.com/quilibrium/monorepo/node/execution/state/hypergraph"
|
||
"source.quilibrium.com/quilibrium/monorepo/protobufs"
|
||
"source.quilibrium.com/quilibrium/monorepo/types/execution/intrinsics"
|
||
"source.quilibrium.com/quilibrium/monorepo/types/schema"
|
||
"source.quilibrium.com/quilibrium/monorepo/types/store"
|
||
"source.quilibrium.com/quilibrium/monorepo/types/tries"
|
||
up2p "source.quilibrium.com/quilibrium/monorepo/utils/p2p"
|
||
)
|
||
|
||
// GenesisJson represents the structure of the mainnet genesis JSON
|
||
type GenesisJson struct {
|
||
FrameNumber uint64 `json:"frame_number"`
|
||
Timestamp int64 `json:"timestamp"`
|
||
Difficulty uint32 `json:"difficulty"`
|
||
ParentSelector string `json:"parent_selector"`
|
||
InitialCommitments map[string]string `json:"initial_commitments"`
|
||
Output string `json:"output"`
|
||
BeaconEd448Key string `json:"beacon_ed448_key"`
|
||
BeaconBLS48581Key string `json:"beacon_bls48581_key"`
|
||
ArchivePeers map[string]string `json:"archive_peers"`
|
||
}
|
||
|
||
// TODO[2.1.1+]: Refactor out direct hypergraph access
|
||
func (e *GlobalConsensusEngine) initializeGenesis() *protobufs.GlobalFrame {
|
||
e.logger.Info("initializing genesis frame for global consensus")
|
||
|
||
var genesisFrame *protobufs.GlobalFrame
|
||
|
||
// If on mainnet, load from release
|
||
if e.config.P2P.Network == 0 {
|
||
var lastErr error
|
||
var genesisData GenesisJson = GenesisJson{}
|
||
for attempt := 1; attempt <= 5; attempt++ {
|
||
if err := func() error {
|
||
resp, err := http.Get("https://releases.quilibrium.com/genesis.json")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
if resp.StatusCode != http.StatusOK {
|
||
return fmt.Errorf("http status %d", resp.StatusCode)
|
||
}
|
||
|
||
buf := bytes.NewBuffer(nil)
|
||
_, err = io.Copy(buf, resp.Body)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
err = json.Unmarshal(buf.Bytes(), &genesisData)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}(); err != nil {
|
||
lastErr = err
|
||
// simple backoff: 200ms * attempt
|
||
time.Sleep(time.Duration(200*attempt) * time.Millisecond)
|
||
continue
|
||
}
|
||
lastErr = nil
|
||
break
|
||
}
|
||
if lastErr != nil {
|
||
e.logger.Error("failed to download genesis", zap.Error(lastErr))
|
||
return nil
|
||
}
|
||
|
||
// Decode base64 encoded fields
|
||
parentSelector, err := base64.StdEncoding.DecodeString(
|
||
genesisData.ParentSelector,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to decode parent selector", zap.Error(err))
|
||
return nil
|
||
}
|
||
|
||
output, err := base64.StdEncoding.DecodeString(genesisData.Output)
|
||
if err != nil {
|
||
e.logger.Error("failed to decode output", zap.Error(err))
|
||
return nil
|
||
}
|
||
|
||
// Create genesis header with actual data
|
||
genesisHeader := &protobufs.GlobalFrameHeader{
|
||
FrameNumber: genesisData.FrameNumber,
|
||
ParentSelector: parentSelector,
|
||
Timestamp: genesisData.Timestamp,
|
||
Difficulty: genesisData.Difficulty,
|
||
GlobalCommitments: make([][]byte, 256),
|
||
ProverTreeCommitment: make([]byte, 64),
|
||
Output: output,
|
||
}
|
||
|
||
// Initialize all commitments with empty values first
|
||
for i := range 256 {
|
||
genesisHeader.GlobalCommitments[i] = make([]byte, 64)
|
||
}
|
||
|
||
commitments := make([]*tries.VectorCommitmentTree, 256)
|
||
for i := range 256 {
|
||
commitments[i] = &tries.VectorCommitmentTree{}
|
||
}
|
||
|
||
proverRoot := make([]byte, 64)
|
||
|
||
// Parse and set initial commitments from JSON
|
||
for hexKey, base64Value := range genesisData.InitialCommitments {
|
||
// Decode hex key to get index
|
||
keyBytes, err := hex.DecodeString(hexKey)
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to decode commitment key",
|
||
zap.String("key", hexKey),
|
||
zap.Error(err),
|
||
)
|
||
continue
|
||
}
|
||
|
||
commitmentValue, err := base64.StdEncoding.DecodeString(base64Value)
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to decode commitment value",
|
||
zap.String("value", base64Value),
|
||
zap.Error(err),
|
||
)
|
||
return nil
|
||
}
|
||
|
||
l1 := up2p.GetBloomFilterIndices(keyBytes, 256, 3)
|
||
|
||
txn, err := e.clockStore.NewTransaction(false)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
|
||
for i := 0; i < 64; i++ {
|
||
for j := 0; j < 64; j++ {
|
||
err = e.shardsStore.PutAppShard(txn, store.ShardInfo{
|
||
L1: l1,
|
||
L2: keyBytes,
|
||
Path: []uint32{uint32(i), uint32(j)},
|
||
})
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to place app shard",
|
||
zap.String("value", base64Value),
|
||
zap.Error(err),
|
||
)
|
||
txn.Abort()
|
||
return nil
|
||
}
|
||
}
|
||
}
|
||
|
||
for i := 0; i < 3; i++ {
|
||
commitments[l1[i]].Insert(
|
||
keyBytes,
|
||
commitmentValue,
|
||
nil,
|
||
big.NewInt(int64(len(commitmentValue))),
|
||
)
|
||
commitments[l1[i]].Commit(e.inclusionProver, false)
|
||
}
|
||
}
|
||
|
||
state := hgstate.NewHypergraphState(e.hypergraph)
|
||
|
||
err = e.establishMainnetGenesisProvers(state, genesisData)
|
||
if err != nil {
|
||
e.logger.Error("failed to establish provers", zap.Error(err))
|
||
return nil
|
||
}
|
||
|
||
err = state.Commit()
|
||
if err != nil {
|
||
e.logger.Error("failed to commit", zap.Error(err))
|
||
return nil
|
||
}
|
||
|
||
roots := e.hypergraph.Commit()
|
||
proverRoots := roots[tries.ShardKey{
|
||
L1: [3]byte{},
|
||
L2: intrinsics.GLOBAL_INTRINSIC_ADDRESS,
|
||
}]
|
||
|
||
proverRoot = proverRoots[0]
|
||
|
||
genesisHeader.ProverTreeCommitment = proverRoot
|
||
|
||
for i := 0; i < 256; i++ {
|
||
genesisHeader.GlobalCommitments[i] = commitments[i].Commit(
|
||
e.inclusionProver,
|
||
false,
|
||
)
|
||
}
|
||
|
||
// Establish an empty signature payload – this avoids panics on broken
|
||
// header readers
|
||
genesisHeader.PublicKeySignatureBls48581 =
|
||
&protobufs.BLS48581AggregateSignature{
|
||
Signature: make([]byte, 0),
|
||
PublicKey: &protobufs.BLS48581G2PublicKey{
|
||
KeyValue: make([]byte, 0),
|
||
},
|
||
Bitmask: make([]byte, 0),
|
||
}
|
||
|
||
genesisFrame = &protobufs.GlobalFrame{
|
||
Header: genesisHeader,
|
||
Requests: []*protobufs.MessageBundle{},
|
||
}
|
||
} else {
|
||
// For non-mainnet, use stub genesis
|
||
genesisFrame = e.createStubGenesis()
|
||
txn, err := e.clockStore.NewTransaction(false)
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to place app shard",
|
||
zap.Error(err),
|
||
)
|
||
return nil
|
||
}
|
||
|
||
l1 := up2p.GetBloomFilterIndices(token.QUIL_TOKEN_ADDRESS, 256, 3)
|
||
|
||
err = e.shardsStore.PutAppShard(txn, store.ShardInfo{
|
||
L1: l1,
|
||
L2: token.QUIL_TOKEN_ADDRESS,
|
||
Path: []uint32{},
|
||
})
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to place app shard",
|
||
zap.Error(err),
|
||
)
|
||
txn.Abort()
|
||
return nil
|
||
}
|
||
if err = txn.Commit(); err != nil {
|
||
e.logger.Error(
|
||
"failed to place app shard",
|
||
zap.Error(err),
|
||
)
|
||
txn.Abort()
|
||
return nil
|
||
}
|
||
}
|
||
|
||
// Compute frame ID and store the full frame
|
||
frameIDBI, _ := poseidon.HashBytes(genesisFrame.Header.Output)
|
||
frameID := frameIDBI.FillBytes(make([]byte, 32))
|
||
e.frameStoreMu.Lock()
|
||
e.frameStore[string(frameID)] = genesisFrame
|
||
e.frameStoreMu.Unlock()
|
||
|
||
// Add to time reel
|
||
if err := e.globalTimeReel.Insert(e.ctx, genesisFrame); err != nil {
|
||
e.logger.Error("failed to add genesis frame to time reel", zap.Error(err))
|
||
// Clean up on error
|
||
e.frameStoreMu.Lock()
|
||
delete(e.frameStore, string(frameID))
|
||
e.frameStoreMu.Unlock()
|
||
}
|
||
|
||
e.proverRegistry.Refresh()
|
||
|
||
e.logger.Info("initialized genesis frame for global consensus")
|
||
return genesisFrame
|
||
}
|
||
|
||
// createStubGenesis creates a stub genesis frame for non-mainnet networks
|
||
func (e *GlobalConsensusEngine) createStubGenesis() *protobufs.GlobalFrame {
|
||
e.logger.Warn("CREATING STUB GENESIS FOR TEST NETWORK")
|
||
// Create a stub genesis frame
|
||
genesisHeader := &protobufs.GlobalFrameHeader{
|
||
FrameNumber: 0,
|
||
ParentSelector: make([]byte, 32),
|
||
Timestamp: time.Now().UnixMilli(),
|
||
Difficulty: e.config.Engine.Difficulty,
|
||
GlobalCommitments: make([][]byte, 256),
|
||
ProverTreeCommitment: make([]byte, 64),
|
||
Output: make([]byte, 516),
|
||
}
|
||
|
||
// Initialize all commitments with empty values first
|
||
for i := range 256 {
|
||
genesisHeader.GlobalCommitments[i] = make([]byte, 64)
|
||
}
|
||
|
||
commitments := make([]*tries.VectorCommitmentTree, 256)
|
||
for i := range 256 {
|
||
commitments[i] = &tries.VectorCommitmentTree{}
|
||
}
|
||
|
||
var proverPubKeys [][]byte
|
||
var err error
|
||
if e.config.P2P.Network != 99 && e.config.Engine != nil &&
|
||
e.config.Engine.GenesisSeed != "" {
|
||
proverPubKeyBytes, err := hex.DecodeString(e.config.Engine.GenesisSeed)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
if len(proverPubKeyBytes)%585 != 0 {
|
||
panic("invalid genesis seed for testnet seeding")
|
||
}
|
||
for i := 0; i < len(proverPubKeyBytes)/585; i++ {
|
||
proverPubKeys = append(proverPubKeys, proverPubKeyBytes[i*585:(i+1)*585])
|
||
}
|
||
} else {
|
||
proverKey, err := e.keyManager.GetSigningKey("q-prover-key")
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to obtain prover bls48-581 key value",
|
||
zap.Error(err),
|
||
)
|
||
return nil
|
||
}
|
||
proverPubKeys = [][]byte{proverKey.Public().([]byte)}
|
||
}
|
||
|
||
state := hgstate.NewHypergraphState(e.hypergraph)
|
||
|
||
rdfMultiprover := schema.NewRDFMultiprover(
|
||
&schema.TurtleRDFParser{},
|
||
e.inclusionProver,
|
||
)
|
||
|
||
for _, prover := range proverPubKeys {
|
||
addrbi, err := poseidon.HashBytes(prover)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
|
||
// Create ProverReward entry in QUIL token address with 10000 balance
|
||
rewardTree := &tries.VectorCommitmentTree{}
|
||
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
token.QUIL_TOKEN_ADDRESS,
|
||
"reward:ProverReward",
|
||
"DelegateAddress",
|
||
addrbi.FillBytes(make([]byte, 32)),
|
||
rewardTree,
|
||
)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
|
||
// Set 10000 balance
|
||
balance := make([]byte, 32)
|
||
balanceBI := big.NewInt(10000 * 8000000000)
|
||
balance = balanceBI.FillBytes(balance)
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
token.QUIL_TOKEN_ADDRESS,
|
||
"reward:ProverReward",
|
||
"Balance",
|
||
balance,
|
||
rewardTree,
|
||
)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
|
||
// Create reward vertex in QUIL token address
|
||
rewardVertex := state.NewVertexAddMaterializedState(
|
||
[32]byte(token.QUIL_TOKEN_ADDRESS),
|
||
[32]byte(addrbi.FillBytes(make([]byte, 32))),
|
||
0,
|
||
nil,
|
||
rewardTree,
|
||
)
|
||
|
||
err = state.Set(
|
||
token.QUIL_TOKEN_ADDRESS,
|
||
addrbi.FillBytes(make([]byte, 32)),
|
||
hgstate.VertexAddsDiscriminator,
|
||
0,
|
||
rewardVertex,
|
||
)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
}
|
||
|
||
if err := state.Commit(); err != nil {
|
||
e.logger.Error("failed to commit", zap.Error(err))
|
||
return nil
|
||
}
|
||
|
||
roots := e.hypergraph.Commit()
|
||
|
||
// Parse and set initial commitments from JSON
|
||
for shardKey, commits := range roots {
|
||
for i := 0; i < 3; i++ {
|
||
commitments[shardKey.L1[i]].Insert(
|
||
shardKey.L2[:],
|
||
commits[0],
|
||
nil,
|
||
big.NewInt(int64(len(commits[0]))),
|
||
)
|
||
commitments[shardKey.L1[i]].Commit(e.inclusionProver, false)
|
||
}
|
||
}
|
||
state = hgstate.NewHypergraphState(e.hypergraph)
|
||
|
||
for _, pubkey := range proverPubKeys {
|
||
err = e.addGenesisProver(rdfMultiprover, state, pubkey, 0, 0)
|
||
if err != nil {
|
||
e.logger.Error("error adding prover", zap.Error(err))
|
||
return nil
|
||
}
|
||
}
|
||
|
||
err = state.Commit()
|
||
if err != nil {
|
||
e.logger.Error("failed to commit", zap.Error(err))
|
||
return nil
|
||
}
|
||
|
||
roots = e.hypergraph.Commit()
|
||
proverRoots := roots[tries.ShardKey{
|
||
L1: [3]byte{},
|
||
L2: intrinsics.GLOBAL_INTRINSIC_ADDRESS,
|
||
}]
|
||
|
||
proverRoot := proverRoots[0]
|
||
|
||
genesisHeader.ProverTreeCommitment = proverRoot
|
||
|
||
for i := 0; i < 256; i++ {
|
||
genesisHeader.GlobalCommitments[i] = commitments[i].Commit(
|
||
e.inclusionProver,
|
||
false,
|
||
)
|
||
}
|
||
|
||
// Establish an empty signature payload – this avoids panics on broken
|
||
// header readers
|
||
genesisHeader.PublicKeySignatureBls48581 =
|
||
&protobufs.BLS48581AggregateSignature{
|
||
Signature: make([]byte, 0),
|
||
PublicKey: &protobufs.BLS48581G2PublicKey{
|
||
KeyValue: make([]byte, 0),
|
||
},
|
||
Bitmask: make([]byte, 0),
|
||
}
|
||
|
||
genesisFrame := &protobufs.GlobalFrame{
|
||
Header: genesisHeader,
|
||
}
|
||
|
||
// Compute frame ID and store the full frame
|
||
frameIDBI, _ := poseidon.HashBytes(genesisHeader.Output)
|
||
frameID := frameIDBI.FillBytes(make([]byte, 32))
|
||
e.frameStoreMu.Lock()
|
||
e.frameStore[string(frameID)] = genesisFrame
|
||
e.frameStoreMu.Unlock()
|
||
|
||
// Add to time reel
|
||
if err := e.globalTimeReel.Insert(e.ctx, genesisFrame); err != nil {
|
||
e.logger.Error("failed to add genesis frame to time reel", zap.Error(err))
|
||
// Clean up on error
|
||
e.frameStoreMu.Lock()
|
||
delete(e.frameStore, string(frameID))
|
||
e.frameStoreMu.Unlock()
|
||
}
|
||
|
||
return genesisFrame
|
||
}
|
||
|
||
func (e *GlobalConsensusEngine) establishMainnetGenesisProvers(
|
||
state *hgstate.HypergraphState,
|
||
genesisData GenesisJson,
|
||
) error {
|
||
rdfMultiprover := schema.NewRDFMultiprover(
|
||
&schema.TurtleRDFParser{},
|
||
e.inclusionProver,
|
||
)
|
||
|
||
// old to peer id, get seniority
|
||
beaconEd448Key, err := base64.StdEncoding.DecodeString(
|
||
genesisData.BeaconEd448Key,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to decode beacon ed448 key value",
|
||
zap.String("value", genesisData.BeaconEd448Key),
|
||
zap.Error(err),
|
||
)
|
||
return err
|
||
}
|
||
|
||
pk, err := pcrypto.UnmarshalEd448PublicKey(beaconEd448Key)
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to unmarshal beacon ed448 key value",
|
||
zap.String("value", genesisData.BeaconEd448Key),
|
||
zap.Error(err),
|
||
)
|
||
return err
|
||
}
|
||
|
||
peerId, err := peer.IDFromPublicKey(pk)
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to construct peer id from ed448 key value",
|
||
zap.String("value", genesisData.BeaconEd448Key),
|
||
zap.Error(err),
|
||
)
|
||
return err
|
||
}
|
||
|
||
seniority := compat.GetAggregatedSeniority([]string{peerId.String()})
|
||
e.logger.Debug(
|
||
"establishing seniority for beacon from aggregated records",
|
||
zap.String("seniority", seniority.String()),
|
||
)
|
||
|
||
publicKey, err := base64.StdEncoding.DecodeString(
|
||
genesisData.BeaconBLS48581Key,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error(
|
||
"failed to decode beacon bls48-581 key value",
|
||
zap.String("value", genesisData.BeaconBLS48581Key),
|
||
zap.Error(err),
|
||
)
|
||
return err
|
||
}
|
||
|
||
if err := e.addGenesisProver(
|
||
rdfMultiprover,
|
||
state,
|
||
publicKey,
|
||
seniority.Uint64(),
|
||
genesisData.FrameNumber,
|
||
); err != nil {
|
||
return err
|
||
}
|
||
|
||
for peerid, pubkeyhex := range genesisData.ArchivePeers {
|
||
_, err := base58.Decode(peerid)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
pubkey, err := hex.DecodeString(pubkeyhex)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
if err := e.addGenesisProver(
|
||
rdfMultiprover,
|
||
state,
|
||
pubkey,
|
||
seniority.Uint64(),
|
||
genesisData.FrameNumber,
|
||
); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (e *GlobalConsensusEngine) addGenesisProver(
|
||
rdfMultiprover *schema.RDFMultiprover,
|
||
state *hgstate.HypergraphState,
|
||
pubkey []byte,
|
||
seniority uint64,
|
||
frameNumber uint64,
|
||
) error {
|
||
proverAddressBI, err := poseidon.HashBytes(pubkey)
|
||
if err != nil || proverAddressBI == nil {
|
||
e.logger.Error(
|
||
"failed to calculate address value",
|
||
zap.String("value", hex.EncodeToString(pubkey)),
|
||
zap.Error(err),
|
||
)
|
||
return err
|
||
}
|
||
proverAddress := proverAddressBI.FillBytes(make([]byte, 32))
|
||
|
||
// Full address for the prover entry
|
||
proverFullAddress := [64]byte{}
|
||
copy(proverFullAddress[:32], intrinsics.GLOBAL_INTRINSIC_ADDRESS[:])
|
||
copy(proverFullAddress[32:], proverAddress)
|
||
|
||
// Create new prover entry
|
||
proverTree := &tries.VectorCommitmentTree{}
|
||
// Store the public key
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"prover:Prover",
|
||
"PublicKey",
|
||
pubkey,
|
||
proverTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set rdf value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Store status
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"prover:Prover",
|
||
"Status",
|
||
[]byte{1},
|
||
proverTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set rdf value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Store available storage (initially 0)
|
||
availableStorageBytes := make([]byte, 8)
|
||
binary.BigEndian.PutUint64(availableStorageBytes, 0)
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"prover:Prover",
|
||
"AvailableStorage",
|
||
availableStorageBytes,
|
||
proverTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set rdf value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Store seniority
|
||
seniorityBytes := make([]byte, 8)
|
||
binary.BigEndian.PutUint64(seniorityBytes, seniority)
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"prover:Prover",
|
||
"Seniority",
|
||
seniorityBytes,
|
||
proverTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set rdf value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Create prover vertex
|
||
proverVertex := state.NewVertexAddMaterializedState(
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS,
|
||
[32]byte(proverAddress),
|
||
frameNumber,
|
||
nil,
|
||
proverTree,
|
||
)
|
||
|
||
err = state.Set(
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
proverAddress,
|
||
hgstate.VertexAddsDiscriminator,
|
||
frameNumber,
|
||
proverVertex,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Create hyperedge for this prover
|
||
hyperedgeAddress := [32]byte(proverAddress)
|
||
hyperedge := hgcrdt.NewHyperedge(
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS,
|
||
hyperedgeAddress,
|
||
)
|
||
|
||
// Create ProverAllocation entry for global
|
||
|
||
// Calculate allocation address: poseidon.Hash(publicKey || filter)
|
||
allocationAddressBI, err := poseidon.HashBytes(
|
||
slices.Concat([]byte("PROVER_ALLOCATION"), pubkey, nil),
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to calculate allocation address", zap.Error(err))
|
||
return err
|
||
}
|
||
allocationAddress := allocationAddressBI.FillBytes(make([]byte, 32))
|
||
|
||
// Create allocation tree
|
||
allocationTree := &tries.VectorCommitmentTree{}
|
||
|
||
// Store prover reference (using the prover vertex)
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"allocation:ProverAllocation",
|
||
"Prover",
|
||
proverAddress,
|
||
allocationTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Store allocation status
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"allocation:ProverAllocation",
|
||
"Status",
|
||
[]byte{1},
|
||
allocationTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Store confirmation filter
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"allocation:ProverAllocation",
|
||
"ConfirmationFilter",
|
||
nil,
|
||
allocationTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Store join frame number
|
||
frameNumberBytes := make([]byte, 8)
|
||
binary.BigEndian.PutUint64(frameNumberBytes, 0)
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"allocation:ProverAllocation",
|
||
"JoinFrameNumber",
|
||
frameNumberBytes,
|
||
allocationTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Store join confirm frame number
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"allocation:ProverAllocation",
|
||
"JoinConfirmFrameNumber",
|
||
frameNumberBytes,
|
||
allocationTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Store last active frame number
|
||
lastActiveFrameNumberBytes := make([]byte, 8)
|
||
binary.BigEndian.PutUint64(lastActiveFrameNumberBytes, frameNumber)
|
||
err = rdfMultiprover.Set(
|
||
globalintrinsics.GLOBAL_RDF_SCHEMA,
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
"allocation:ProverAllocation",
|
||
"LastActiveFrameNumber",
|
||
lastActiveFrameNumberBytes,
|
||
allocationTree,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Create allocation vertex
|
||
allocationVertex := state.NewVertexAddMaterializedState(
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS,
|
||
[32]byte(allocationAddress),
|
||
frameNumber,
|
||
nil,
|
||
allocationTree,
|
||
)
|
||
|
||
err = state.Set(
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
allocationAddress,
|
||
hgstate.VertexAddsDiscriminator,
|
||
frameNumber,
|
||
allocationVertex,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
// Add allocation vertex to hyperedge
|
||
allocationAtom := hgcrdt.NewVertex(
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS,
|
||
[32]byte(allocationAddress),
|
||
allocationTree.Commit(e.inclusionProver, false),
|
||
allocationTree.GetSize(),
|
||
)
|
||
hyperedge.AddExtrinsic(allocationAtom)
|
||
|
||
// Update hyperedge
|
||
hyperedgeState := state.NewHyperedgeAddMaterializedState(
|
||
frameNumber,
|
||
nil,
|
||
hyperedge,
|
||
)
|
||
err = state.Set(
|
||
intrinsics.GLOBAL_INTRINSIC_ADDRESS[:],
|
||
hyperedgeAddress[:],
|
||
hgstate.HyperedgeAddsDiscriminator,
|
||
frameNumber,
|
||
hyperedgeState,
|
||
)
|
||
if err != nil {
|
||
e.logger.Error("failed to set state value", zap.Error(err))
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|