From 7615d712daa78975c20190cc696d3860d99f16c6 Mon Sep 17 00:00:00 2001 From: LINCKODE Date: Mon, 9 Sep 2024 16:50:00 +0300 Subject: [PATCH] Implement suggested fixes. --- .github/workflows/push-compression.yaml | 25 ---- README.md | 6 +- db-migration.md | 7 + main.go | 64 +++------ processor/processor.go | 6 +- rpc/rpc_server.go | 63 ++++++++- rpc/v2_endpoints.go | 176 ------------------------ validator/quorum/models.go | 84 +++++++++++ validator/quorum/validator.go | 12 +- validator/validator.go | 4 +- 10 files changed, 176 insertions(+), 271 deletions(-) delete mode 100644 .github/workflows/push-compression.yaml create mode 100644 db-migration.md diff --git a/.github/workflows/push-compression.yaml b/.github/workflows/push-compression.yaml deleted file mode 100644 index df3e236..0000000 --- a/.github/workflows/push-compression.yaml +++ /dev/null @@ -1,25 +0,0 @@ -name: Deploy dev images to GHCR - -on: - push: - branches: - - 'compression' - -jobs: - push-store-image: - runs-on: ubuntu-latest - steps: - - name: 'Checkout GitHub Action' - uses: actions/checkout@main - - - name: 'Login to GitHub Container Registry' - uses: docker/login-action@v1 - with: - registry: ghcr.io - username: ${{github.actor}} - password: ${{secrets.GITHUB_TOKEN}} - - - name: 'Build Inventory Image' - run: | - docker build . --tag ghcr.io/qubic/qubic-archiver:${{github.ref_name}} - docker push ghcr.io/qubic/qubic-archiver:${{github.ref_name}} \ No newline at end of file diff --git a/README.md b/README.md index 0bf65d3..c099422 100644 --- a/README.md +++ b/README.md @@ -11,10 +11,10 @@ The archive system consists of two services: ## IMPORTANT > [!WARNING] -> This version of archiver is **INCOMPATIBLE** by default with versions **v0.x.x**, as it features database compression and a different format for quorum data. -> If you wish to enable backwards compatibility, please set `STORE_COMPRESSION_TYPE` to `Snappy` and `STORE_SAVE_FULL_QUORUM_DATA` to `true`. +> This version of archiver is **INCOMPATIBLE** with versions **v0.x.x**, as it features database compression and a different format for quorum data. > Archiver **DOES NOT** migrate the database to the new format by itself, and **MAY BREAK** your existing information, if not migrated correctly. > For a migration tool, please see the [Archiver DB Migrator](https://github.com/qubic/archiver-db-migrator), and make sure to back up your data! +> See [this](db-migration.md) for how to migrate the database to the new format. Before starting the system, open the `docker-compose.yml` file and make sure that you have a reliable peer list setup for the `qubic-nodes` service. @@ -41,8 +41,6 @@ This can be configured using the `QUBIC_NODES_QUBIC_PEER_LIST` environment varia $QUBIC_ARCHIVER_QUBIC_NODE_PORT (default: 21841) $QUBIC_ARCHIVER_QUBIC_STORAGE_FOLDER (default: store) $QUBIC_ARCHIVER_QUBIC_PROCESS_TICK_TIMEOUT (default: 5s) - $QUBIC_ARCHIVER_STORE_COMPRESSION_TYPE (default: Zstd) - $QUBIC_ARCHIVER_STORE_SAVE_FULL_VOTE_DATA (default: false) ``` ## Run with docker-compose: diff --git a/db-migration.md b/db-migration.md new file mode 100644 index 0000000..275337e --- /dev/null +++ b/db-migration.md @@ -0,0 +1,7 @@ +# Process of migrating an Archiver instance: + +1. Stop archiver. +2. Run the [archiver-db-migrator](https://github.com/qubic/archiver-db-migrator) tool, specifying the path of the old database, and the path of where to store the new database directory. Wait for the process to stop. +3. Rename the old database directory to something else, and the new directory to the old name, thus we don't need to modify the archiver configuration. +4. Update the archiver version in the docker compose file. +5. Start archiver. \ No newline at end of file diff --git a/main.go b/main.go index 6f9ac04..2ca5467 100644 --- a/main.go +++ b/main.go @@ -50,9 +50,7 @@ func run() error { ProcessTickTimeout time.Duration `conf:"default:5s"` } Store struct { - ResetEmptyTickKeys bool `conf:"default:false"` - CompressionType string `conf:"default:Zstd"` - SaveFullQuorumData bool `conf:"default:false"` + ResetEmptyTickKeys bool `conf:"default:false"` } } @@ -82,9 +80,24 @@ func run() error { } log.Printf("main: Config :\n%v\n", out) - db, err := openDB(cfg.Qubic.StorageFolder, cfg.Store.CompressionType) + levelOptions := pebble.LevelOptions{ + BlockRestartInterval: 16, + BlockSize: 4096, + BlockSizeThreshold: 90, + Compression: pebble.ZstdCompression, + FilterPolicy: nil, + FilterType: pebble.TableFilter, + IndexBlockSize: 4096, + TargetFileSize: 2097152, + } + + pebbleOptions := pebble.Options{ + Levels: []pebble.LevelOptions{levelOptions}, + } + + db, err := pebble.Open(cfg.Qubic.StorageFolder, &pebbleOptions) if err != nil { - return errors.Wrap(err, "opening db") + return errors.Wrap(err, "opening db with zstd compression") } defer db.Close() @@ -125,7 +138,7 @@ func run() error { shutdown := make(chan os.Signal, 1) signal.Notify(shutdown, os.Interrupt, syscall.SIGTERM) - proc := processor.NewProcessor(p, ps, cfg.Qubic.ProcessTickTimeout, cfg.Store.SaveFullQuorumData) + proc := processor.NewProcessor(p, ps, cfg.Qubic.ProcessTickTimeout) procErrors := make(chan error, 1) // Start the service listening for requests. @@ -142,42 +155,3 @@ func run() error { } } } - -func openDB(path string, compressionType string) (*pebble.DB, error) { - switch compressionType { - case "Zstd": - return createDBWithZstdCompression(path) - case "Snappy": - db, err := pebble.Open(path, &pebble.Options{}) - if err != nil { - return nil, errors.Wrap(err, "opening db with snappy compression") - } - return db, nil - } - return nil, errors.New("unknown compression type") -} - -func createDBWithZstdCompression(path string) (*pebble.DB, error) { - - levelOptions := pebble.LevelOptions{ - BlockRestartInterval: 16, - BlockSize: 4096, - BlockSizeThreshold: 90, - Compression: pebble.ZstdCompression, - FilterPolicy: nil, - FilterType: pebble.TableFilter, - IndexBlockSize: 4096, - TargetFileSize: 2097152, - } - - pebbleOptions := pebble.Options{ - Levels: []pebble.LevelOptions{levelOptions}, - } - - db, err := pebble.Open(path, &pebbleOptions) - if err != nil { - return nil, errors.Wrap(err, "opening db with zstd compression") - } - - return db, nil -} diff --git a/processor/processor.go b/processor/processor.go index ec6ba4e..fbd589f 100644 --- a/processor/processor.go +++ b/processor/processor.go @@ -29,15 +29,13 @@ type Processor struct { pool *qubic.Pool ps *store.PebbleStore processTickTimeout time.Duration - storeFullVoteData bool } -func NewProcessor(p *qubic.Pool, ps *store.PebbleStore, processTickTimeout time.Duration, storeFullVoteData bool) *Processor { +func NewProcessor(p *qubic.Pool, ps *store.PebbleStore, processTickTimeout time.Duration) *Processor { return &Processor{ pool: p, ps: ps, processTickTimeout: processTickTimeout, - storeFullVoteData: storeFullVoteData, } } @@ -98,7 +96,7 @@ func (p *Processor) processOneByOne() error { } val := validator.New(client, p.ps) - err = val.ValidateTick(ctx, tickInfo.InitialTick, nextTick.TickNumber, p.storeFullVoteData) + err = val.ValidateTick(ctx, tickInfo.InitialTick, nextTick.TickNumber) if err != nil { return errors.Wrapf(err, "validating tick %d", nextTick.TickNumber) } diff --git a/rpc/rpc_server.go b/rpc/rpc_server.go index c6ad93e..ef4c5b3 100644 --- a/rpc/rpc_server.go +++ b/rpc/rpc_server.go @@ -8,6 +8,7 @@ import ( "github.com/pkg/errors" "github.com/qubic/go-archiver/protobuff" "github.com/qubic/go-archiver/store" + "github.com/qubic/go-archiver/validator/quorum" qubic "github.com/qubic/go-node-connector" "github.com/qubic/go-node-connector/types" "google.golang.org/grpc" @@ -242,15 +243,69 @@ func (s *Server) GetQuorumTickData(ctx context.Context, req *protobuff.GetQuorum return nil, st.Err() } - qtd, err := s.store.GetQuorumTickData(ctx, req.TickNumber) + if req.TickNumber == lastProcessedTick.TickNumber { + tickData, err := s.store.GetQuorumTickDataV2(ctx, req.TickNumber) + if err != nil { + if errors.Is(err, store.ErrNotFound) { + return nil, status.Errorf(codes.NotFound, "quorum tick data not found") + } + return nil, status.Errorf(codes.Internal, "getting quorum tick data: %v", err) + } + + res := protobuff.GetQuorumTickDataResponse{ + QuorumTickData: &protobuff.QuorumTickData{ + QuorumTickStructure: tickData.QuorumTickStructure, + QuorumDiffPerComputor: make(map[uint32]*protobuff.QuorumDiff), + }, + } + + for id, diff := range tickData.QuorumDiffPerComputor { + res.QuorumTickData.QuorumDiffPerComputor[id] = &protobuff.QuorumDiff{ + ExpectedNextTickTxDigestHex: diff.ExpectedNextTickTxDigestHex, + SignatureHex: diff.SignatureHex, + } + } + + return &res, nil + } + + nextTick := req.TickNumber + 1 + + //Get quorum data for next tick + nextTickQuorumData, err := s.store.GetQuorumTickDataV2(ctx, nextTick) if err != nil { if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.NotFound, "quorum tick data not found") + return nil, status.Errorf(codes.Internal, "quorum data for next tick was not found") } - return nil, status.Errorf(codes.Internal, "getting quorum tick data: %v", err) + return nil, status.Errorf(codes.Internal, "getting tick data: %v", err) + } + + //Get quorum data for current tick + currentTickQuorumData, err := s.store.GetQuorumTickDataV2(ctx, req.TickNumber) + if err != nil { + if errors.Is(err, store.ErrNotFound) { + return nil, status.Errorf(codes.Internal, "quorum data for tick was not found") + } + return nil, status.Errorf(codes.Internal, "getting tick data: %v", err) + } + + //Get computors + computors, err := s.store.GetComputors(ctx, currentTickQuorumData.QuorumTickStructure.Epoch) + if err != nil { + return nil, status.Errorf(codes.Internal, "getting computor list") + } + + reconstructedQuorumData, err := quorum.ReconstructQuorumData(currentTickQuorumData, nextTickQuorumData, computors) + if err != nil { + return nil, status.Errorf(codes.Internal, "reconstructing quorum data: %v", err) + } + + //Response object + res := protobuff.GetQuorumTickDataResponse{ + QuorumTickData: reconstructedQuorumData, } - return &protobuff.GetQuorumTickDataResponse{QuorumTickData: qtd}, nil + return &res, nil } func (s *Server) GetComputors(ctx context.Context, req *protobuff.GetComputorsRequest) (*protobuff.GetComputorsResponse, error) { computors, err := s.store.GetComputors(ctx, req.Epoch) diff --git a/rpc/v2_endpoints.go b/rpc/v2_endpoints.go index 3eb7e1d..1bf7542 100644 --- a/rpc/v2_endpoints.go +++ b/rpc/v2_endpoints.go @@ -4,7 +4,6 @@ import ( "cmp" "context" "encoding/hex" - "github.com/qubic/go-archiver/utils" "slices" "github.com/pkg/errors" @@ -381,178 +380,3 @@ func (s *Server) GetIdentityTransfersInTickRangeV2(ctx context.Context, req *pro }, nil } - -func (s *Server) GetQuorumTickDataV2(ctx context.Context, req *protobuff.GetQuorumTickDataRequest) (*protobuff.GetQuorumTickDataResponse, error) { - - lastProcessedTick, err := s.store.GetLastProcessedTick(ctx) - if err != nil { - return nil, status.Errorf(codes.Internal, "getting last processed tick: %v", err) - } - if req.TickNumber > lastProcessedTick.TickNumber { - st := status.Newf(codes.FailedPrecondition, "requested tick number %d is greater than last processed tick %d", req.TickNumber, lastProcessedTick.TickNumber) - st, err = st.WithDetails(&protobuff.LastProcessedTick{LastProcessedTick: lastProcessedTick.TickNumber}) - if err != nil { - return nil, status.Errorf(codes.Internal, "creating custom status") - } - - return nil, st.Err() - } - - processedTickIntervalsPerEpoch, err := s.store.GetProcessedTickIntervals(ctx) - if err != nil { - return nil, status.Errorf(codes.Internal, "getting processed tick intervals per epoch") - } - - wasSkipped, nextAvailableTick := wasTickSkippedByArchive(req.TickNumber, processedTickIntervalsPerEpoch) - if wasSkipped == true { - st := status.Newf(codes.OutOfRange, "provided tick number %d was skipped by the system, next available tick is %d", req.TickNumber, nextAvailableTick) - st, err = st.WithDetails(&protobuff.NextAvailableTick{NextTickNumber: nextAvailableTick}) - if err != nil { - return nil, status.Errorf(codes.Internal, "creating custom status") - } - - return nil, st.Err() - } - - if req.TickNumber == lastProcessedTick.TickNumber { - - tickData, err := s.store.GetQuorumTickDataV2(ctx, req.TickNumber) - if err != nil { - if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.NotFound, "quorum tick data not found") - } - return nil, status.Errorf(codes.Internal, "getting quorum tick data: %v", err) - } - - res := protobuff.GetQuorumTickDataResponse{ - QuorumTickData: &protobuff.QuorumTickData{ - QuorumTickStructure: tickData.QuorumTickStructure, - QuorumDiffPerComputor: make(map[uint32]*protobuff.QuorumDiff), - }, - } - - for id, diff := range tickData.QuorumDiffPerComputor { - res.QuorumTickData.QuorumDiffPerComputor[id] = &protobuff.QuorumDiff{ - ExpectedNextTickTxDigestHex: diff.ExpectedNextTickTxDigestHex, - SignatureHex: diff.SignatureHex, - } - } - - return &res, nil - } - - nextTick := req.TickNumber + 1 - - //Check if next tick was skipped - //TODO: check if this is accurate behaviour (if the tick gets skipped, then the data should be in the next available tick) - skipped, nextAvailable := wasTickSkippedByArchive(nextTick, processedTickIntervalsPerEpoch) - if skipped { - nextTick = nextAvailable - } - - //Get quorum data for next tick - nextTickQuorumData, err := s.store.GetQuorumTickDataV2(ctx, nextTick) - if err != nil { - if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.Internal, "quorum data for next tick was not found") - } - return nil, status.Errorf(codes.Internal, "getting tick data: %v", err) - } - - //Get quorum data for current tick - currentTickQuorumData, err := s.store.GetQuorumTickDataV2(ctx, req.TickNumber) - if err != nil { - if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.Internal, "quorum data for tick was not found") - } - return nil, status.Errorf(codes.Internal, "getting tick data: %v", err) - } - - //Get computors - computors, err := s.store.GetComputors(ctx, currentTickQuorumData.QuorumTickStructure.Epoch) - if err != nil { - return nil, status.Errorf(codes.Internal, "getting computor list") - } - - //Response object - res := protobuff.GetQuorumTickDataResponse{ - QuorumTickData: &protobuff.QuorumTickData{ - QuorumTickStructure: currentTickQuorumData.QuorumTickStructure, - QuorumDiffPerComputor: make(map[uint32]*protobuff.QuorumDiff), - }, - } - - //Digests - spectrumDigest, err := hex.DecodeString(nextTickQuorumData.QuorumTickStructure.PrevSpectrumDigestHex) - if err != nil { - return nil, status.Errorf(codes.Internal, "obtaining spectrum digest from next tick quorum data") - } - universeDigest, err := hex.DecodeString(nextTickQuorumData.QuorumTickStructure.PrevUniverseDigestHex) - if err != nil { - return nil, status.Errorf(codes.Internal, "obtaining universe digest from next tick quorum data") - } - computerDigest, err := hex.DecodeString(nextTickQuorumData.QuorumTickStructure.PrevComputerDigestHex) - if err != nil { - return nil, status.Errorf(codes.Internal, "obtaining computer digest from next tick quorum data") - } - resourceDigest, err := hex.DecodeString(nextTickQuorumData.QuorumTickStructure.PrevResourceTestingDigestHex) - if err != nil { - return nil, status.Errorf(codes.Internal, "obtaining resource testing digest from next tick quorum data") - } - - //Loop over all computors in current tick data - for id, voteDiff := range currentTickQuorumData.QuorumDiffPerComputor { - - identity := types.Identity(computors.Identities[id]) - - computorPublicKey, err := identity.ToPubKey(false) - if err != nil { - return nil, status.Errorf(codes.Internal, "obtaining public key for computor id: %d", id) - } - - var tmp [64]byte - copy(tmp[:32], computorPublicKey[:]) // Public key as the first part - - //Salted spectrum digest - copy(tmp[32:], spectrumDigest[:]) - saltedSpectrumDigest, err := utils.K12Hash(tmp[:]) - if err != nil { - return nil, status.Errorf(codes.Internal, "hashing salted spectrum digest") - } - - //Salted universe digest - copy(tmp[32:], universeDigest[:]) - saltedUniverseDigest, err := utils.K12Hash(tmp[:]) - if err != nil { - return nil, status.Errorf(codes.Internal, "hashing salted universe digest") - } - - //Salted computer digest - copy(tmp[32:], computerDigest[:]) - saltedComputerDigest, err := utils.K12Hash(tmp[:]) - if err != nil { - return nil, status.Errorf(codes.Internal, "hashing salted computer digest") - } - - //Salted resource digest - var tmp2 [40]byte - copy(tmp2[:32], computorPublicKey[:]) // Public key as the first part - copy(tmp2[32:], resourceDigest[:]) - saltedResourceTestingDigest, err := utils.K12Hash(tmp2[:]) - if err != nil { - return nil, status.Errorf(codes.Internal, "hashing salted resource testing digest") - } - - //Add reconstructed object to response - res.QuorumTickData.QuorumDiffPerComputor[id] = &protobuff.QuorumDiff{ - SaltedResourceTestingDigestHex: hex.EncodeToString(saltedResourceTestingDigest[:8]), - SaltedSpectrumDigestHex: hex.EncodeToString(saltedSpectrumDigest[:]), - SaltedUniverseDigestHex: hex.EncodeToString(saltedUniverseDigest[:]), - SaltedComputerDigestHex: hex.EncodeToString(saltedComputerDigest[:]), - ExpectedNextTickTxDigestHex: voteDiff.ExpectedNextTickTxDigestHex, - SignatureHex: voteDiff.SignatureHex, - } - } - - return &res, nil -} diff --git a/validator/quorum/models.go b/validator/quorum/models.go index 53e5f7d..bfd3bd2 100644 --- a/validator/quorum/models.go +++ b/validator/quorum/models.go @@ -3,7 +3,9 @@ package quorum import ( "encoding/binary" "encoding/hex" + "github.com/pkg/errors" "github.com/qubic/go-archiver/protobuff" + "github.com/qubic/go-archiver/utils" "github.com/qubic/go-node-connector/types" "time" ) @@ -78,3 +80,85 @@ func qubicDiffToProtoV2(tickVote types.QuorumTickVote) *protobuff.QuorumDiffV2 { } return &protoQuorumDiff } + +func ReconstructQuorumData(currentTickQuorumData, nextTickQuorumData *protobuff.QuorumTickDataV2, computors *protobuff.Computors) (*protobuff.QuorumTickData, error) { + + reconstructedQuorumData := protobuff.QuorumTickData{ + QuorumTickStructure: currentTickQuorumData.QuorumTickStructure, + QuorumDiffPerComputor: make(map[uint32]*protobuff.QuorumDiff), + } + + //Digests + spectrumDigest, err := hex.DecodeString(nextTickQuorumData.QuorumTickStructure.PrevSpectrumDigestHex) + if err != nil { + return nil, errors.Wrap(err, "obtaining spectrum digest from next tick quorum data") + } + universeDigest, err := hex.DecodeString(nextTickQuorumData.QuorumTickStructure.PrevUniverseDigestHex) + if err != nil { + return nil, errors.Wrap(err, "obtaining universe digest from next tick quorum data") + } + computerDigest, err := hex.DecodeString(nextTickQuorumData.QuorumTickStructure.PrevComputerDigestHex) + if err != nil { + return nil, errors.Wrap(err, "obtaining computer digest from next tick quorum data") + } + resourceDigest, err := hex.DecodeString(nextTickQuorumData.QuorumTickStructure.PrevResourceTestingDigestHex) + if err != nil { + return nil, errors.Wrap(err, "obtaining resource testing digest from next tick quorum data") + } + + //Loop over all computors in current tick data + for id, voteDiff := range currentTickQuorumData.QuorumDiffPerComputor { + + identity := types.Identity(computors.Identities[id]) + + computorPublicKey, err := identity.ToPubKey(false) + if err != nil { + return nil, errors.Wrapf(err, "obtaining public key for computor id: %d", id) + } + + var tmp [64]byte + copy(tmp[:32], computorPublicKey[:]) // Public key as the first part + + //Salted spectrum digest + copy(tmp[32:], spectrumDigest[:]) + saltedSpectrumDigest, err := utils.K12Hash(tmp[:]) + if err != nil { + return nil, errors.Wrap(err, "hashing salted spectrum digest") + } + + //Salted universe digest + copy(tmp[32:], universeDigest[:]) + saltedUniverseDigest, err := utils.K12Hash(tmp[:]) + if err != nil { + return nil, errors.Wrap(err, "hashing salted universe digest") + } + + //Salted computer digest + copy(tmp[32:], computerDigest[:]) + saltedComputerDigest, err := utils.K12Hash(tmp[:]) + if err != nil { + return nil, errors.Wrap(err, "hashing salted computer digest") + } + + //Salted resource digest + var tmp2 [40]byte + copy(tmp2[:32], computorPublicKey[:]) // Public key as the first part + copy(tmp2[32:], resourceDigest[:]) + saltedResourceTestingDigest, err := utils.K12Hash(tmp2[:]) + if err != nil { + return nil, errors.Wrap(err, "hashing salted resource testing digest") + } + + //Add reconstructed object to response + reconstructedQuorumData.QuorumDiffPerComputor[id] = &protobuff.QuorumDiff{ + SaltedResourceTestingDigestHex: hex.EncodeToString(saltedResourceTestingDigest[:8]), + SaltedSpectrumDigestHex: hex.EncodeToString(saltedSpectrumDigest[:]), + SaltedUniverseDigestHex: hex.EncodeToString(saltedUniverseDigest[:]), + SaltedComputerDigestHex: hex.EncodeToString(saltedComputerDigest[:]), + ExpectedNextTickTxDigestHex: voteDiff.ExpectedNextTickTxDigestHex, + SignatureHex: voteDiff.SignatureHex, + } + } + + return &reconstructedQuorumData, nil +} diff --git a/validator/quorum/validator.go b/validator/quorum/validator.go index 8d0f3e8..83c57b4 100644 --- a/validator/quorum/validator.go +++ b/validator/quorum/validator.go @@ -155,17 +155,7 @@ func getDigestFromQuorumTickData(data types.QuorumTickVote) ([32]byte, error) { return digest, nil } -func Store(ctx context.Context, store *store.PebbleStore, tickNumber uint32, quorumVotes types.QuorumVotes, storeFullTickData bool) error { - - if !storeFullTickData { - protoModel := qubicToProto(quorumVotes) - - err := store.SetQuorumTickData(ctx, tickNumber, protoModel) - if err != nil { - return errors.Wrap(err, "set quorum votes") - } - } - +func Store(ctx context.Context, store *store.PebbleStore, tickNumber uint32, quorumVotes types.QuorumVotes) error { protoModel := qubicToProtoV2(quorumVotes) err := store.SetQuorumTickDataV2(ctx, tickNumber, protoModel) diff --git a/validator/validator.go b/validator/validator.go index c699c25..e3d84d0 100644 --- a/validator/validator.go +++ b/validator/validator.go @@ -37,7 +37,7 @@ func GoSchnorrqVerify(ctx context.Context, pubkey [32]byte, digest [32]byte, sig return schnorrq.Verify(pubkey, digest, sig) } -func (v *Validator) ValidateTick(ctx context.Context, initialEpochTick, tickNumber uint32, storeFullTickData bool) error { +func (v *Validator) ValidateTick(ctx context.Context, initialEpochTick, tickNumber uint32) error { quorumVotes, err := v.qu.GetQuorumVotes(ctx, tickNumber) if err != nil { return errors.Wrap(err, "getting quorum tick data") @@ -122,7 +122,7 @@ func (v *Validator) ValidateTick(ctx context.Context, initialEpochTick, tickNumb } // proceed to storing tick information - err = quorum.Store(ctx, v.store, tickNumber, alignedVotes, storeFullTickData) + err = quorum.Store(ctx, v.store, tickNumber, alignedVotes) if err != nil { return errors.Wrap(err, "storing quorum votes") }