From fe432e24ee6dbb059b6c1e99bd77812deca6d687 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Thu, 23 Jan 2025 17:50:34 -0500 Subject: [PATCH 01/41] init --- chain/errors.go | 2 + chain/processor.go | 6 +- chain/processor_test.go | 319 +++++++++++++++++++++++++++++++ chain/transaction_test.go | 5 +- internal/logging/noop.go | 45 +++++ internal/workers/mock_workers.go | 35 ++++ 6 files changed, 407 insertions(+), 5 deletions(-) create mode 100644 chain/processor_test.go create mode 100644 internal/logging/noop.go create mode 100644 internal/workers/mock_workers.go diff --git a/chain/errors.go b/chain/errors.go index 697235626a..4e7ef9bb47 100644 --- a/chain/errors.go +++ b/chain/errors.go @@ -61,6 +61,8 @@ var ( ErrFailedToFetchParentHeight = errors.New("failed to fetch height from state") ErrFailedToFetchParentTimestamp = errors.New("failed to fetch timestamp from state") ErrFailedToFetchParentFee = errors.New("failed to fetch fee manager from state") + ErrFailedToParseParentHeight = errors.New("failed to parse height") + ErrFailedToParseParentTimestamp = errors.New("failed to parse timestamp") // Misc ErrNotImplemented = errors.New("not implemented") diff --git a/chain/processor.go b/chain/processor.go index aa8d2103d0..d049633d46 100644 --- a/chain/processor.go +++ b/chain/processor.go @@ -383,7 +383,7 @@ func (p *Processor) createBlockContext( } parentHeight, err := database.ParseUInt64(parentHeightRaw) if err != nil { - return blockContext{}, fmt.Errorf("failed to parse parent height from state: %w", err) + return blockContext{}, fmt.Errorf("%w %w", ErrFailedToParseParentHeight, err) } if block.Hght != parentHeight+1 { return blockContext{}, fmt.Errorf("%w: block height %d != parentHeight (%d) + 1", ErrInvalidBlockHeight, block.Hght, parentHeight) @@ -393,11 +393,11 @@ func (p *Processor) createBlockContext( timestampKey := TimestampKey(p.metadataManager.TimestampPrefix()) parentTimestampRaw, err := im.GetValue(ctx, timestampKey) if err != nil { - return blockContext{}, fmt.Errorf("%w: %w", ErrFailedToFetchParentHeight, err) + return blockContext{}, fmt.Errorf("%w: %w", ErrFailedToFetchParentTimestamp, err) } parsedParentTimestamp, err := database.ParseUInt64(parentTimestampRaw) if err != nil { - return blockContext{}, fmt.Errorf("failed to parse timestamp from state: %w", err) + return blockContext{}, fmt.Errorf("%w: %w", ErrFailedToParseParentTimestamp, err) } // Confirm block timestamp is valid diff --git a/chain/processor_test.go b/chain/processor_test.go new file mode 100644 index 0000000000..2e113faed1 --- /dev/null +++ b/chain/processor_test.go @@ -0,0 +1,319 @@ +// Copyright (C) 2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package chain_test + +import ( + "context" + "encoding/binary" + "errors" + "testing" + "time" + + "github.com/ava-labs/avalanchego/database/memdb" + "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/trace" + "github.com/ava-labs/avalanchego/x/merkledb" + "github.com/prometheus/client_golang/prometheus" + "github.com/stretchr/testify/require" + + "github.com/ava-labs/hypersdk/chain" + "github.com/ava-labs/hypersdk/genesis" + "github.com/ava-labs/hypersdk/internal/logging" + "github.com/ava-labs/hypersdk/internal/validitywindow" + "github.com/ava-labs/hypersdk/internal/validitywindow/validitywindowtest" + "github.com/ava-labs/hypersdk/internal/workers" + "github.com/ava-labs/hypersdk/state" + "github.com/ava-labs/hypersdk/state/metadata" +) + +var ( + heightKey = string(chain.HeightKey([]byte{0})) + timestampKey = string(chain.TimestampKey([]byte{1})) + + errMockWorker = errors.New("mock worker error") + errMockWorkerJob = errors.New("mock worker job error") + errMockVerifyExpiryReplayProtection = errors.New("mock validity window error") +) + +func TestProcessorExecute(t *testing.T) { + testRules := genesis.NewDefaultRules() + testRuleFactory := genesis.ImmutableRuleFactory{Rules: testRules} + invalidStateRoot := ids.ID{1} + validBlock := &chain.ExecutionBlock{ + StatelessBlock: &chain.StatelessBlock{ + Hght: 1, + Tmstmp: testRules.GetMinEmptyBlockGap(), + }, + } + + // TODO: make sure to add a valid transaction to all applicable tests! + tests := []struct { + name string + block *chain.ExecutionBlock + validityWindow chain.ValidityWindow + includeRoot bool + isNormalOp bool + state map[string][]byte + workers workers.Workers + expectedErr error + }{ + { + name: "valid test case", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }, + block: validBlock, + includeRoot: true, + }, + { + name: "block timestamp too late", + block: &chain.ExecutionBlock{ + StatelessBlock: &chain.StatelessBlock{ + Tmstmp: time.Now().Add(chain.FutureBound).UnixMilli() + int64(time.Second), + }, + }, + expectedErr: chain.ErrTimestampTooLate, + }, + { + name: "verify signatures fails", + block: validBlock, + workers: &workers.MockWorkers{ + OnNewJob: func(_ int) (workers.Job, error) { + return nil, errMockWorker + }, + }, + expectedErr: errMockWorker, + }, + { + name: "failed to get parent height", + block: validBlock, + expectedErr: chain.ErrFailedToFetchParentHeight, + }, + { + name: "failed to parse parent height", + state: map[string][]byte{ + heightKey: {}, + }, + block: validBlock, + expectedErr: chain.ErrFailedToParseParentHeight, + }, + { + name: "block height is not one more than parent height (2 != 0 + 1)", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + }, + block: &chain.ExecutionBlock{ + StatelessBlock: &chain.StatelessBlock{ + Hght: 2, + }, + }, + expectedErr: chain.ErrInvalidBlockHeight, + }, + { + name: "failed to get timestamp", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + }, + block: validBlock, + expectedErr: chain.ErrFailedToFetchParentTimestamp, + }, + { + name: "failed to parse timestamp", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: {}, + }, + block: validBlock, + expectedErr: chain.ErrFailedToParseParentTimestamp, + }, + { + name: "non-empty block timestamp less than parent timestamp with gap", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + }, + block: &chain.ExecutionBlock{ + StatelessBlock: &chain.StatelessBlock{ + Hght: 1, + Txs: []*chain.Transaction{ + { + TransactionData: chain.TransactionData{ + Base: &chain.Base{}, + }, + Auth: &mockAuth{ + typeID: 1, + }, + }, + }, + }, + }, + expectedErr: chain.ErrTimestampTooEarly, + }, + { + name: "empty block timestamp less than parent timestamp with gap", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + }, + block: &chain.ExecutionBlock{ + StatelessBlock: &chain.StatelessBlock{ + Hght: 1, + }, + }, + expectedErr: chain.ErrTimestampTooEarly, + }, + { + name: "failed to get fee", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + }, + block: validBlock, + expectedErr: chain.ErrFailedToFetchParentFee, + }, + { + name: "failed VerifyExpiryReplayProtection", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }, + block: validBlock, + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{ + OnVerifyExpiryReplayProtection: func(_ context.Context, _ validitywindow.ExecutionBlock[*chain.Transaction]) error { + return errMockVerifyExpiryReplayProtection + }, + }, + isNormalOp: true, + expectedErr: errMockVerifyExpiryReplayProtection, + }, + { + name: "failed to execute txs", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }, + block: &chain.ExecutionBlock{ + StatelessBlock: &chain.StatelessBlock{ + Hght: 1, + Tmstmp: testRules.GetMinEmptyBlockGap(), + Txs: []*chain.Transaction{ + { + TransactionData: chain.TransactionData{ + Base: &chain.Base{}, + Actions: []chain.Action{ + &mockAction{ + stateKeys: state.Keys{ + "": state.None, + }, + }, + }, + }, + Auth: &mockAuth{ + typeID: 1, + }, + }, + }, + }, + }, + expectedErr: chain.ErrInvalidKeyValue, + }, + { + name: "state root mismatch", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }, + block: &chain.ExecutionBlock{ + StatelessBlock: &chain.StatelessBlock{ + Hght: 1, + Tmstmp: testRules.GetMinEmptyBlockGap(), + StateRoot: invalidStateRoot, + }, + }, + expectedErr: chain.ErrStateRootMismatch, + }, + { + name: "failed to verify signatures", + state: map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }, + block: validBlock, + workers: &workers.MockWorkers{ + OnNewJob: func(_ int) (workers.Job, error) { + return &workers.MockJob{ + OnWaitError: errMockWorkerJob, + }, nil + }, + }, + includeRoot: true, + expectedErr: errMockWorkerJob, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + r := require.New(t) + ctx := context.Background() + + if tt.workers == nil { + tt.workers = &workers.MockWorkers{ + OnNewJob: func(_ int) (workers.Job, error) { + return &workers.MockJob{}, nil + }, + } + } + + if tt.validityWindow == nil { + tt.validityWindow = &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{} + } + + testChain, err := chain.NewChain( + trace.Noop, + prometheus.NewRegistry(), + nil, + nil, + &logging.Noop{}, + &testRuleFactory, + metadata.NewDefaultManager(), + nil, + tt.workers, + nil, + tt.validityWindow, + chain.Config{}, + ) + r.NoError(err) + + db, err := merkledb.New( + ctx, + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + r.NoError(err) + + for k, v := range tt.state { + r.NoError(db.Put([]byte(k), v)) + } + r.NoError(db.CommitToDB(ctx)) + + if tt.includeRoot { + root, err := db.GetMerkleRoot(ctx) + r.NoError(err) + tt.block.StateRoot = root + } + + _, err = testChain.Execute(ctx, db, tt.block, tt.isNormalOp) + r.ErrorIs(err, tt.expectedErr) + }) + } +} diff --git a/chain/transaction_test.go b/chain/transaction_test.go index 45a45818e2..e4a17c8db3 100644 --- a/chain/transaction_test.go +++ b/chain/transaction_test.go @@ -125,6 +125,7 @@ func (*mockBalanceHandler) SponsorStateKeys(_ codec.Address) state.Keys { type mockAuth struct { start int64 end int64 + typeID uint8 computeUnits uint64 actor codec.Address sponsor codec.Address @@ -139,8 +140,8 @@ func (m *mockAuth) ComputeUnits(chain.Rules) uint64 { return m.computeUnits } -func (*mockAuth) GetTypeID() uint8 { - panic("unimplemented") +func (m *mockAuth) GetTypeID() uint8 { + return m.typeID } func (*mockAuth) Marshal(*codec.Packer) { diff --git a/internal/logging/noop.go b/internal/logging/noop.go new file mode 100644 index 0000000000..82f692cb20 --- /dev/null +++ b/internal/logging/noop.go @@ -0,0 +1,45 @@ +// Copyright (C) 2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package logging + +import ( + "github.com/ava-labs/avalanchego/utils/logging" + "go.uber.org/zap" +) + +var _ logging.Logger = (*Noop)(nil) + +type Noop struct{} + +func (*Noop) Debug(string, ...zap.Field) {} + +func (*Noop) Enabled(logging.Level) bool { + return false +} + +func (*Noop) Error(string, ...zap.Field) {} + +func (*Noop) Fatal(string, ...zap.Field) {} + +func (*Noop) Info(string, ...zap.Field) {} + +func (*Noop) RecoverAndExit(func(), func()) {} + +func (*Noop) RecoverAndPanic(func()) {} + +func (*Noop) SetLevel(logging.Level) {} + +func (*Noop) Stop() {} + +func (*Noop) StopOnPanic() {} + +func (*Noop) Trace(string, ...zap.Field) {} + +func (*Noop) Verbo(string, ...zap.Field) {} + +func (*Noop) Warn(string, ...zap.Field) {} + +func (*Noop) Write([]byte) (int, error) { + return 0, nil +} diff --git a/internal/workers/mock_workers.go b/internal/workers/mock_workers.go new file mode 100644 index 0000000000..773571a848 --- /dev/null +++ b/internal/workers/mock_workers.go @@ -0,0 +1,35 @@ +// Copyright (C) 2024, Ava Labs, Inc. All rights reserved. +// See the file LICENSE for licensing terms. + +package workers + +var ( + _ Workers = (*MockWorkers)(nil) + _ Job = (*MockJob)(nil) +) + +type MockWorkers struct { + OnNewJob func(backlog int) (Job, error) +} + +func (m *MockWorkers) NewJob(backlog int) (Job, error) { + return m.OnNewJob(backlog) +} + +func (*MockWorkers) Stop() {} + +type MockJob struct { + OnWaitError error +} + +func (*MockJob) Done(func()) {} + +func (*MockJob) Go(func() error) {} + +func (m *MockJob) Wait() error { + return m.OnWaitError +} + +func (*MockJob) Workers() int { + panic("unimplemented") +} From 81b93f831346e19dd14e53d60bba5e3137a7de6a Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Thu, 23 Jan 2025 17:59:18 -0500 Subject: [PATCH 02/41] nit --- chain/processor_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 2e113faed1..0c239d41fa 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -47,7 +47,6 @@ func TestProcessorExecute(t *testing.T) { }, } - // TODO: make sure to add a valid transaction to all applicable tests! tests := []struct { name string block *chain.ExecutionBlock From 3e9f766c4c114b454a6dc64610334f6fec8aeaf5 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Fri, 24 Jan 2025 12:46:07 -0500 Subject: [PATCH 03/41] use avalanchego logger --- chain/processor_test.go | 4 ++-- internal/logging/noop.go | 45 ---------------------------------------- 2 files changed, 2 insertions(+), 47 deletions(-) delete mode 100644 internal/logging/noop.go diff --git a/chain/processor_test.go b/chain/processor_test.go index 0c239d41fa..697452c129 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -17,9 +17,9 @@ import ( "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/require" + "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/hypersdk/chain" "github.com/ava-labs/hypersdk/genesis" - "github.com/ava-labs/hypersdk/internal/logging" "github.com/ava-labs/hypersdk/internal/validitywindow" "github.com/ava-labs/hypersdk/internal/validitywindow/validitywindowtest" "github.com/ava-labs/hypersdk/internal/workers" @@ -279,7 +279,7 @@ func TestProcessorExecute(t *testing.T) { prometheus.NewRegistry(), nil, nil, - &logging.Noop{}, + &logging.NoLog{}, &testRuleFactory, metadata.NewDefaultManager(), nil, diff --git a/internal/logging/noop.go b/internal/logging/noop.go deleted file mode 100644 index 82f692cb20..0000000000 --- a/internal/logging/noop.go +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright (C) 2024, Ava Labs, Inc. All rights reserved. -// See the file LICENSE for licensing terms. - -package logging - -import ( - "github.com/ava-labs/avalanchego/utils/logging" - "go.uber.org/zap" -) - -var _ logging.Logger = (*Noop)(nil) - -type Noop struct{} - -func (*Noop) Debug(string, ...zap.Field) {} - -func (*Noop) Enabled(logging.Level) bool { - return false -} - -func (*Noop) Error(string, ...zap.Field) {} - -func (*Noop) Fatal(string, ...zap.Field) {} - -func (*Noop) Info(string, ...zap.Field) {} - -func (*Noop) RecoverAndExit(func(), func()) {} - -func (*Noop) RecoverAndPanic(func()) {} - -func (*Noop) SetLevel(logging.Level) {} - -func (*Noop) Stop() {} - -func (*Noop) StopOnPanic() {} - -func (*Noop) Trace(string, ...zap.Field) {} - -func (*Noop) Verbo(string, ...zap.Field) {} - -func (*Noop) Warn(string, ...zap.Field) {} - -func (*Noop) Write([]byte) (int, error) { - return 0, nil -} From 467d7b833492ca74e14504e3660e7e13cb4ef38c Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Fri, 24 Jan 2025 13:14:21 -0500 Subject: [PATCH 04/41] create processor instead of chain --- chain/chain.go | 2 +- chain/metrics.go | 2 +- chain/processor_test.go | 18 +++++++++--------- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/chain/chain.go b/chain/chain.go index 2d5be31a20..e33f617b0e 100644 --- a/chain/chain.go +++ b/chain/chain.go @@ -37,7 +37,7 @@ func NewChain( validityWindow ValidityWindow, config Config, ) (*Chain, error) { - metrics, err := newMetrics(registerer) + metrics, err := NewMetrics(registerer) if err != nil { return nil, err } diff --git a/chain/metrics.go b/chain/metrics.go index 7e7f55d101..fcb84510b4 100644 --- a/chain/metrics.go +++ b/chain/metrics.go @@ -53,7 +53,7 @@ func (em *executorMetrics) RecordExecutable() { em.executable.Inc() } -func newMetrics(reg *prometheus.Registry) (*chainMetrics, error) { +func NewMetrics(reg *prometheus.Registry) (*chainMetrics, error) { m := &chainMetrics{ txsBuilt: prometheus.NewCounter(prometheus.CounterOpts{ Namespace: namespace, diff --git a/chain/processor_test.go b/chain/processor_test.go index 697452c129..02436b3716 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -13,11 +13,11 @@ import ( "github.com/ava-labs/avalanchego/database/memdb" "github.com/ava-labs/avalanchego/ids" "github.com/ava-labs/avalanchego/trace" + "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/x/merkledb" "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/require" - "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/hypersdk/chain" "github.com/ava-labs/hypersdk/genesis" "github.com/ava-labs/hypersdk/internal/validitywindow" @@ -274,21 +274,21 @@ func TestProcessorExecute(t *testing.T) { tt.validityWindow = &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{} } - testChain, err := chain.NewChain( + metrics, err := chain.NewMetrics(prometheus.NewRegistry()) + r.NoError(err) + + processor := chain.NewProcessor( trace.Noop, - prometheus.NewRegistry(), - nil, - nil, &logging.NoLog{}, &testRuleFactory, - metadata.NewDefaultManager(), - nil, tt.workers, nil, + metadata.NewDefaultManager(), + nil, tt.validityWindow, + metrics, chain.Config{}, ) - r.NoError(err) db, err := merkledb.New( ctx, @@ -311,7 +311,7 @@ func TestProcessorExecute(t *testing.T) { tt.block.StateRoot = root } - _, err = testChain.Execute(ctx, db, tt.block, tt.isNormalOp) + _, err = processor.Execute(ctx, db, tt.block, tt.isNormalOp) r.ErrorIs(err, tt.expectedErr) }) } From 5cdc67451d5086965fa1c37091c22414a4ed83de Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Fri, 24 Jan 2025 16:22:07 -0500 Subject: [PATCH 05/41] use constructors and lambda funcs --- chain/processor_test.go | 144 +++++++++++++++++++------------ chain/transaction_test.go | 4 +- internal/workers/mock_workers.go | 2 +- 3 files changed, 90 insertions(+), 60 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 02436b3716..1102644605 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -28,6 +28,8 @@ import ( ) var ( + _ chain.AuthVM = (*mockAuthVM)(nil) + heightKey = string(chain.HeightKey([]byte{0})) timestampKey = string(chain.TimestampKey([]byte{1})) @@ -36,23 +38,36 @@ var ( errMockVerifyExpiryReplayProtection = errors.New("mock validity window error") ) +type createBlock func(parentRoot ids.ID) (*chain.StatelessBlock, error) + +type mockAuthVM struct{} + +func (m *mockAuthVM) GetAuthBatchVerifier(authTypeID uint8, cores int, count int) (chain.AuthBatchVerifier, bool) { + return nil, false +} + +func (m *mockAuthVM) Logger() logging.Logger { + panic("unimplemented") +} + func TestProcessorExecute(t *testing.T) { testRules := genesis.NewDefaultRules() testRuleFactory := genesis.ImmutableRuleFactory{Rules: testRules} - invalidStateRoot := ids.ID{1} - validBlock := &chain.ExecutionBlock{ - StatelessBlock: &chain.StatelessBlock{ - Hght: 1, - Tmstmp: testRules.GetMinEmptyBlockGap(), - }, + createValidBlock := func(root ids.ID) (*chain.StatelessBlock, error) { + return chain.NewStatelessBlock( + ids.Empty, + testRules.GetMinEmptyBlockGap(), + 1, + nil, + root, + ) } tests := []struct { name string - block *chain.ExecutionBlock validityWindow chain.ValidityWindow - includeRoot bool isNormalOp bool + createBlock createBlock state map[string][]byte workers workers.Workers expectedErr error @@ -64,21 +79,24 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - block: validBlock, - includeRoot: true, + createBlock: createValidBlock, }, { name: "block timestamp too late", - block: &chain.ExecutionBlock{ - StatelessBlock: &chain.StatelessBlock{ - Tmstmp: time.Now().Add(chain.FutureBound).UnixMilli() + int64(time.Second), - }, + createBlock: func(root ids.ID) (*chain.StatelessBlock, error) { + return chain.NewStatelessBlock( + ids.Empty, + time.Now().Add(chain.FutureBound).UnixMilli()+int64(time.Second), + 0, + nil, + root, + ) }, expectedErr: chain.ErrTimestampTooLate, }, { - name: "verify signatures fails", - block: validBlock, + name: "verify signatures fails", + createBlock: createValidBlock, workers: &workers.MockWorkers{ OnNewJob: func(_ int) (workers.Job, error) { return nil, errMockWorker @@ -88,7 +106,7 @@ func TestProcessorExecute(t *testing.T) { }, { name: "failed to get parent height", - block: validBlock, + createBlock: createValidBlock, expectedErr: chain.ErrFailedToFetchParentHeight, }, { @@ -96,7 +114,7 @@ func TestProcessorExecute(t *testing.T) { state: map[string][]byte{ heightKey: {}, }, - block: validBlock, + createBlock: createValidBlock, expectedErr: chain.ErrFailedToParseParentHeight, }, { @@ -104,10 +122,14 @@ func TestProcessorExecute(t *testing.T) { state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), }, - block: &chain.ExecutionBlock{ - StatelessBlock: &chain.StatelessBlock{ - Hght: 2, - }, + createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { + return chain.NewStatelessBlock( + ids.Empty, + testRules.GetMinEmptyBlockGap(), + 2, + nil, + parentRoot, + ) }, expectedErr: chain.ErrInvalidBlockHeight, }, @@ -116,7 +138,7 @@ func TestProcessorExecute(t *testing.T) { state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), }, - block: validBlock, + createBlock: createValidBlock, expectedErr: chain.ErrFailedToFetchParentTimestamp, }, { @@ -125,7 +147,7 @@ func TestProcessorExecute(t *testing.T) { heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: {}, }, - block: validBlock, + createBlock: createValidBlock, expectedErr: chain.ErrFailedToParseParentTimestamp, }, { @@ -134,10 +156,12 @@ func TestProcessorExecute(t *testing.T) { heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), }, - block: &chain.ExecutionBlock{ - StatelessBlock: &chain.StatelessBlock{ - Hght: 1, - Txs: []*chain.Transaction{ + createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { + return chain.NewStatelessBlock( + ids.Empty, + 0, + 1, + []*chain.Transaction{ { TransactionData: chain.TransactionData{ Base: &chain.Base{}, @@ -147,7 +171,8 @@ func TestProcessorExecute(t *testing.T) { }, }, }, - }, + parentRoot, + ) }, expectedErr: chain.ErrTimestampTooEarly, }, @@ -157,10 +182,14 @@ func TestProcessorExecute(t *testing.T) { heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), }, - block: &chain.ExecutionBlock{ - StatelessBlock: &chain.StatelessBlock{ - Hght: 1, - }, + createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { + return chain.NewStatelessBlock( + ids.Empty, + 0, + 1, + nil, + parentRoot, + ) }, expectedErr: chain.ErrTimestampTooEarly, }, @@ -170,7 +199,7 @@ func TestProcessorExecute(t *testing.T) { heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), }, - block: validBlock, + createBlock: createValidBlock, expectedErr: chain.ErrFailedToFetchParentFee, }, { @@ -180,7 +209,7 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - block: validBlock, + createBlock: createValidBlock, validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{ OnVerifyExpiryReplayProtection: func(_ context.Context, _ validitywindow.ExecutionBlock[*chain.Transaction]) error { return errMockVerifyExpiryReplayProtection @@ -196,11 +225,12 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - block: &chain.ExecutionBlock{ - StatelessBlock: &chain.StatelessBlock{ - Hght: 1, - Tmstmp: testRules.GetMinEmptyBlockGap(), - Txs: []*chain.Transaction{ + createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { + return chain.NewStatelessBlock( + ids.Empty, + testRules.GetMinEmptyBlockGap(), + 1, + []*chain.Transaction{ { TransactionData: chain.TransactionData{ Base: &chain.Base{}, @@ -217,7 +247,8 @@ func TestProcessorExecute(t *testing.T) { }, }, }, - }, + parentRoot, + ) }, expectedErr: chain.ErrInvalidKeyValue, }, @@ -228,12 +259,14 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - block: &chain.ExecutionBlock{ - StatelessBlock: &chain.StatelessBlock{ - Hght: 1, - Tmstmp: testRules.GetMinEmptyBlockGap(), - StateRoot: invalidStateRoot, - }, + createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { + return chain.NewStatelessBlock( + ids.Empty, + testRules.GetMinEmptyBlockGap(), + 1, + nil, + ids.GenerateTestID(), + ) }, expectedErr: chain.ErrStateRootMismatch, }, @@ -244,7 +277,7 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - block: validBlock, + createBlock: createValidBlock, workers: &workers.MockWorkers{ OnNewJob: func(_ int) (workers.Job, error) { return &workers.MockJob{ @@ -252,7 +285,6 @@ func TestProcessorExecute(t *testing.T) { }, nil }, }, - includeRoot: true, expectedErr: errMockWorkerJob, }, } @@ -282,7 +314,7 @@ func TestProcessorExecute(t *testing.T) { &logging.NoLog{}, &testRuleFactory, tt.workers, - nil, + &mockAuthVM{}, metadata.NewDefaultManager(), nil, tt.validityWindow, @@ -305,13 +337,13 @@ func TestProcessorExecute(t *testing.T) { } r.NoError(db.CommitToDB(ctx)) - if tt.includeRoot { - root, err := db.GetMerkleRoot(ctx) - r.NoError(err) - tt.block.StateRoot = root - } + root, err := db.GetMerkleRoot(ctx) + r.NoError(err) + + block, err := tt.createBlock(root) + r.NoError(err) - _, err = processor.Execute(ctx, db, tt.block, tt.isNormalOp) + _, err = processor.Execute(ctx, db, chain.NewExecutionBlock(block), tt.isNormalOp) r.ErrorIs(err, tt.expectedErr) }) } diff --git a/chain/transaction_test.go b/chain/transaction_test.go index e4a17c8db3..a41c5a4ffa 100644 --- a/chain/transaction_test.go +++ b/chain/transaction_test.go @@ -144,9 +144,7 @@ func (m *mockAuth) GetTypeID() uint8 { return m.typeID } -func (*mockAuth) Marshal(*codec.Packer) { - panic("unimplemented") -} +func (*mockAuth) Marshal(*codec.Packer) {} func (*mockAuth) Size() int { panic("unimplemented") diff --git a/internal/workers/mock_workers.go b/internal/workers/mock_workers.go index 773571a848..0fb2b28131 100644 --- a/internal/workers/mock_workers.go +++ b/internal/workers/mock_workers.go @@ -31,5 +31,5 @@ func (m *MockJob) Wait() error { } func (*MockJob) Workers() int { - panic("unimplemented") + return 0 } From d3920c06af8488754bd48fb0f9e6a8cc2d0aa983 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Sun, 26 Jan 2025 15:08:56 -0500 Subject: [PATCH 06/41] use constructor for tx --- chain/processor_test.go | 56 ++++++++++++++++++++++++--------------- chain/transaction_test.go | 5 ++-- 2 files changed, 37 insertions(+), 24 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 1102644605..3692e88d26 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -42,11 +42,11 @@ type createBlock func(parentRoot ids.ID) (*chain.StatelessBlock, error) type mockAuthVM struct{} -func (m *mockAuthVM) GetAuthBatchVerifier(authTypeID uint8, cores int, count int) (chain.AuthBatchVerifier, bool) { +func (*mockAuthVM) GetAuthBatchVerifier(_ uint8, _ int, _ int) (chain.AuthBatchVerifier, bool) { return nil, false } -func (m *mockAuthVM) Logger() logging.Logger { +func (*mockAuthVM) Logger() logging.Logger { panic("unimplemented") } @@ -162,14 +162,18 @@ func TestProcessorExecute(t *testing.T) { 0, 1, []*chain.Transaction{ - { - TransactionData: chain.TransactionData{ - Base: &chain.Base{}, - }, - Auth: &mockAuth{ - typeID: 1, - }, - }, + func() *chain.Transaction { + r := require.New(t) + tx, err := chain.NewTransaction( + &chain.Base{}, + []chain.Action{}, + &mockAuth{ + typeID: 1, + }, + ) + r.NoError(err) + return tx + }(), }, parentRoot, ) @@ -231,21 +235,24 @@ func TestProcessorExecute(t *testing.T) { testRules.GetMinEmptyBlockGap(), 1, []*chain.Transaction{ - { - TransactionData: chain.TransactionData{ - Base: &chain.Base{}, - Actions: []chain.Action{ + func() *chain.Transaction { + r := require.New(t) + tx, err := chain.NewTransaction( + &chain.Base{}, + []chain.Action{ &mockAction{ stateKeys: state.Keys{ "": state.None, }, }, }, - }, - Auth: &mockAuth{ - typeID: 1, - }, - }, + &mockAuth{ + typeID: 1, + }, + ) + r.NoError(err) + return tx + }(), }, parentRoot, ) @@ -259,7 +266,7 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { + createBlock: func(_ ids.ID) (*chain.StatelessBlock, error) { return chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -340,10 +347,15 @@ func TestProcessorExecute(t *testing.T) { root, err := db.GetMerkleRoot(ctx) r.NoError(err) - block, err := tt.createBlock(root) + statelessBlock, err := tt.createBlock(root) r.NoError(err) - _, err = processor.Execute(ctx, db, chain.NewExecutionBlock(block), tt.isNormalOp) + _, err = processor.Execute( + ctx, + db, + chain.NewExecutionBlock(statelessBlock), + tt.isNormalOp, + ) r.ErrorIs(err, tt.expectedErr) }) } diff --git a/chain/transaction_test.go b/chain/transaction_test.go index a41c5a4ffa..eecedfec31 100644 --- a/chain/transaction_test.go +++ b/chain/transaction_test.go @@ -130,6 +130,7 @@ type mockAuth struct { actor codec.Address sponsor codec.Address verifyError error + size int } func (m *mockAuth) Actor() codec.Address { @@ -146,8 +147,8 @@ func (m *mockAuth) GetTypeID() uint8 { func (*mockAuth) Marshal(*codec.Packer) {} -func (*mockAuth) Size() int { - panic("unimplemented") +func (m *mockAuth) Size() int { + return m.size } func (m *mockAuth) Sponsor() codec.Address { From dd9c5a940da1021fa81136f601b57bb9f171254a Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Mon, 27 Jan 2025 09:54:04 -0500 Subject: [PATCH 07/41] nit --- chain/processor_test.go | 71 ++++++++++++++++++++------------ chain/transaction_test.go | 5 ++- internal/workers/mock_workers.go | 35 ---------------- 3 files changed, 47 insertions(+), 64 deletions(-) delete mode 100644 internal/workers/mock_workers.go diff --git a/chain/processor_test.go b/chain/processor_test.go index 3692e88d26..7ecf6aa1ae 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -18,7 +18,10 @@ import ( "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/require" + "github.com/ava-labs/hypersdk/auth" "github.com/ava-labs/hypersdk/chain" + "github.com/ava-labs/hypersdk/crypto" + "github.com/ava-labs/hypersdk/crypto/ed25519" "github.com/ava-labs/hypersdk/genesis" "github.com/ava-labs/hypersdk/internal/validitywindow" "github.com/ava-labs/hypersdk/internal/validitywindow/validitywindowtest" @@ -33,8 +36,6 @@ var ( heightKey = string(chain.HeightKey([]byte{0})) timestampKey = string(chain.TimestampKey([]byte{1})) - errMockWorker = errors.New("mock worker error") - errMockWorkerJob = errors.New("mock worker job error") errMockVerifyExpiryReplayProtection = errors.New("mock validity window error") ) @@ -56,7 +57,7 @@ func TestProcessorExecute(t *testing.T) { createValidBlock := func(root ids.ID) (*chain.StatelessBlock, error) { return chain.NewStatelessBlock( ids.Empty, - testRules.GetMinEmptyBlockGap(), + time.Now().UnixMilli(), 1, nil, root, @@ -97,12 +98,12 @@ func TestProcessorExecute(t *testing.T) { { name: "verify signatures fails", createBlock: createValidBlock, - workers: &workers.MockWorkers{ - OnNewJob: func(_ int) (workers.Job, error) { - return nil, errMockWorker - }, - }, - expectedErr: errMockWorker, + workers: func() workers.Workers { + w := workers.NewParallel(0, 0) + w.Stop() + return w + }(), + expectedErr: workers.ErrShutdown, }, { name: "failed to get parent height", @@ -284,15 +285,35 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - createBlock: createValidBlock, - workers: &workers.MockWorkers{ - OnNewJob: func(_ int) (workers.Job, error) { - return &workers.MockJob{ - OnWaitError: errMockWorkerJob, - }, nil - }, + createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { + return chain.NewStatelessBlock( + ids.Empty, + testRules.MinBlockGap, + 1, + []*chain.Transaction{ + func() *chain.Transaction { + r := require.New(t) + + p, err := ed25519.GeneratePrivateKey() + r.NoError(err) + + tx, err := chain.NewTransaction( + &chain.Base{ + Timestamp: testRules.GetMinBlockGap() * 10, + }, + []chain.Action{}, + &auth.ED25519{ + Signer: p.PublicKey(), + }, + ) + r.NoError(err) + return tx + }(), + }, + parentRoot, + ) }, - expectedErr: errMockWorkerJob, + expectedErr: crypto.ErrInvalidSignature, }, } @@ -301,18 +322,14 @@ func TestProcessorExecute(t *testing.T) { r := require.New(t) ctx := context.Background() - if tt.workers == nil { - tt.workers = &workers.MockWorkers{ - OnNewJob: func(_ int) (workers.Job, error) { - return &workers.MockJob{}, nil - }, - } - } - if tt.validityWindow == nil { tt.validityWindow = &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{} } + if tt.workers == nil { + tt.workers = workers.NewSerial() + } + metrics, err := chain.NewMetrics(prometheus.NewRegistry()) r.NoError(err) @@ -323,10 +340,10 @@ func TestProcessorExecute(t *testing.T) { tt.workers, &mockAuthVM{}, metadata.NewDefaultManager(), - nil, + &mockBalanceHandler{}, tt.validityWindow, metrics, - chain.Config{}, + chain.NewDefaultConfig(), ) db, err := merkledb.New( diff --git a/chain/transaction_test.go b/chain/transaction_test.go index eecedfec31..e0ed7c6aa8 100644 --- a/chain/transaction_test.go +++ b/chain/transaction_test.go @@ -100,6 +100,7 @@ func unmarshalAction2(p *codec.Packer) (chain.Action, error) { type mockBalanceHandler struct { canDeductError error + deductError error } func (*mockBalanceHandler) AddBalance(_ context.Context, _ codec.Address, _ state.Mutable, _ uint64) error { @@ -110,8 +111,8 @@ func (m *mockBalanceHandler) CanDeduct(_ context.Context, _ codec.Address, _ sta return m.canDeductError } -func (*mockBalanceHandler) Deduct(_ context.Context, _ codec.Address, _ state.Mutable, _ uint64) error { - panic("unimplemented") +func (m *mockBalanceHandler) Deduct(_ context.Context, _ codec.Address, _ state.Mutable, _ uint64) error { + return m.deductError } func (*mockBalanceHandler) GetBalance(_ context.Context, _ codec.Address, _ state.Immutable) (uint64, error) { diff --git a/internal/workers/mock_workers.go b/internal/workers/mock_workers.go deleted file mode 100644 index 0fb2b28131..0000000000 --- a/internal/workers/mock_workers.go +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright (C) 2024, Ava Labs, Inc. All rights reserved. -// See the file LICENSE for licensing terms. - -package workers - -var ( - _ Workers = (*MockWorkers)(nil) - _ Job = (*MockJob)(nil) -) - -type MockWorkers struct { - OnNewJob func(backlog int) (Job, error) -} - -func (m *MockWorkers) NewJob(backlog int) (Job, error) { - return m.OnNewJob(backlog) -} - -func (*MockWorkers) Stop() {} - -type MockJob struct { - OnWaitError error -} - -func (*MockJob) Done(func()) {} - -func (*MockJob) Go(func() error) {} - -func (m *MockJob) Wait() error { - return m.OnWaitError -} - -func (*MockJob) Workers() int { - return 0 -} From d2da050f3cd5430ba826b360a6eeea18626f1293 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Mon, 27 Jan 2025 10:11:04 -0500 Subject: [PATCH 08/41] consistent block timestamps --- chain/processor_test.go | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 7ecf6aa1ae..911218470f 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -28,6 +28,7 @@ import ( "github.com/ava-labs/hypersdk/internal/workers" "github.com/ava-labs/hypersdk/state" "github.com/ava-labs/hypersdk/state/metadata" + "github.com/ava-labs/hypersdk/utils" ) var ( @@ -126,7 +127,7 @@ func TestProcessorExecute(t *testing.T) { createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { return chain.NewStatelessBlock( ids.Empty, - testRules.GetMinEmptyBlockGap(), + time.Now().UnixMilli(), 2, nil, parentRoot, @@ -233,7 +234,7 @@ func TestProcessorExecute(t *testing.T) { createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { return chain.NewStatelessBlock( ids.Empty, - testRules.GetMinEmptyBlockGap(), + time.Now().UnixMilli(), 1, []*chain.Transaction{ func() *chain.Transaction { @@ -270,7 +271,7 @@ func TestProcessorExecute(t *testing.T) { createBlock: func(_ ids.ID) (*chain.StatelessBlock, error) { return chain.NewStatelessBlock( ids.Empty, - testRules.GetMinEmptyBlockGap(), + time.Now().UnixMilli(), 1, nil, ids.GenerateTestID(), @@ -288,7 +289,7 @@ func TestProcessorExecute(t *testing.T) { createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { return chain.NewStatelessBlock( ids.Empty, - testRules.MinBlockGap, + time.Now().UnixMilli(), 1, []*chain.Transaction{ func() *chain.Transaction { @@ -299,7 +300,10 @@ func TestProcessorExecute(t *testing.T) { tx, err := chain.NewTransaction( &chain.Base{ - Timestamp: testRules.GetMinBlockGap() * 10, + Timestamp: utils.UnixRMilli( + time.Now().UnixMilli(), + testRules.GetValidityWindow(), + ), }, []chain.Action{}, &auth.ED25519{ From 37dc75cf4f210797004f7ea55de3c55d40069665 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 13:24:43 -0500 Subject: [PATCH 09/41] add delimiter --- chain/processor.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chain/processor.go b/chain/processor.go index d049633d46..fb1713bd9b 100644 --- a/chain/processor.go +++ b/chain/processor.go @@ -383,7 +383,7 @@ func (p *Processor) createBlockContext( } parentHeight, err := database.ParseUInt64(parentHeightRaw) if err != nil { - return blockContext{}, fmt.Errorf("%w %w", ErrFailedToParseParentHeight, err) + return blockContext{}, fmt.Errorf("%w: %w", ErrFailedToParseParentHeight, err) } if block.Hght != parentHeight+1 { return blockContext{}, fmt.Errorf("%w: block height %d != parentHeight (%d) + 1", ErrInvalidBlockHeight, block.Hght, parentHeight) From 3fa517d68be5b221e3944ca6bfb751433b19ddd8 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 13:27:32 -0500 Subject: [PATCH 10/41] consistent naming --- chain/processor_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 911218470f..2d0edb3186 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -209,7 +209,7 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToFetchParentFee, }, { - name: "failed VerifyExpiryReplayProtection", + name: "fails replay protection", state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), From 3598dc7c36ebd3d53637d67d9a977d4d82228d05 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 13:29:15 -0500 Subject: [PATCH 11/41] group dependencies/parameters --- chain/processor_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 2d0edb3186..e0eee47550 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -68,10 +68,10 @@ func TestProcessorExecute(t *testing.T) { tests := []struct { name string validityWindow chain.ValidityWindow + workers workers.Workers isNormalOp bool createBlock createBlock state map[string][]byte - workers workers.Workers expectedErr error }{ { From 33e0fe41be049f222df77808378ca758a9cfe124 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 13:33:02 -0500 Subject: [PATCH 12/41] each test defines worker --- chain/processor_test.go | 58 ++++++++++++++++++++++++----------------- 1 file changed, 34 insertions(+), 24 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index e0eee47550..d307ebffe0 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -70,12 +70,13 @@ func TestProcessorExecute(t *testing.T) { validityWindow chain.ValidityWindow workers workers.Workers isNormalOp bool - createBlock createBlock state map[string][]byte + createBlock createBlock expectedErr error }{ { - name: "valid test case", + name: "valid test case", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -84,7 +85,8 @@ func TestProcessorExecute(t *testing.T) { createBlock: createValidBlock, }, { - name: "block timestamp too late", + name: "block timestamp too late", + workers: workers.NewSerial(), createBlock: func(root ids.ID) (*chain.StatelessBlock, error) { return chain.NewStatelessBlock( ids.Empty, @@ -108,11 +110,13 @@ func TestProcessorExecute(t *testing.T) { }, { name: "failed to get parent height", + workers: workers.NewSerial(), createBlock: createValidBlock, expectedErr: chain.ErrFailedToFetchParentHeight, }, { - name: "failed to parse parent height", + name: "failed to parse parent height", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: {}, }, @@ -120,7 +124,8 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToParseParentHeight, }, { - name: "block height is not one more than parent height (2 != 0 + 1)", + name: "block height is not one more than parent height (2 != 0 + 1)", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), }, @@ -136,7 +141,8 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrInvalidBlockHeight, }, { - name: "failed to get timestamp", + name: "failed to get timestamp", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), }, @@ -144,7 +150,8 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToFetchParentTimestamp, }, { - name: "failed to parse timestamp", + name: "failed to parse timestamp", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: {}, @@ -153,7 +160,8 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToParseParentTimestamp, }, { - name: "non-empty block timestamp less than parent timestamp with gap", + name: "non-empty block timestamp less than parent timestamp with gap", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -183,7 +191,8 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrTimestampTooEarly, }, { - name: "empty block timestamp less than parent timestamp with gap", + name: "empty block timestamp less than parent timestamp with gap", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -200,7 +209,8 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrTimestampTooEarly, }, { - name: "failed to get fee", + name: "failed to get fee", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -209,23 +219,25 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToFetchParentFee, }, { - name: "fails replay protection", + name: "fails replay protection", + workers: workers.NewSerial(), + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{ + OnVerifyExpiryReplayProtection: func(_ context.Context, _ validitywindow.ExecutionBlock[*chain.Transaction]) error { + return errMockVerifyExpiryReplayProtection + }, + }, + isNormalOp: true, state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, createBlock: createValidBlock, - validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{ - OnVerifyExpiryReplayProtection: func(_ context.Context, _ validitywindow.ExecutionBlock[*chain.Transaction]) error { - return errMockVerifyExpiryReplayProtection - }, - }, - isNormalOp: true, expectedErr: errMockVerifyExpiryReplayProtection, }, { - name: "failed to execute txs", + name: "failed to execute txs", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -262,7 +274,8 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrInvalidKeyValue, }, { - name: "state root mismatch", + name: "state root mismatch", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -280,7 +293,8 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrStateRootMismatch, }, { - name: "failed to verify signatures", + name: "failed to verify signatures", + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -330,10 +344,6 @@ func TestProcessorExecute(t *testing.T) { tt.validityWindow = &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{} } - if tt.workers == nil { - tt.workers = workers.NewSerial() - } - metrics, err := chain.NewMetrics(prometheus.NewRegistry()) r.NoError(err) From 2bbc4898b42b9358b369fbab6de7626f67618180 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 13:35:56 -0500 Subject: [PATCH 13/41] each test defines validitywindow --- chain/processor_test.go | 82 +++++++++++++++++++++++------------------ 1 file changed, 46 insertions(+), 36 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index d307ebffe0..796d1528d7 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -75,8 +75,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr error }{ { - name: "valid test case", - workers: workers.NewSerial(), + name: "valid test case", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -85,8 +86,9 @@ func TestProcessorExecute(t *testing.T) { createBlock: createValidBlock, }, { - name: "block timestamp too late", - workers: workers.NewSerial(), + name: "block timestamp too late", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), createBlock: func(root ids.ID) (*chain.StatelessBlock, error) { return chain.NewStatelessBlock( ids.Empty, @@ -99,24 +101,27 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrTimestampTooLate, }, { - name: "verify signatures fails", - createBlock: createValidBlock, + name: "verify signatures fails", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: func() workers.Workers { w := workers.NewParallel(0, 0) w.Stop() return w }(), + createBlock: createValidBlock, expectedErr: workers.ErrShutdown, }, { - name: "failed to get parent height", - workers: workers.NewSerial(), - createBlock: createValidBlock, - expectedErr: chain.ErrFailedToFetchParentHeight, + name: "failed to get parent height", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), + createBlock: createValidBlock, + expectedErr: chain.ErrFailedToFetchParentHeight, }, { - name: "failed to parse parent height", - workers: workers.NewSerial(), + name: "failed to parse parent height", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: {}, }, @@ -124,8 +129,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToParseParentHeight, }, { - name: "block height is not one more than parent height (2 != 0 + 1)", - workers: workers.NewSerial(), + name: "block height is not one more than parent height (2 != 0 + 1)", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), }, @@ -141,8 +147,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrInvalidBlockHeight, }, { - name: "failed to get timestamp", - workers: workers.NewSerial(), + name: "failed to get timestamp", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), }, @@ -150,8 +157,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToFetchParentTimestamp, }, { - name: "failed to parse timestamp", - workers: workers.NewSerial(), + name: "failed to parse timestamp", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: {}, @@ -160,8 +168,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToParseParentTimestamp, }, { - name: "non-empty block timestamp less than parent timestamp with gap", - workers: workers.NewSerial(), + name: "non-empty block timestamp less than parent timestamp with gap", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -191,8 +200,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrTimestampTooEarly, }, { - name: "empty block timestamp less than parent timestamp with gap", - workers: workers.NewSerial(), + name: "empty block timestamp less than parent timestamp with gap", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -209,8 +219,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrTimestampTooEarly, }, { - name: "failed to get fee", - workers: workers.NewSerial(), + name: "failed to get fee", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -219,13 +230,13 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToFetchParentFee, }, { - name: "fails replay protection", - workers: workers.NewSerial(), + name: "fails replay protection", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{ OnVerifyExpiryReplayProtection: func(_ context.Context, _ validitywindow.ExecutionBlock[*chain.Transaction]) error { return errMockVerifyExpiryReplayProtection }, }, + workers: workers.NewSerial(), isNormalOp: true, state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -236,8 +247,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: errMockVerifyExpiryReplayProtection, }, { - name: "failed to execute txs", - workers: workers.NewSerial(), + name: "failed to execute txs", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -274,8 +286,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrInvalidKeyValue, }, { - name: "state root mismatch", - workers: workers.NewSerial(), + name: "state root mismatch", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -293,8 +306,9 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrStateRootMismatch, }, { - name: "failed to verify signatures", - workers: workers.NewSerial(), + name: "failed to verify signatures", + validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, + workers: workers.NewSerial(), state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), @@ -340,10 +354,6 @@ func TestProcessorExecute(t *testing.T) { r := require.New(t) ctx := context.Background() - if tt.validityWindow == nil { - tt.validityWindow = &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{} - } - metrics, err := chain.NewMetrics(prometheus.NewRegistry()) r.NoError(err) From 390c816d577eac24758e5be3f4f2ec5d5fc3b229 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 13:41:08 -0500 Subject: [PATCH 14/41] createBlock returns only block --- chain/processor_test.go | 55 +++++++++++++++++++++++++---------------- 1 file changed, 34 insertions(+), 21 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 796d1528d7..5bfbee9283 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -40,7 +40,7 @@ var ( errMockVerifyExpiryReplayProtection = errors.New("mock validity window error") ) -type createBlock func(parentRoot ids.ID) (*chain.StatelessBlock, error) +type createBlock func(parentRoot ids.ID) *chain.StatelessBlock type mockAuthVM struct{} @@ -55,14 +55,16 @@ func (*mockAuthVM) Logger() logging.Logger { func TestProcessorExecute(t *testing.T) { testRules := genesis.NewDefaultRules() testRuleFactory := genesis.ImmutableRuleFactory{Rules: testRules} - createValidBlock := func(root ids.ID) (*chain.StatelessBlock, error) { - return chain.NewStatelessBlock( + createValidBlock := func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), 1, nil, root, ) + require.NoError(t, err) + return block } tests := []struct { @@ -89,14 +91,16 @@ func TestProcessorExecute(t *testing.T) { name: "block timestamp too late", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - createBlock: func(root ids.ID) (*chain.StatelessBlock, error) { - return chain.NewStatelessBlock( + createBlock: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( ids.Empty, time.Now().Add(chain.FutureBound).UnixMilli()+int64(time.Second), 0, nil, root, ) + require.NoError(t, err) + return block }, expectedErr: chain.ErrTimestampTooLate, }, @@ -135,14 +139,16 @@ func TestProcessorExecute(t *testing.T) { state: map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), }, - createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { - return chain.NewStatelessBlock( + createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), 2, nil, parentRoot, ) + require.NoError(t, err) + return block }, expectedErr: chain.ErrInvalidBlockHeight, }, @@ -175,8 +181,8 @@ func TestProcessorExecute(t *testing.T) { heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), }, - createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { - return chain.NewStatelessBlock( + createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( ids.Empty, 0, 1, @@ -196,6 +202,8 @@ func TestProcessorExecute(t *testing.T) { }, parentRoot, ) + require.NoError(t, err) + return block }, expectedErr: chain.ErrTimestampTooEarly, }, @@ -207,14 +215,16 @@ func TestProcessorExecute(t *testing.T) { heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), }, - createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { - return chain.NewStatelessBlock( + createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( ids.Empty, 0, 1, nil, parentRoot, ) + require.NoError(t, err) + return block }, expectedErr: chain.ErrTimestampTooEarly, }, @@ -255,8 +265,8 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { - return chain.NewStatelessBlock( + createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), 1, @@ -282,6 +292,8 @@ func TestProcessorExecute(t *testing.T) { }, parentRoot, ) + require.NoError(t, err) + return block }, expectedErr: chain.ErrInvalidKeyValue, }, @@ -294,14 +306,16 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - createBlock: func(_ ids.ID) (*chain.StatelessBlock, error) { - return chain.NewStatelessBlock( + createBlock: func(_ ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), 1, nil, ids.GenerateTestID(), ) + require.NoError(t, err) + return block }, expectedErr: chain.ErrStateRootMismatch, }, @@ -314,8 +328,8 @@ func TestProcessorExecute(t *testing.T) { timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }, - createBlock: func(parentRoot ids.ID) (*chain.StatelessBlock, error) { - return chain.NewStatelessBlock( + createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), 1, @@ -344,6 +358,8 @@ func TestProcessorExecute(t *testing.T) { }, parentRoot, ) + require.NoError(t, err) + return block }, expectedErr: crypto.ErrInvalidSignature, }, @@ -388,13 +404,10 @@ func TestProcessorExecute(t *testing.T) { root, err := db.GetMerkleRoot(ctx) r.NoError(err) - statelessBlock, err := tt.createBlock(root) - r.NoError(err) - _, err = processor.Execute( ctx, db, - chain.NewExecutionBlock(statelessBlock), + chain.NewExecutionBlock(tt.createBlock(root)), tt.isNormalOp, ) r.ErrorIs(err, tt.expectedErr) From 7aa3fd1c59c32743d5398a224f4d18afafa7e810 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 13:51:43 -0500 Subject: [PATCH 15/41] consistent usage of require --- chain/processor_test.go | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 5bfbee9283..0cd636312d 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -188,7 +188,6 @@ func TestProcessorExecute(t *testing.T) { 1, []*chain.Transaction{ func() *chain.Transaction { - r := require.New(t) tx, err := chain.NewTransaction( &chain.Base{}, []chain.Action{}, @@ -196,7 +195,7 @@ func TestProcessorExecute(t *testing.T) { typeID: 1, }, ) - r.NoError(err) + require.NoError(t, err) return tx }(), }, @@ -272,7 +271,6 @@ func TestProcessorExecute(t *testing.T) { 1, []*chain.Transaction{ func() *chain.Transaction { - r := require.New(t) tx, err := chain.NewTransaction( &chain.Base{}, []chain.Action{ @@ -286,7 +284,7 @@ func TestProcessorExecute(t *testing.T) { typeID: 1, }, ) - r.NoError(err) + require.NoError(t, err) return tx }(), }, @@ -335,10 +333,8 @@ func TestProcessorExecute(t *testing.T) { 1, []*chain.Transaction{ func() *chain.Transaction { - r := require.New(t) - p, err := ed25519.GeneratePrivateKey() - r.NoError(err) + require.NoError(t, err) tx, err := chain.NewTransaction( &chain.Base{ @@ -352,7 +348,7 @@ func TestProcessorExecute(t *testing.T) { Signer: p.PublicKey(), }, ) - r.NoError(err) + require.NoError(t, err) return tx }(), }, From 9cd1db1451de0753b8186b514ea390eddf60c394 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 15:27:06 -0500 Subject: [PATCH 16/41] each test declares rules --- chain/processor_test.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 0cd636312d..4f8855ef38 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -53,8 +53,6 @@ func (*mockAuthVM) Logger() logging.Logger { } func TestProcessorExecute(t *testing.T) { - testRules := genesis.NewDefaultRules() - testRuleFactory := genesis.ImmutableRuleFactory{Rules: testRules} createValidBlock := func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -336,6 +334,7 @@ func TestProcessorExecute(t *testing.T) { p, err := ed25519.GeneratePrivateKey() require.NoError(t, err) + testRules := genesis.NewDefaultRules() tx, err := chain.NewTransaction( &chain.Base{ Timestamp: utils.UnixRMilli( @@ -372,7 +371,7 @@ func TestProcessorExecute(t *testing.T) { processor := chain.NewProcessor( trace.Noop, &logging.NoLog{}, - &testRuleFactory, + &genesis.ImmutableRuleFactory{Rules: genesis.NewDefaultRules()}, tt.workers, &mockAuthVM{}, metadata.NewDefaultManager(), From 3395a71b8c7ff79116218278f40f05db1a26c343 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 15:38:51 -0500 Subject: [PATCH 17/41] remove unnecessary commit to db --- chain/processor_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 4f8855ef38..8f088cc93b 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -394,7 +394,6 @@ func TestProcessorExecute(t *testing.T) { for k, v := range tt.state { r.NoError(db.Put([]byte(k), v)) } - r.NoError(db.CommitToDB(ctx)) root, err := db.GetMerkleRoot(ctx) r.NoError(err) From c5750f8b9aabd06ed52144db89cc8e07ece8c698 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 16:13:35 -0500 Subject: [PATCH 18/41] replace map with merkledb --- chain/processor_test.go | 159 +++++++++++++++++++++++----------------- 1 file changed, 92 insertions(+), 67 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 8f088cc93b..df32d6165f 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -64,13 +64,25 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, err) return block } + createDB := func() merkledb.MerkleDB { + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) + return db + } tests := []struct { name string validityWindow chain.ValidityWindow workers workers.Workers isNormalOp bool - state map[string][]byte + db merkledb.MerkleDB createBlock createBlock expectedErr error }{ @@ -78,11 +90,13 @@ func TestProcessorExecute(t *testing.T) { name: "valid test case", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: binary.BigEndian.AppendUint64(nil, 0), - feeKey: {}, - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(feeKey), []byte{})) + return db + }(), createBlock: createValidBlock, }, { @@ -100,6 +114,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, err) return block }, + db: createDB(), expectedErr: chain.ErrTimestampTooLate, }, { @@ -110,6 +125,7 @@ func TestProcessorExecute(t *testing.T) { w.Stop() return w }(), + db: createDB(), createBlock: createValidBlock, expectedErr: workers.ErrShutdown, }, @@ -117,6 +133,7 @@ func TestProcessorExecute(t *testing.T) { name: "failed to get parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), + db: createDB(), createBlock: createValidBlock, expectedErr: chain.ErrFailedToFetchParentHeight, }, @@ -124,9 +141,11 @@ func TestProcessorExecute(t *testing.T) { name: "failed to parse parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: {}, - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), []byte{})) + return db + }(), createBlock: createValidBlock, expectedErr: chain.ErrFailedToParseParentHeight, }, @@ -134,9 +153,11 @@ func TestProcessorExecute(t *testing.T) { name: "block height is not one more than parent height (2 != 0 + 1)", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + return db + }(), createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -154,9 +175,11 @@ func TestProcessorExecute(t *testing.T) { name: "failed to get timestamp", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + return db + }(), createBlock: createValidBlock, expectedErr: chain.ErrFailedToFetchParentTimestamp, }, @@ -164,10 +187,12 @@ func TestProcessorExecute(t *testing.T) { name: "failed to parse timestamp", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: {}, - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), []byte{})) + return db + }(), createBlock: createValidBlock, expectedErr: chain.ErrFailedToParseParentTimestamp, }, @@ -175,10 +200,12 @@ func TestProcessorExecute(t *testing.T) { name: "non-empty block timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: binary.BigEndian.AppendUint64(nil, 0), - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) + return db + }(), createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -208,10 +235,12 @@ func TestProcessorExecute(t *testing.T) { name: "empty block timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: binary.BigEndian.AppendUint64(nil, 0), - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) + return db + }(), createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -229,10 +258,12 @@ func TestProcessorExecute(t *testing.T) { name: "failed to get fee", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: binary.BigEndian.AppendUint64(nil, 0), - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) + return db + }(), createBlock: createValidBlock, expectedErr: chain.ErrFailedToFetchParentFee, }, @@ -245,11 +276,13 @@ func TestProcessorExecute(t *testing.T) { }, workers: workers.NewSerial(), isNormalOp: true, - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: binary.BigEndian.AppendUint64(nil, 0), - feeKey: {}, - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(feeKey), []byte{})) + return db + }(), createBlock: createValidBlock, expectedErr: errMockVerifyExpiryReplayProtection, }, @@ -257,11 +290,13 @@ func TestProcessorExecute(t *testing.T) { name: "failed to execute txs", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: binary.BigEndian.AppendUint64(nil, 0), - feeKey: {}, - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(feeKey), []byte{})) + return db + }(), createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -297,11 +332,13 @@ func TestProcessorExecute(t *testing.T) { name: "state root mismatch", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: binary.BigEndian.AppendUint64(nil, 0), - feeKey: {}, - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(feeKey), []byte{})) + return db + }(), createBlock: func(_ ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -319,11 +356,13 @@ func TestProcessorExecute(t *testing.T) { name: "failed to verify signatures", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - state: map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), - timestampKey: binary.BigEndian.AppendUint64(nil, 0), - feeKey: {}, - }, + db: func() merkledb.MerkleDB { + db := createDB() + require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) + require.NoError(t, db.Put([]byte(feeKey), []byte{})) + return db + }(), createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -381,26 +420,12 @@ func TestProcessorExecute(t *testing.T) { chain.NewDefaultConfig(), ) - db, err := merkledb.New( - ctx, - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) - r.NoError(err) - - for k, v := range tt.state { - r.NoError(db.Put([]byte(k), v)) - } - - root, err := db.GetMerkleRoot(ctx) + root, err := tt.db.GetMerkleRoot(ctx) r.NoError(err) _, err = processor.Execute( ctx, - db, + tt.db, chain.NewExecutionBlock(tt.createBlock(root)), tt.isNormalOp, ) From 167755c4de5c01041983fdc3b1ed61c349b9fbea Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 16:37:14 -0500 Subject: [PATCH 19/41] export chain metrics --- chain/accepter.go | 4 ++-- chain/builder.go | 4 ++-- chain/metrics.go | 6 +++--- chain/processor.go | 4 ++-- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/chain/accepter.go b/chain/accepter.go index 0ed6cd9928..6007dcd1dc 100644 --- a/chain/accepter.go +++ b/chain/accepter.go @@ -12,13 +12,13 @@ import ( type Accepter struct { tracer trace.Tracer validityWindow ValidityWindow - metrics *chainMetrics + metrics *ChainMetrics } func NewAccepter( tracer trace.Tracer, validityWindow ValidityWindow, - metrics *chainMetrics, + metrics *ChainMetrics, ) *Accepter { return &Accepter{ tracer: tracer, diff --git a/chain/builder.go b/chain/builder.go index a5f978fec2..a03b2d846e 100644 --- a/chain/builder.go +++ b/chain/builder.go @@ -44,7 +44,7 @@ type Builder struct { balanceHandler BalanceHandler mempool Mempool validityWindow ValidityWindow - metrics *chainMetrics + metrics *ChainMetrics config Config } @@ -56,7 +56,7 @@ func NewBuilder( balanceHandler BalanceHandler, mempool Mempool, validityWindow ValidityWindow, - metrics *chainMetrics, + metrics *ChainMetrics, config Config, ) *Builder { return &Builder{ diff --git a/chain/metrics.go b/chain/metrics.go index fcb84510b4..afbdf25a81 100644 --- a/chain/metrics.go +++ b/chain/metrics.go @@ -12,7 +12,7 @@ import ( const namespace = "chain" -type chainMetrics struct { +type ChainMetrics struct { txsBuilt prometheus.Counter txsVerified prometheus.Counter txsAccepted prometheus.Counter @@ -53,8 +53,8 @@ func (em *executorMetrics) RecordExecutable() { em.executable.Inc() } -func NewMetrics(reg *prometheus.Registry) (*chainMetrics, error) { - m := &chainMetrics{ +func NewMetrics(reg *prometheus.Registry) (*ChainMetrics, error) { + m := &ChainMetrics{ txsBuilt: prometheus.NewCounter(prometheus.CounterOpts{ Namespace: namespace, Name: "txs_built", diff --git a/chain/processor.go b/chain/processor.go index fb1713bd9b..4ae42b7b4f 100644 --- a/chain/processor.go +++ b/chain/processor.go @@ -83,7 +83,7 @@ type Processor struct { metadataManager MetadataManager balanceHandler BalanceHandler validityWindow ValidityWindow - metrics *chainMetrics + metrics *ChainMetrics config Config } @@ -96,7 +96,7 @@ func NewProcessor( metadataManager MetadataManager, balanceHandler BalanceHandler, validityWindow ValidityWindow, - metrics *chainMetrics, + metrics *ChainMetrics, config Config, ) *Processor { return &Processor{ From d56316ea86a70031067b8d6ddb5951af8ee7cd2d Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 17:23:28 -0500 Subject: [PATCH 20/41] nits --- chain/processor_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index df32d6165f..043e7a1b86 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -44,7 +44,7 @@ type createBlock func(parentRoot ids.ID) *chain.StatelessBlock type mockAuthVM struct{} -func (*mockAuthVM) GetAuthBatchVerifier(_ uint8, _ int, _ int) (chain.AuthBatchVerifier, bool) { +func (*mockAuthVM) GetAuthBatchVerifier(uint8, int, int) (chain.AuthBatchVerifier, bool) { return nil, false } @@ -150,7 +150,7 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToParseParentHeight, }, { - name: "block height is not one more than parent height (2 != 0 + 1)", + name: "block height is not one more than parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { @@ -270,7 +270,7 @@ func TestProcessorExecute(t *testing.T) { { name: "fails replay protection", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{ - OnVerifyExpiryReplayProtection: func(_ context.Context, _ validitywindow.ExecutionBlock[*chain.Transaction]) error { + OnVerifyExpiryReplayProtection: func(context.Context, validitywindow.ExecutionBlock[*chain.Transaction]) error { return errMockVerifyExpiryReplayProtection }, }, @@ -339,7 +339,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - createBlock: func(_ ids.ID) *chain.StatelessBlock { + createBlock: func(ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), From 8b4f12e9c4dbb9387d87457d24ad62e391ec3c41 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 17:24:11 -0500 Subject: [PATCH 21/41] nits --- chain/processor_test.go | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 043e7a1b86..9a13799f0a 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -40,18 +40,6 @@ var ( errMockVerifyExpiryReplayProtection = errors.New("mock validity window error") ) -type createBlock func(parentRoot ids.ID) *chain.StatelessBlock - -type mockAuthVM struct{} - -func (*mockAuthVM) GetAuthBatchVerifier(uint8, int, int) (chain.AuthBatchVerifier, bool) { - return nil, false -} - -func (*mockAuthVM) Logger() logging.Logger { - panic("unimplemented") -} - func TestProcessorExecute(t *testing.T) { createValidBlock := func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -83,7 +71,7 @@ func TestProcessorExecute(t *testing.T) { workers workers.Workers isNormalOp bool db merkledb.MerkleDB - createBlock createBlock + createBlock func(ids.ID) *chain.StatelessBlock expectedErr error }{ { @@ -433,3 +421,13 @@ func TestProcessorExecute(t *testing.T) { }) } } + +type mockAuthVM struct{} + +func (*mockAuthVM) GetAuthBatchVerifier(uint8, int, int) (chain.AuthBatchVerifier, bool) { + return nil, false +} + +func (*mockAuthVM) Logger() logging.Logger { + panic("unimplemented") +} From a51526d694980f62ac6132a6a0e7a71229a0e3c4 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 17:26:30 -0500 Subject: [PATCH 22/41] rename block constructor --- chain/processor_test.go | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 9a13799f0a..4159f71b80 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -71,7 +71,7 @@ func TestProcessorExecute(t *testing.T) { workers workers.Workers isNormalOp bool db merkledb.MerkleDB - createBlock func(ids.ID) *chain.StatelessBlock + newBlockF func(ids.ID) *chain.StatelessBlock expectedErr error }{ { @@ -85,13 +85,13 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - createBlock: createValidBlock, + newBlockF: createValidBlock, }, { name: "block timestamp too late", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - createBlock: func(root ids.ID) *chain.StatelessBlock { + newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, time.Now().Add(chain.FutureBound).UnixMilli()+int64(time.Second), @@ -114,7 +114,7 @@ func TestProcessorExecute(t *testing.T) { return w }(), db: createDB(), - createBlock: createValidBlock, + newBlockF: createValidBlock, expectedErr: workers.ErrShutdown, }, { @@ -122,7 +122,7 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: createDB(), - createBlock: createValidBlock, + newBlockF: createValidBlock, expectedErr: chain.ErrFailedToFetchParentHeight, }, { @@ -134,7 +134,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(heightKey), []byte{})) return db }(), - createBlock: createValidBlock, + newBlockF: createValidBlock, expectedErr: chain.ErrFailedToParseParentHeight, }, { @@ -146,7 +146,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), @@ -168,7 +168,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - createBlock: createValidBlock, + newBlockF: createValidBlock, expectedErr: chain.ErrFailedToFetchParentTimestamp, }, { @@ -181,7 +181,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(timestampKey), []byte{})) return db }(), - createBlock: createValidBlock, + newBlockF: createValidBlock, expectedErr: chain.ErrFailedToParseParentTimestamp, }, { @@ -194,7 +194,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, 0, @@ -229,7 +229,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, 0, @@ -252,7 +252,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - createBlock: createValidBlock, + newBlockF: createValidBlock, expectedErr: chain.ErrFailedToFetchParentFee, }, { @@ -271,7 +271,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - createBlock: createValidBlock, + newBlockF: createValidBlock, expectedErr: errMockVerifyExpiryReplayProtection, }, { @@ -285,7 +285,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), @@ -327,7 +327,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - createBlock: func(ids.ID) *chain.StatelessBlock { + newBlockF: func(ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), @@ -351,7 +351,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - createBlock: func(parentRoot ids.ID) *chain.StatelessBlock { + newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, time.Now().UnixMilli(), @@ -414,7 +414,7 @@ func TestProcessorExecute(t *testing.T) { _, err = processor.Execute( ctx, tt.db, - chain.NewExecutionBlock(tt.createBlock(root)), + chain.NewExecutionBlock(tt.newBlockF(root)), tt.isNormalOp, ) r.ErrorIs(err, tt.expectedErr) From 6acef69a2f904db7f9b9ed56752cbb55dcd0cb75 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 17:36:48 -0500 Subject: [PATCH 23/41] use single time --- chain/processor_test.go | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 4159f71b80..95ab79c33e 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -41,10 +41,11 @@ var ( ) func TestProcessorExecute(t *testing.T) { + currentTime := time.Now() createValidBlock := func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - time.Now().UnixMilli(), + currentTime.UnixMilli(), 1, nil, root, @@ -94,7 +95,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - time.Now().Add(chain.FutureBound).UnixMilli()+int64(time.Second), + currentTime.Add(chain.FutureBound).UnixMilli()+int64(time.Second), 0, nil, root, @@ -149,7 +150,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - time.Now().UnixMilli(), + currentTime.UnixMilli(), 2, nil, parentRoot, @@ -288,7 +289,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - time.Now().UnixMilli(), + currentTime.UnixMilli(), 1, []*chain.Transaction{ func() *chain.Transaction { @@ -330,7 +331,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - time.Now().UnixMilli(), + currentTime.UnixMilli(), 1, nil, ids.GenerateTestID(), @@ -354,7 +355,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - time.Now().UnixMilli(), + currentTime.UnixMilli(), 1, []*chain.Transaction{ func() *chain.Transaction { @@ -365,7 +366,7 @@ func TestProcessorExecute(t *testing.T) { tx, err := chain.NewTransaction( &chain.Base{ Timestamp: utils.UnixRMilli( - time.Now().UnixMilli(), + currentTime.UnixMilli(), testRules.GetValidityWindow(), ), }, From d9e0a43800fddc688d7747cc995d25f1c2012958 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Tue, 28 Jan 2025 17:43:53 -0500 Subject: [PATCH 24/41] nit --- chain/processor_test.go | 50 ++++++++++++++++++++--------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 95ab79c33e..f76a6e9e5a 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -42,7 +42,7 @@ var ( func TestProcessorExecute(t *testing.T) { currentTime := time.Now() - createValidBlock := func(root ids.ID) *chain.StatelessBlock { + validBlockF := func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, currentTime.UnixMilli(), @@ -53,7 +53,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, err) return block } - createDB := func() merkledb.MerkleDB { + dbF := func() merkledb.MerkleDB { db, err := merkledb.New( context.Background(), memdb.New(), @@ -80,13 +80,13 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - newBlockF: createValidBlock, + newBlockF: validBlockF, }, { name: "block timestamp too late", @@ -103,7 +103,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, err) return block }, - db: createDB(), + db: dbF(), expectedErr: chain.ErrTimestampTooLate, }, { @@ -114,16 +114,16 @@ func TestProcessorExecute(t *testing.T) { w.Stop() return w }(), - db: createDB(), - newBlockF: createValidBlock, + db: dbF(), + newBlockF: validBlockF, expectedErr: workers.ErrShutdown, }, { name: "failed to get parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: createDB(), - newBlockF: createValidBlock, + db: dbF(), + newBlockF: validBlockF, expectedErr: chain.ErrFailedToFetchParentHeight, }, { @@ -131,11 +131,11 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), []byte{})) return db }(), - newBlockF: createValidBlock, + newBlockF: validBlockF, expectedErr: chain.ErrFailedToParseParentHeight, }, { @@ -143,7 +143,7 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), @@ -165,11 +165,11 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - newBlockF: createValidBlock, + newBlockF: validBlockF, expectedErr: chain.ErrFailedToFetchParentTimestamp, }, { @@ -177,12 +177,12 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), []byte{})) return db }(), - newBlockF: createValidBlock, + newBlockF: validBlockF, expectedErr: chain.ErrFailedToParseParentTimestamp, }, { @@ -190,7 +190,7 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db @@ -225,7 +225,7 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db @@ -248,12 +248,12 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - newBlockF: createValidBlock, + newBlockF: validBlockF, expectedErr: chain.ErrFailedToFetchParentFee, }, { @@ -266,13 +266,13 @@ func TestProcessorExecute(t *testing.T) { workers: workers.NewSerial(), isNormalOp: true, db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - newBlockF: createValidBlock, + newBlockF: validBlockF, expectedErr: errMockVerifyExpiryReplayProtection, }, { @@ -280,7 +280,7 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) @@ -322,7 +322,7 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) @@ -346,7 +346,7 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := createDB() + db := dbF() require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) From c0934f66f2f31fe8a227150641906a24ccd252e8 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Wed, 29 Jan 2025 09:24:56 -0500 Subject: [PATCH 25/41] use constant time when possible --- chain/processor_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index f76a6e9e5a..85afa51ef9 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -41,7 +41,7 @@ var ( ) func TestProcessorExecute(t *testing.T) { - currentTime := time.Now() + currentTime := time.UnixMilli(genesis.NewDefaultRules().GetMinEmptyBlockGap()) validBlockF := func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -95,7 +95,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - currentTime.Add(chain.FutureBound).UnixMilli()+int64(time.Second), + time.Now().Add(chain.FutureBound).UnixMilli()+int64(time.Second), 0, nil, root, From de7142dec1afd85dc08f4cde4b5d80ff40cf2552 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Wed, 29 Jan 2025 09:31:53 -0500 Subject: [PATCH 26/41] nit --- chain/processor_test.go | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 85afa51ef9..a1b9f993bd 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -41,11 +41,10 @@ var ( ) func TestProcessorExecute(t *testing.T) { - currentTime := time.UnixMilli(genesis.NewDefaultRules().GetMinEmptyBlockGap()) validBlockF := func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - currentTime.UnixMilli(), + time.UnixMilli(genesis.NewDefaultRules().GetMinEmptyBlockGap()).UnixMilli(), 1, nil, root, @@ -95,7 +94,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - time.Now().Add(chain.FutureBound).UnixMilli()+int64(time.Second), + time.Now().Add(2*chain.FutureBound).UnixMilli(), 0, nil, root, @@ -150,7 +149,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - currentTime.UnixMilli(), + genesis.NewDefaultRules().GetMinEmptyBlockGap(), 2, nil, parentRoot, @@ -289,7 +288,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - currentTime.UnixMilli(), + genesis.NewDefaultRules().GetMinEmptyBlockGap(), 1, []*chain.Transaction{ func() *chain.Transaction { @@ -331,7 +330,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - currentTime.UnixMilli(), + genesis.NewDefaultRules().GetMinEmptyBlockGap(), 1, nil, ids.GenerateTestID(), @@ -355,7 +354,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - currentTime.UnixMilli(), + genesis.NewDefaultRules().GetMinEmptyBlockGap(), 1, []*chain.Transaction{ func() *chain.Transaction { @@ -366,7 +365,7 @@ func TestProcessorExecute(t *testing.T) { tx, err := chain.NewTransaction( &chain.Base{ Timestamp: utils.UnixRMilli( - currentTime.UnixMilli(), + genesis.NewDefaultRules().GetMinEmptyBlockGap(), testRules.GetValidityWindow(), ), }, From 7f3e6ea78a8c5ae40ce3a2b78daf5b429ff7566f Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Wed, 29 Jan 2025 09:35:33 -0500 Subject: [PATCH 27/41] nit --- chain/processor_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index a1b9f993bd..1243525027 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -44,7 +44,7 @@ func TestProcessorExecute(t *testing.T) { validBlockF := func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - time.UnixMilli(genesis.NewDefaultRules().GetMinEmptyBlockGap()).UnixMilli(), + genesis.NewDefaultRules().GetMinEmptyBlockGap(), 1, nil, root, From 6afe17239b22426b6c1cea96325972766d45dcc7 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Wed, 29 Jan 2025 09:48:20 -0500 Subject: [PATCH 28/41] remove lambda funcs --- chain/processor_test.go | 281 +++++++++++++++++++++++++++++++++------- 1 file changed, 233 insertions(+), 48 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 1243525027..81e8ff3665 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -41,30 +41,6 @@ var ( ) func TestProcessorExecute(t *testing.T) { - validBlockF := func(root ids.ID) *chain.StatelessBlock { - block, err := chain.NewStatelessBlock( - ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), - 1, - nil, - root, - ) - require.NoError(t, err) - return block - } - dbF := func() merkledb.MerkleDB { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) - require.NoError(t, err) - return db - } - tests := []struct { name string validityWindow chain.ValidityWindow @@ -79,13 +55,31 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - newBlockF: validBlockF, + newBlockF: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( + ids.Empty, + genesis.NewDefaultRules().GetMinEmptyBlockGap(), + 1, + nil, + root, + ) + require.NoError(t, err) + return block + }, }, { name: "block timestamp too late", @@ -102,7 +96,18 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, err) return block }, - db: dbF(), + db: func() merkledb.MerkleDB { + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) + return db + }(), expectedErr: chain.ErrTimestampTooLate, }, { @@ -113,28 +118,88 @@ func TestProcessorExecute(t *testing.T) { w.Stop() return w }(), - db: dbF(), - newBlockF: validBlockF, + db: func() merkledb.MerkleDB { + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) + return db + }(), + newBlockF: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( + ids.Empty, + genesis.NewDefaultRules().GetMinEmptyBlockGap(), + 1, + nil, + root, + ) + require.NoError(t, err) + return block + }, expectedErr: workers.ErrShutdown, }, { name: "failed to get parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: dbF(), - newBlockF: validBlockF, - expectedErr: chain.ErrFailedToFetchParentHeight, + db: func() merkledb.MerkleDB { + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) + return db + }(), + newBlockF: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( + ids.Empty, + genesis.NewDefaultRules().GetMinEmptyBlockGap(), + 1, + nil, + root, + ) + require.NoError(t, err) + return block + }, + expectedErr: chain.ErrFailedToFetchParentHeight, }, { name: "failed to parse parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), []byte{})) return db }(), - newBlockF: validBlockF, + newBlockF: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( + ids.Empty, + genesis.NewDefaultRules().GetMinEmptyBlockGap(), + 1, + nil, + root, + ) + require.NoError(t, err) + return block + }, expectedErr: chain.ErrFailedToParseParentHeight, }, { @@ -142,7 +207,15 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), @@ -164,11 +237,29 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - newBlockF: validBlockF, + newBlockF: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( + ids.Empty, + genesis.NewDefaultRules().GetMinEmptyBlockGap(), + 1, + nil, + root, + ) + require.NoError(t, err) + return block + }, expectedErr: chain.ErrFailedToFetchParentTimestamp, }, { @@ -176,12 +267,30 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), []byte{})) return db }(), - newBlockF: validBlockF, + newBlockF: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( + ids.Empty, + genesis.NewDefaultRules().GetMinEmptyBlockGap(), + 1, + nil, + root, + ) + require.NoError(t, err) + return block + }, expectedErr: chain.ErrFailedToParseParentTimestamp, }, { @@ -189,7 +298,15 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db @@ -224,7 +341,15 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db @@ -247,12 +372,30 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) return db }(), - newBlockF: validBlockF, + newBlockF: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( + ids.Empty, + genesis.NewDefaultRules().GetMinEmptyBlockGap(), + 1, + nil, + root, + ) + require.NoError(t, err) + return block + }, expectedErr: chain.ErrFailedToFetchParentFee, }, { @@ -265,13 +408,31 @@ func TestProcessorExecute(t *testing.T) { workers: workers.NewSerial(), isNormalOp: true, db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) return db }(), - newBlockF: validBlockF, + newBlockF: func(root ids.ID) *chain.StatelessBlock { + block, err := chain.NewStatelessBlock( + ids.Empty, + genesis.NewDefaultRules().GetMinEmptyBlockGap(), + 1, + nil, + root, + ) + require.NoError(t, err) + return block + }, expectedErr: errMockVerifyExpiryReplayProtection, }, { @@ -279,7 +440,15 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) @@ -321,7 +490,15 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) @@ -345,7 +522,15 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), db: func() merkledb.MerkleDB { - db := dbF() + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + require.NoError(t, err) require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) require.NoError(t, db.Put([]byte(feeKey), []byte{})) From 0ef1f29624bc76c9bb3663b4d7bf43813544689c Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Thu, 30 Jan 2025 12:05:08 -0500 Subject: [PATCH 29/41] use single genesis rules --- chain/processor_test.go | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 81e8ff3665..f0c29cb594 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -41,6 +41,7 @@ var ( ) func TestProcessorExecute(t *testing.T) { + testRules := genesis.NewDefaultRules() tests := []struct { name string validityWindow chain.ValidityWindow @@ -72,7 +73,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, root, @@ -133,7 +134,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, root, @@ -162,7 +163,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, root, @@ -192,7 +193,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, root, @@ -222,7 +223,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 2, nil, parentRoot, @@ -252,7 +253,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, root, @@ -283,7 +284,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, root, @@ -388,7 +389,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, root, @@ -425,7 +426,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, root, @@ -457,7 +458,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, []*chain.Transaction{ func() *chain.Transaction { @@ -507,7 +508,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, nil, ids.GenerateTestID(), @@ -539,18 +540,18 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), 1, []*chain.Transaction{ func() *chain.Transaction { p, err := ed25519.GeneratePrivateKey() require.NoError(t, err) - testRules := genesis.NewDefaultRules() + testRules := testRules tx, err := chain.NewTransaction( &chain.Base{ Timestamp: utils.UnixRMilli( - genesis.NewDefaultRules().GetMinEmptyBlockGap(), + testRules.GetMinEmptyBlockGap(), testRules.GetValidityWindow(), ), }, @@ -583,7 +584,7 @@ func TestProcessorExecute(t *testing.T) { processor := chain.NewProcessor( trace.Noop, &logging.NoLog{}, - &genesis.ImmutableRuleFactory{Rules: genesis.NewDefaultRules()}, + &genesis.ImmutableRuleFactory{Rules: testRules}, tt.workers, &mockAuthVM{}, metadata.NewDefaultManager(), From fc22e506d2a6091cb2d32cd2a65d3abb0107d5ff Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Thu, 30 Jan 2025 12:59:18 -0500 Subject: [PATCH 30/41] replace db with view --- chain/processor_test.go | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index f0c29cb594..adfe49fbe7 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -47,7 +47,7 @@ func TestProcessorExecute(t *testing.T) { validityWindow chain.ValidityWindow workers workers.Workers isNormalOp bool - db merkledb.MerkleDB + view merkledb.View newBlockF func(ids.ID) *chain.StatelessBlock expectedErr error }{ @@ -55,7 +55,7 @@ func TestProcessorExecute(t *testing.T) { name: "valid test case", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -97,7 +97,7 @@ func TestProcessorExecute(t *testing.T) { require.NoError(t, err) return block }, - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -119,7 +119,7 @@ func TestProcessorExecute(t *testing.T) { w.Stop() return w }(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -148,7 +148,7 @@ func TestProcessorExecute(t *testing.T) { name: "failed to get parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -177,7 +177,7 @@ func TestProcessorExecute(t *testing.T) { name: "failed to parse parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -207,7 +207,7 @@ func TestProcessorExecute(t *testing.T) { name: "block height is not one more than parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -237,7 +237,7 @@ func TestProcessorExecute(t *testing.T) { name: "failed to get timestamp", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -267,7 +267,7 @@ func TestProcessorExecute(t *testing.T) { name: "failed to parse timestamp", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -298,7 +298,7 @@ func TestProcessorExecute(t *testing.T) { name: "non-empty block timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -341,7 +341,7 @@ func TestProcessorExecute(t *testing.T) { name: "empty block timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -372,7 +372,7 @@ func TestProcessorExecute(t *testing.T) { name: "failed to get fee", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -408,7 +408,7 @@ func TestProcessorExecute(t *testing.T) { }, workers: workers.NewSerial(), isNormalOp: true, - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -440,7 +440,7 @@ func TestProcessorExecute(t *testing.T) { name: "failed to execute txs", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -490,7 +490,7 @@ func TestProcessorExecute(t *testing.T) { name: "state root mismatch", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -522,7 +522,7 @@ func TestProcessorExecute(t *testing.T) { name: "failed to verify signatures", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), - db: func() merkledb.MerkleDB { + view: func() merkledb.View { db, err := merkledb.New( context.Background(), memdb.New(), @@ -594,12 +594,12 @@ func TestProcessorExecute(t *testing.T) { chain.NewDefaultConfig(), ) - root, err := tt.db.GetMerkleRoot(ctx) + root, err := tt.view.GetMerkleRoot(ctx) r.NoError(err) _, err = processor.Execute( ctx, - tt.db, + tt.view, chain.NewExecutionBlock(tt.newBlockF(root)), tt.isNormalOp, ) From 4b12eee19a70fade5461535dbb2b68d4c1e96d51 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Thu, 30 Jan 2025 15:57:53 -0500 Subject: [PATCH 31/41] add view helper function --- chain/processor_test.go | 251 ++++++++++++++-------------------------- 1 file changed, 90 insertions(+), 161 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index adfe49fbe7..0457217df8 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -56,19 +56,13 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(feeKey), []byte{})) - return db + return v }(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -98,16 +92,9 @@ func TestProcessorExecute(t *testing.T) { return block }, view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{}) require.NoError(t, err) - return db + return v }(), expectedErr: chain.ErrTimestampTooLate, }, @@ -120,16 +107,9 @@ func TestProcessorExecute(t *testing.T) { return w }(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{}) require.NoError(t, err) - return db + return v }(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -149,16 +129,9 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{}) require.NoError(t, err) - return db + return v }(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -178,17 +151,11 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: {}, + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), []byte{})) - return db + return v }(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -208,17 +175,11 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - return db + return v }(), newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -238,17 +199,11 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - return db + return v }(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -268,18 +223,12 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: {}, + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), []byte{})) - return db + return v }(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -299,18 +248,12 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) - return db + return v }(), newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -342,18 +285,12 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) - return db + return v }(), newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -373,18 +310,12 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) - return db + return v }(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -409,19 +340,13 @@ func TestProcessorExecute(t *testing.T) { workers: workers.NewSerial(), isNormalOp: true, view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(feeKey), []byte{})) - return db + return v }(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -441,19 +366,13 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(feeKey), []byte{})) - return db + return v }(), newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -491,19 +410,13 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(feeKey), []byte{})) - return db + return v }(), newBlockF: func(ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -523,19 +436,13 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { - db, err := merkledb.New( - context.Background(), - memdb.New(), - merkledb.Config{ - BranchFactor: merkledb.BranchFactor16, - Tracer: trace.Noop, - }, - ) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }) require.NoError(t, err) - require.NoError(t, db.Put([]byte(heightKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(timestampKey), binary.BigEndian.AppendUint64(nil, 0))) - require.NoError(t, db.Put([]byte(feeKey), []byte{})) - return db + return v }(), newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( @@ -608,6 +515,28 @@ func TestProcessorExecute(t *testing.T) { } } +func createTestView(mp map[string][]byte) (merkledb.View, error) { + db, err := merkledb.New( + context.Background(), + memdb.New(), + merkledb.Config{ + BranchFactor: merkledb.BranchFactor16, + Tracer: trace.Noop, + }, + ) + if err != nil { + return nil, err + } + + for key, value := range mp { + if err := db.Put([]byte(key), value); err != nil { + return nil, err + } + } + + return db, nil +} + type mockAuthVM struct{} func (*mockAuthVM) GetAuthBatchVerifier(uint8, int, int) (chain.AuthBatchVerifier, bool) { From c4aeff6439be3016c47843c770096450e3dfd15b Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Thu, 30 Jan 2025 15:58:49 -0500 Subject: [PATCH 32/41] nit --- chain/processor_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 0457217df8..5516a5c75e 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -99,7 +99,7 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrTimestampTooLate, }, { - name: "verify signatures fails", + name: "failed to start signature verification", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: func() workers.Workers { w := workers.NewParallel(0, 0) From f5036f544940086f3ded7dcf2cc84cc3f5bbd769 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Thu, 30 Jan 2025 16:00:05 -0500 Subject: [PATCH 33/41] nit --- chain/processor_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 5516a5c75e..4b452a51d2 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -432,7 +432,7 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrStateRootMismatch, }, { - name: "failed to verify signatures", + name: "invalid transaction signature", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, workers: workers.NewSerial(), view: func() merkledb.View { From 0040c01c72e893d47959e5493681b916509e3c08 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Thu, 30 Jan 2025 16:19:05 -0500 Subject: [PATCH 34/41] remove unnecessary workers --- chain/processor_test.go | 43 +---------------------------------------- 1 file changed, 1 insertion(+), 42 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 4b452a51d2..67f7d54d28 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -45,7 +45,6 @@ func TestProcessorExecute(t *testing.T) { tests := []struct { name string validityWindow chain.ValidityWindow - workers workers.Workers isNormalOp bool view merkledb.View newBlockF func(ids.ID) *chain.StatelessBlock @@ -54,7 +53,6 @@ func TestProcessorExecute(t *testing.T) { { name: "valid test case", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -79,7 +77,6 @@ func TestProcessorExecute(t *testing.T) { { name: "block timestamp too late", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), newBlockF: func(root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, @@ -98,36 +95,9 @@ func TestProcessorExecute(t *testing.T) { }(), expectedErr: chain.ErrTimestampTooLate, }, - { - name: "failed to start signature verification", - validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: func() workers.Workers { - w := workers.NewParallel(0, 0) - w.Stop() - return w - }(), - view: func() merkledb.View { - v, err := createTestView(map[string][]byte{}) - require.NoError(t, err) - return v - }(), - newBlockF: func(root ids.ID) *chain.StatelessBlock { - block, err := chain.NewStatelessBlock( - ids.Empty, - testRules.GetMinEmptyBlockGap(), - 1, - nil, - root, - ) - require.NoError(t, err) - return block - }, - expectedErr: workers.ErrShutdown, - }, { name: "failed to get parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{}) require.NoError(t, err) @@ -149,7 +119,6 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to parse parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: {}, @@ -173,7 +142,6 @@ func TestProcessorExecute(t *testing.T) { { name: "block height is not one more than parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -197,7 +165,6 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to get timestamp", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -221,7 +188,6 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to parse timestamp", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -246,7 +212,6 @@ func TestProcessorExecute(t *testing.T) { { name: "non-empty block timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -283,7 +248,6 @@ func TestProcessorExecute(t *testing.T) { { name: "empty block timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -308,7 +272,6 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to get fee", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -337,7 +300,6 @@ func TestProcessorExecute(t *testing.T) { return errMockVerifyExpiryReplayProtection }, }, - workers: workers.NewSerial(), isNormalOp: true, view: func() merkledb.View { v, err := createTestView(map[string][]byte{ @@ -364,7 +326,6 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to execute txs", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -408,7 +369,6 @@ func TestProcessorExecute(t *testing.T) { { name: "state root mismatch", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -434,7 +394,6 @@ func TestProcessorExecute(t *testing.T) { { name: "invalid transaction signature", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - workers: workers.NewSerial(), view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), @@ -492,7 +451,7 @@ func TestProcessorExecute(t *testing.T) { trace.Noop, &logging.NoLog{}, &genesis.ImmutableRuleFactory{Rules: testRules}, - tt.workers, + workers.NewSerial(), &mockAuthVM{}, metadata.NewDefaultManager(), &mockBalanceHandler{}, From 5844161e25b78af6833df31373991ca9a77b0af7 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Fri, 7 Feb 2025 09:41:05 -0500 Subject: [PATCH 35/41] add block ctx --- chain/processor_test.go | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/chain/processor_test.go b/chain/processor_test.go index 67f7d54d28..ec563c83e1 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -12,6 +12,7 @@ import ( "github.com/ava-labs/avalanchego/database/memdb" "github.com/ava-labs/avalanchego/ids" + "github.com/ava-labs/avalanchego/snow/engine/snowman/block" "github.com/ava-labs/avalanchego/trace" "github.com/ava-labs/avalanchego/utils/logging" "github.com/ava-labs/avalanchego/x/merkledb" @@ -69,6 +70,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, root, + &block.Context{}, ) require.NoError(t, err) return block @@ -84,6 +86,7 @@ func TestProcessorExecute(t *testing.T) { 0, nil, root, + &block.Context{}, ) require.NoError(t, err) return block @@ -110,6 +113,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, root, + &block.Context{}, ) require.NoError(t, err) return block @@ -133,6 +137,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, root, + &block.Context{}, ) require.NoError(t, err) return block @@ -156,6 +161,7 @@ func TestProcessorExecute(t *testing.T) { 2, nil, parentRoot, + &block.Context{}, ) require.NoError(t, err) return block @@ -179,6 +185,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, root, + &block.Context{}, ) require.NoError(t, err) return block @@ -203,6 +210,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, root, + &block.Context{}, ) require.NoError(t, err) return block @@ -239,6 +247,7 @@ func TestProcessorExecute(t *testing.T) { }(), }, parentRoot, + &block.Context{}, ) require.NoError(t, err) return block @@ -263,6 +272,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, parentRoot, + &block.Context{}, ) require.NoError(t, err) return block @@ -287,6 +297,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, root, + &block.Context{}, ) require.NoError(t, err) return block @@ -317,6 +328,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, root, + &block.Context{}, ) require.NoError(t, err) return block @@ -360,6 +372,7 @@ func TestProcessorExecute(t *testing.T) { }(), }, parentRoot, + &block.Context{}, ) require.NoError(t, err) return block @@ -385,6 +398,7 @@ func TestProcessorExecute(t *testing.T) { 1, nil, ids.GenerateTestID(), + &block.Context{}, ) require.NoError(t, err) return block @@ -431,6 +445,7 @@ func TestProcessorExecute(t *testing.T) { }(), }, parentRoot, + &block.Context{}, ) require.NoError(t, err) return block From dae8bde86d47b2c5bc3cf04fbfc23f7171d613c3 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Fri, 7 Feb 2025 10:05:12 -0500 Subject: [PATCH 36/41] tests fail for exact reason --- chain/processor_test.go | 27 +++++++++++++++++++++------ 1 file changed, 21 insertions(+), 6 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index ec563c83e1..2509af56b9 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -92,7 +92,11 @@ func TestProcessorExecute(t *testing.T) { return block }, view: func() merkledb.View { - v, err := createTestView(map[string][]byte{}) + v, err := createTestView(map[string][]byte{ + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }) require.NoError(t, err) return v }(), @@ -102,7 +106,10 @@ func TestProcessorExecute(t *testing.T) { name: "failed to get parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, view: func() merkledb.View { - v, err := createTestView(map[string][]byte{}) + v, err := createTestView(map[string][]byte{ + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, + }) require.NoError(t, err) return v }(), @@ -125,7 +132,9 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, view: func() merkledb.View { v, err := createTestView(map[string][]byte{ - heightKey: {}, + heightKey: {}, + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, }) require.NoError(t, err) return v @@ -149,7 +158,9 @@ func TestProcessorExecute(t *testing.T) { validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, view: func() merkledb.View { v, err := createTestView(map[string][]byte{ - heightKey: binary.BigEndian.AppendUint64(nil, 0), + heightKey: binary.BigEndian.AppendUint64(nil, 0), + timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, }) require.NoError(t, err) return v @@ -174,6 +185,7 @@ func TestProcessorExecute(t *testing.T) { view: func() merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, }) require.NoError(t, err) return v @@ -199,6 +211,7 @@ func TestProcessorExecute(t *testing.T) { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: {}, + feeKey: {}, }) require.NoError(t, err) return v @@ -224,6 +237,7 @@ func TestProcessorExecute(t *testing.T) { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, }) require.NoError(t, err) return v @@ -261,6 +275,7 @@ func TestProcessorExecute(t *testing.T) { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), + feeKey: {}, }) require.NoError(t, err) return v @@ -350,7 +365,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - testRules.GetMinEmptyBlockGap(), + testRules.GetMinBlockGap(), 1, []*chain.Transaction{ func() *chain.Transaction { @@ -420,7 +435,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - testRules.GetMinEmptyBlockGap(), + testRules.GetMinBlockGap(), 1, []*chain.Transaction{ func() *chain.Transaction { From 4ca4ebfe657c65a92d6b82e3a98eda8401608737 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Fri, 7 Feb 2025 10:21:33 -0500 Subject: [PATCH 37/41] create tx separate from block --- chain/processor_test.go | 104 +++++++++++++++++++--------------------- 1 file changed, 50 insertions(+), 54 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 2509af56b9..a9bfd57f9d 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -243,23 +243,23 @@ func TestProcessorExecute(t *testing.T) { return v }(), newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { + tx, err := chain.NewTransaction( + &chain.Base{ + Timestamp: utils.UnixRMilli( + testRules.GetMinEmptyBlockGap(), + testRules.GetValidityWindow(), + ), + }, + []chain.Action{}, + &mockAuth{typeID: 1}, + ) + require.NoError(t, err) + block, err := chain.NewStatelessBlock( ids.Empty, 0, 1, - []*chain.Transaction{ - func() *chain.Transaction { - tx, err := chain.NewTransaction( - &chain.Base{}, - []chain.Action{}, - &mockAuth{ - typeID: 1, - }, - ) - require.NoError(t, err) - return tx - }(), - }, + []*chain.Transaction{tx}, parentRoot, &block.Context{}, ) @@ -363,29 +363,29 @@ func TestProcessorExecute(t *testing.T) { return v }(), newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { + tx, err := chain.NewTransaction( + &chain.Base{ + Timestamp: utils.UnixRMilli( + testRules.GetMinEmptyBlockGap(), + testRules.GetValidityWindow(), + ), + }, + []chain.Action{ + &mockAction{ + stateKeys: state.Keys{ + "": state.None, + }, + }, + }, + &mockAuth{typeID: 1}, + ) + require.NoError(t, err) + block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinBlockGap(), 1, - []*chain.Transaction{ - func() *chain.Transaction { - tx, err := chain.NewTransaction( - &chain.Base{}, - []chain.Action{ - &mockAction{ - stateKeys: state.Keys{ - "": state.None, - }, - }, - }, - &mockAuth{ - typeID: 1, - }, - ) - require.NoError(t, err) - return tx - }(), - }, + []*chain.Transaction{tx}, parentRoot, &block.Context{}, ) @@ -433,32 +433,28 @@ func TestProcessorExecute(t *testing.T) { return v }(), newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { + p, err := ed25519.GeneratePrivateKey() + require.NoError(t, err) + + tx, err := chain.NewTransaction( + &chain.Base{ + Timestamp: utils.UnixRMilli( + testRules.GetMinEmptyBlockGap(), + testRules.GetValidityWindow(), + ), + }, + []chain.Action{}, + &auth.ED25519{ + Signer: p.PublicKey(), + }, + ) + require.NoError(t, err) + block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinBlockGap(), 1, - []*chain.Transaction{ - func() *chain.Transaction { - p, err := ed25519.GeneratePrivateKey() - require.NoError(t, err) - - testRules := testRules - tx, err := chain.NewTransaction( - &chain.Base{ - Timestamp: utils.UnixRMilli( - testRules.GetMinEmptyBlockGap(), - testRules.GetValidityWindow(), - ), - }, - []chain.Action{}, - &auth.ED25519{ - Signer: p.PublicKey(), - }, - ) - require.NoError(t, err) - return tx - }(), - }, + []*chain.Transaction{tx}, parentRoot, &block.Context{}, ) From 9f50828c7ecff3341a4e456f6c47a061c8c7973f Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Fri, 7 Feb 2025 11:26:29 -0500 Subject: [PATCH 38/41] use subtest assertions --- chain/processor_test.go | 161 ++++++++++++++++++++-------------------- 1 file changed, 82 insertions(+), 79 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index a9bfd57f9d..74b69d5f46 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -47,23 +47,23 @@ func TestProcessorExecute(t *testing.T) { name string validityWindow chain.ValidityWindow isNormalOp bool - view merkledb.View - newBlockF func(ids.ID) *chain.StatelessBlock + newViewF func(*require.Assertions) merkledb.View + newBlockF func(*require.Assertions, ids.ID) *chain.StatelessBlock expectedErr error }{ { name: "valid test case", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(root ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -72,14 +72,14 @@ func TestProcessorExecute(t *testing.T) { root, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, }, { name: "block timestamp too late", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - newBlockF: func(root ids.ID) *chain.StatelessBlock { + newBlockF: func(r *require.Assertions, root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, time.Now().Add(2*chain.FutureBound).UnixMilli(), @@ -88,32 +88,32 @@ func TestProcessorExecute(t *testing.T) { root, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), + }, expectedErr: chain.ErrTimestampTooLate, }, { name: "failed to get parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(root ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -122,7 +122,7 @@ func TestProcessorExecute(t *testing.T) { root, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrFailedToFetchParentHeight, @@ -130,16 +130,16 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to parse parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: {}, timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(root ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -148,7 +148,7 @@ func TestProcessorExecute(t *testing.T) { root, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrFailedToParseParentHeight, @@ -156,16 +156,16 @@ func TestProcessorExecute(t *testing.T) { { name: "block height is not one more than parent height", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -174,7 +174,7 @@ func TestProcessorExecute(t *testing.T) { parentRoot, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrInvalidBlockHeight, @@ -182,15 +182,15 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to get timestamp", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(root ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -199,7 +199,7 @@ func TestProcessorExecute(t *testing.T) { root, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrFailedToFetchParentTimestamp, @@ -207,16 +207,16 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to parse timestamp", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: {}, feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(root ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -225,7 +225,7 @@ func TestProcessorExecute(t *testing.T) { root, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrFailedToParseParentTimestamp, @@ -233,16 +233,16 @@ func TestProcessorExecute(t *testing.T) { { name: "non-empty block timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, parentRoot ids.ID) *chain.StatelessBlock { tx, err := chain.NewTransaction( &chain.Base{ Timestamp: utils.UnixRMilli( @@ -253,7 +253,7 @@ func TestProcessorExecute(t *testing.T) { []chain.Action{}, &mockAuth{typeID: 1}, ) - require.NoError(t, err) + r.NoError(err) block, err := chain.NewStatelessBlock( ids.Empty, @@ -263,7 +263,7 @@ func TestProcessorExecute(t *testing.T) { parentRoot, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrTimestampTooEarly, @@ -271,16 +271,16 @@ func TestProcessorExecute(t *testing.T) { { name: "empty block timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, 0, @@ -289,7 +289,7 @@ func TestProcessorExecute(t *testing.T) { parentRoot, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrTimestampTooEarly, @@ -297,15 +297,15 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to get fee", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(root ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -314,7 +314,7 @@ func TestProcessorExecute(t *testing.T) { root, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrFailedToFetchParentFee, @@ -327,16 +327,16 @@ func TestProcessorExecute(t *testing.T) { }, }, isNormalOp: true, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(root ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, root ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -345,7 +345,7 @@ func TestProcessorExecute(t *testing.T) { root, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: errMockVerifyExpiryReplayProtection, @@ -353,16 +353,16 @@ func TestProcessorExecute(t *testing.T) { { name: "failed to execute txs", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, parentRoot ids.ID) *chain.StatelessBlock { tx, err := chain.NewTransaction( &chain.Base{ Timestamp: utils.UnixRMilli( @@ -379,7 +379,7 @@ func TestProcessorExecute(t *testing.T) { }, &mockAuth{typeID: 1}, ) - require.NoError(t, err) + r.NoError(err) block, err := chain.NewStatelessBlock( ids.Empty, @@ -389,7 +389,7 @@ func TestProcessorExecute(t *testing.T) { parentRoot, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrInvalidKeyValue, @@ -397,16 +397,16 @@ func TestProcessorExecute(t *testing.T) { { name: "state root mismatch", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, _ ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, testRules.GetMinEmptyBlockGap(), @@ -415,7 +415,7 @@ func TestProcessorExecute(t *testing.T) { ids.GenerateTestID(), &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: chain.ErrStateRootMismatch, @@ -423,18 +423,18 @@ func TestProcessorExecute(t *testing.T) { { name: "invalid transaction signature", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, - view: func() merkledb.View { + newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ heightKey: binary.BigEndian.AppendUint64(nil, 0), timestampKey: binary.BigEndian.AppendUint64(nil, 0), feeKey: {}, }) - require.NoError(t, err) + r.NoError(err) return v - }(), - newBlockF: func(parentRoot ids.ID) *chain.StatelessBlock { + }, + newBlockF: func(r *require.Assertions, parentRoot ids.ID) *chain.StatelessBlock { p, err := ed25519.GeneratePrivateKey() - require.NoError(t, err) + r.NoError(err) tx, err := chain.NewTransaction( &chain.Base{ @@ -448,7 +448,7 @@ func TestProcessorExecute(t *testing.T) { Signer: p.PublicKey(), }, ) - require.NoError(t, err) + r.NoError(err) block, err := chain.NewStatelessBlock( ids.Empty, @@ -458,7 +458,7 @@ func TestProcessorExecute(t *testing.T) { parentRoot, &block.Context{}, ) - require.NoError(t, err) + r.NoError(err) return block }, expectedErr: crypto.ErrInvalidSignature, @@ -486,13 +486,16 @@ func TestProcessorExecute(t *testing.T) { chain.NewDefaultConfig(), ) - root, err := tt.view.GetMerkleRoot(ctx) + view := tt.newViewF(r) + root, err := view.GetMerkleRoot(ctx) r.NoError(err) + block := tt.newBlockF(r, root) + _, err = processor.Execute( ctx, - tt.view, - chain.NewExecutionBlock(tt.newBlockF(root)), + view, + chain.NewExecutionBlock(block), tt.isNormalOp, ) r.ErrorIs(err, tt.expectedErr) From 2d3bf36a618164b0a9950e30ef48fb09e028fadf Mon Sep 17 00:00:00 2001 From: rodrigo <77309055+RodrigoVillar@users.noreply.github.com> Date: Fri, 28 Feb 2025 12:33:43 -0500 Subject: [PATCH 39/41] Update chain/processor_test.go Co-authored-by: aaronbuchwald Signed-off-by: rodrigo <77309055+RodrigoVillar@users.noreply.github.com> --- chain/processor_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 74b69d5f46..41b4e64e70 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -231,7 +231,7 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrFailedToParseParentTimestamp, }, { - name: "non-empty block timestamp less than parent timestamp with gap", + name: "non-empty block - timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ From 73453ccc9f7b8112749b3d7affbbc55350bcab4c Mon Sep 17 00:00:00 2001 From: rodrigo <77309055+RodrigoVillar@users.noreply.github.com> Date: Fri, 28 Feb 2025 12:34:05 -0500 Subject: [PATCH 40/41] Update chain/processor_test.go Co-authored-by: aaronbuchwald Signed-off-by: rodrigo <77309055+RodrigoVillar@users.noreply.github.com> --- chain/processor_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 41b4e64e70..38f88a7191 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -269,7 +269,7 @@ func TestProcessorExecute(t *testing.T) { expectedErr: chain.ErrTimestampTooEarly, }, { - name: "empty block timestamp less than parent timestamp with gap", + name: "empty block - timestamp less than parent timestamp with gap", validityWindow: &validitywindowtest.MockTimeValidityWindow[*chain.Transaction]{}, newViewF: func(r *require.Assertions) merkledb.View { v, err := createTestView(map[string][]byte{ From a5ba2630a5ad39bfa728612417c22d0b3ceb3da5 Mon Sep 17 00:00:00 2001 From: Rodrigo Villar Date: Fri, 28 Feb 2025 12:49:03 -0500 Subject: [PATCH 41/41] nit --- chain/processor_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/chain/processor_test.go b/chain/processor_test.go index 38f88a7191..ca466edcbc 100644 --- a/chain/processor_test.go +++ b/chain/processor_test.go @@ -257,7 +257,7 @@ func TestProcessorExecute(t *testing.T) { block, err := chain.NewStatelessBlock( ids.Empty, - 0, + testRules.GetMinBlockGap()-1, 1, []*chain.Transaction{tx}, parentRoot, @@ -283,7 +283,7 @@ func TestProcessorExecute(t *testing.T) { newBlockF: func(r *require.Assertions, parentRoot ids.ID) *chain.StatelessBlock { block, err := chain.NewStatelessBlock( ids.Empty, - 0, + testRules.GetMinEmptyBlockGap()-1, 1, nil, parentRoot, @@ -292,7 +292,7 @@ func TestProcessorExecute(t *testing.T) { r.NoError(err) return block }, - expectedErr: chain.ErrTimestampTooEarly, + expectedErr: chain.ErrTimestampTooEarlyEmptyBlock, }, { name: "failed to get fee",