From 5cd4263f571a1ee142653325e3379c338e93988a Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 18 Jul 2022 12:11:39 +0530 Subject: [PATCH 01/49] temp --- lib/babe/epoch_handler.go | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/babe/epoch_handler.go b/lib/babe/epoch_handler.go index b2cde8af8c..7648b405ce 100644 --- a/lib/babe/epoch_handler.go +++ b/lib/babe/epoch_handler.go @@ -135,6 +135,7 @@ func (h *epochHandler) run(ctx context.Context, errCh chan<- error) { panic(fmt.Sprintf("no VRF proof for authoring slot! slot=%d", swt.slotNum)) } + logger.Infof("handling slot %d", swt.slotNum) err := h.handleSlot(h.epochNumber, swt.slotNum, h.epochData.authorityIndex, h.slotToPreRuntimeDigest[swt.slotNum]) if err != nil { logger.Warnf("failed to handle slot %d: %s", swt.slotNum, err) From f57fa84b9d71224a18c6775acdf072244f93fe39 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 18 Jul 2022 21:10:15 +0530 Subject: [PATCH 02/49] temp --- dot/state/epoch.go | 1 + 1 file changed, 1 insertion(+) diff --git a/dot/state/epoch.go b/dot/state/epoch.go index 0b5ab5db83..c83e6195a8 100644 --- a/dot/state/epoch.go +++ b/dot/state/epoch.go @@ -264,6 +264,7 @@ func (s *EpochState) GetEpochData(epoch uint64, header *types.Header) (*types.Ep s.nextEpochDataLock.RLock() defer s.nextEpochDataLock.RUnlock() + // here inMemoryEpochData, err := s.nextEpochData.Retrieve(s.blockState, epoch, header) if err != nil { return nil, fmt.Errorf("failed to get epoch data from memory: %w", err) From 12fde0bf795afa6b42c50417629ddc600a0e9901 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 3 Aug 2022 19:04:02 +0800 Subject: [PATCH 03/49] temp --- lib/babe/babe.go | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index d0dd5fa4e7..8b991b29f4 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -497,6 +497,20 @@ func (b *Service) handleSlot(epoch, slotNum uint64, return err } + slotNumOfTheBestBlock, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) + if err != nil { + return err + } + + // When can this happen, + // - inconsistency in slot calculation, like may be rust code and go code running simultaneously, + // it does not produce the same slot number. Otherwise, why would I have a block for a slot number + // that is ongoing? + // - Also, should I even accept a block for the ongoing slot number? I feel like noce + if slotNumOfTheBestBlock == slotNum { + + } + if parentHeader == nil { return errNilParentHeader } From ae2fa69833c0938adc55425b33c458c3ae7531e2 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Thu, 4 Aug 2022 20:15:44 +0530 Subject: [PATCH 04/49] While authoring a new block, if we find that best block was authored in the current slot, we should author a new block as child of best block's parent. This would create forks in the chain which would get resolved eventually. --- lib/babe/babe.go | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index 8b991b29f4..1716f68424 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -502,13 +502,14 @@ func (b *Service) handleSlot(epoch, slotNum uint64, return err } - // When can this happen, - // - inconsistency in slot calculation, like may be rust code and go code running simultaneously, - // it does not produce the same slot number. Otherwise, why would I have a block for a slot number - // that is ongoing? - // - Also, should I even accept a block for the ongoing slot number? I feel like noce if slotNumOfTheBestBlock == slotNum { + // pick parent of best block instead to handle slot + newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash) + if err != nil { + return err + } + parentHeader = newParentHeader } if parentHeader == nil { From cc2ffaf477e4f17c4a4b23e22f42a5ad1699e620 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Thu, 4 Aug 2022 20:25:46 +0530 Subject: [PATCH 05/49] clean up --- dot/state/epoch.go | 1 - lib/babe/babe.go | 4 ++-- lib/babe/epoch_handler.go | 1 - 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/dot/state/epoch.go b/dot/state/epoch.go index c83e6195a8..0b5ab5db83 100644 --- a/dot/state/epoch.go +++ b/dot/state/epoch.go @@ -264,7 +264,6 @@ func (s *EpochState) GetEpochData(epoch uint64, header *types.Header) (*types.Ep s.nextEpochDataLock.RLock() defer s.nextEpochDataLock.RUnlock() - // here inMemoryEpochData, err := s.nextEpochData.Retrieve(s.blockState, epoch, header) if err != nil { return nil, fmt.Errorf("failed to get epoch data from memory: %w", err) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index 1716f68424..4fd8c68009 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -499,14 +499,14 @@ func (b *Service) handleSlot(epoch, slotNum uint64, slotNumOfTheBestBlock, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) if err != nil { - return err + return fmt.Errorf("could not get slot for block %s: %w", parentHeader.Hash(), err) } if slotNumOfTheBestBlock == slotNum { // pick parent of best block instead to handle slot newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash) if err != nil { - return err + return fmt.Errorf("could not get header for hash %s: %w", parentHeader.ParentHash, err) } parentHeader = newParentHeader diff --git a/lib/babe/epoch_handler.go b/lib/babe/epoch_handler.go index 706245fd61..52e75ba3dd 100644 --- a/lib/babe/epoch_handler.go +++ b/lib/babe/epoch_handler.go @@ -135,7 +135,6 @@ func (h *epochHandler) run(ctx context.Context, errCh chan<- error) { panic(fmt.Sprintf("no VRF proof for authoring slot! slot=%d", swt.slotNum)) } - logger.Infof("handling slot %d", swt.slotNum) err := h.handleSlot(h.epochNumber, swt.slotNum, h.epochData.authorityIndex, h.slotToPreRuntimeDigest[swt.slotNum]) if err != nil { logger.Warnf("failed to handle slot %d: %s", swt.slotNum, err) From cbc44d2ca03e07342023a59b7beecf2f5be555be Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Fri, 5 Aug 2022 20:59:30 +0530 Subject: [PATCH 06/49] add a check for current slot is greater than slot in best block --- lib/babe/babe.go | 8 ++++++-- lib/babe/errors.go | 1 + 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index 4fd8c68009..e4b8b65c8f 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -497,12 +497,16 @@ func (b *Service) handleSlot(epoch, slotNum uint64, return err } - slotNumOfTheBestBlock, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) + bestBlockSlotNum, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) if err != nil { return fmt.Errorf("could not get slot for block %s: %w", parentHeader.Hash(), err) } - if slotNumOfTheBestBlock == slotNum { + if bestBlockSlotNum > slotNum { + return errLaggingSlot + } + + if bestBlockSlotNum == slotNum { // pick parent of best block instead to handle slot newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash) if err != nil { diff --git a/lib/babe/errors.go b/lib/babe/errors.go index 670f85dcf1..4548ed3a3b 100644 --- a/lib/babe/errors.go +++ b/lib/babe/errors.go @@ -78,6 +78,7 @@ var ( errInvalidSlotTechnique = errors.New("invalid slot claiming technique") errNoBABEAuthorityKeyProvided = errors.New("cannot create BABE service as authority; no keypair provided") errLastDigestItemNotSeal = errors.New("last digest item is not seal") + errLaggingSlot = errors.New("cannot claim slot, current slot is smaller than slot of best block") other Other invalidCustom InvalidCustom From 3de132f4f7b0c5b85892205ee0aede1244130244 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Tue, 16 Aug 2022 15:20:01 +0530 Subject: [PATCH 07/49] test for err slot lagging --- lib/babe/babe_integration_test.go | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index ec5d31a0b6..550ea9cac4 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -301,3 +301,30 @@ func TestService_PauseAndResume(t *testing.T) { err = bs.Stop() require.NoError(t, err) } + +func TestService_HandleSlotWithSameSlot(t *testing.T) { + cfg := &ServiceConfig{ + Authority: true, + Lead: true, + } + babeService := createTestService(t, cfg) + + err := babeService.Start() + require.NoError(t, err) + defer func() { + _ = babeService.Stop() + }() + + time.Sleep(babeService.constants.slotDuration * 2) + + header, err := babeService.blockState.BestBlockHeader() + require.NoError(t, err) + + bestBlockSlotNum, err := babeService.blockState.GetSlotForBlock(header.Hash()) + require.NoError(t, err) + + // todo: create predigest + var preRuntimeDigest *types.PreRuntimeDigest + err = babeService.handleSlot(babeService.epochHandler.epochNumber, bestBlockSlotNum-1, babeService.epochHandler.epochData.authorityIndex, preRuntimeDigest) + require.ErrorAs(t, err, errLaggingSlot) +} From a63a0739800f6ec0ade711229d287021ce60c764 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 17 Aug 2022 14:48:11 +0530 Subject: [PATCH 08/49] test --- lib/babe/babe_integration_test.go | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 550ea9cac4..95f71ebc47 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -323,8 +323,20 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { bestBlockSlotNum, err := babeService.blockState.GetSlotForBlock(header.Hash()) require.NoError(t, err) - // todo: create predigest - var preRuntimeDigest *types.PreRuntimeDigest + slotnum := uint64(1) + slot := Slot{ + start: time.Now(), + duration: 1 * time.Second, + number: slotnum, + } + testVRFOutputAndProof := &VrfOutputAndProof{} + preRuntimeDigest, err := types.NewBabePrimaryPreDigest( + 0, slot.number, + testVRFOutputAndProof.output, + testVRFOutputAndProof.proof, + ).ToPreRuntimeDigest() + require.NoError(t, err) + err = babeService.handleSlot(babeService.epochHandler.epochNumber, bestBlockSlotNum-1, babeService.epochHandler.epochData.authorityIndex, preRuntimeDigest) require.ErrorAs(t, err, errLaggingSlot) } From aca3b683ef2ebf9be1639acad1441e66a3c444a2 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 17 Aug 2022 20:41:16 +0530 Subject: [PATCH 09/49] fix test for errLaggingSlot --- lib/babe/babe_integration_test.go | 26 +++++++++++++++++++++++--- lib/genesis/test_utils.go | 17 ++++++++++++++++- 2 files changed, 39 insertions(+), 4 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 95f71ebc47..eb009aec46 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -15,6 +15,7 @@ import ( "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/internal/log" "github.com/ChainSafe/gossamer/lib/babe/mocks" + "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/crypto/sr25519" "github.com/ChainSafe/gossamer/lib/genesis" "github.com/ChainSafe/gossamer/lib/runtime" @@ -315,7 +316,20 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { _ = babeService.Stop() }() - time.Sleep(babeService.constants.slotDuration * 2) + // add a block + parentHash := babeService.blockState.GenesisHash() + rt, err := babeService.blockState.GetRuntime(nil) + require.NoError(t, err) + + epochData, err := babeService.initiateEpoch(testEpochIndex) + require.NoError(t, err) + + ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd}) + block := createTestBlock(t, babeService, emptyHeader, [][]byte{common.MustHexToBytes(ext)}, + 1, testEpochIndex, epochData) + + babeService.blockState.AddBlock(block) + time.Sleep(babeService.constants.slotDuration * 10) header, err := babeService.blockState.BestBlockHeader() require.NoError(t, err) @@ -335,8 +349,14 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { testVRFOutputAndProof.output, testVRFOutputAndProof.proof, ).ToPreRuntimeDigest() + require.NoError(t, err) - err = babeService.handleSlot(babeService.epochHandler.epochNumber, bestBlockSlotNum-1, babeService.epochHandler.epochData.authorityIndex, preRuntimeDigest) - require.ErrorAs(t, err, errLaggingSlot) + err = babeService.handleSlot( + babeService.epochHandler.epochNumber, + bestBlockSlotNum-1, + babeService.epochHandler.epochData.authorityIndex, + preRuntimeDigest) + + require.ErrorIs(t, err, errLaggingSlot) } diff --git a/lib/genesis/test_utils.go b/lib/genesis/test_utils.go index 418d743d33..7fb94428dc 100644 --- a/lib/genesis/test_utils.go +++ b/lib/genesis/test_utils.go @@ -13,6 +13,7 @@ import ( "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/trie" "github.com/ChainSafe/gossamer/lib/utils" + "github.com/ChainSafe/gossamer/pkg/scale" "github.com/stretchr/testify/require" ) @@ -100,8 +101,22 @@ func newGenesisTrieAndHeader(t *testing.T, gen *Genesis) (*trie.Trie, *types.Hea genTrie, err := NewTrieFromGenesis(gen) require.NoError(t, err) + babeDigest := types.NewBabeDigest() + err = babeDigest.Set(types.BabePrimaryPreDigest{AuthorityIndex: 0}) + require.NoError(t, err) + + bdEnc, err := scale.Marshal(babeDigest) + require.NoError(t, err) + + digest := types.NewDigest() + err = digest.Add(types.PreRuntimeDigest{ + ConsensusEngineID: types.BabeEngineID, + Data: bdEnc, + }) + require.NoError(t, err) + genesisHeader, err := types.NewHeader(common.NewHash([]byte{0}), - genTrie.MustHash(), trie.EmptyHash, 0, types.NewDigest()) + genTrie.MustHash(), trie.EmptyHash, 0, digest) require.NoError(t, err) return genTrie, genesisHeader From 9c9f47b61883410140666f87758c1c55823d261f Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 17 Aug 2022 21:00:08 +0530 Subject: [PATCH 10/49] test that we create a fork if best block is authored in the same slot that we are claiming at the moment --- lib/babe/babe_integration_test.go | 65 ++++++++++++++++++++++++++++++- 1 file changed, 64 insertions(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index eb009aec46..0b03489b98 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -303,7 +303,7 @@ func TestService_PauseAndResume(t *testing.T) { require.NoError(t, err) } -func TestService_HandleSlotWithSameSlot(t *testing.T) { +func TestService_HandleSlotWithLaggingSlot(t *testing.T) { cfg := &ServiceConfig{ Authority: true, Lead: true, @@ -360,3 +360,66 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { require.ErrorIs(t, err, errLaggingSlot) } + +func TestService_HandleSlotWithSameSlot(t *testing.T) { + cfg := &ServiceConfig{ + Authority: true, + Lead: true, + } + babeService := createTestService(t, cfg) + + err := babeService.Start() + require.NoError(t, err) + defer func() { + _ = babeService.Stop() + }() + + // add a block + parentHash := babeService.blockState.GenesisHash() + rt, err := babeService.blockState.GetRuntime(nil) + require.NoError(t, err) + + epochData, err := babeService.initiateEpoch(testEpochIndex) + require.NoError(t, err) + + ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd}) + block := createTestBlock(t, babeService, emptyHeader, [][]byte{common.MustHexToBytes(ext)}, + 1, testEpochIndex, epochData) + + babeService.blockState.AddBlock(block) + time.Sleep(babeService.constants.slotDuration * 10) + + bestBlockHeader, err := babeService.blockState.BestBlockHeader() + require.NoError(t, err) + + bestBlockSlotNum, err := babeService.blockState.GetSlotForBlock(bestBlockHeader.Hash()) + require.NoError(t, err) + + slotnum := uint64(1) + slot := Slot{ + start: time.Now(), + duration: 1 * time.Second, + number: slotnum, + } + testVRFOutputAndProof := &VrfOutputAndProof{} + preRuntimeDigest, err := types.NewBabePrimaryPreDigest( + 0, slot.number, + testVRFOutputAndProof.output, + testVRFOutputAndProof.proof, + ).ToPreRuntimeDigest() + + require.NoError(t, err) + + err = babeService.handleSlot( + babeService.epochHandler.epochNumber, + bestBlockSlotNum, + babeService.epochHandler.epochData.authorityIndex, + preRuntimeDigest) + + require.NoError(t, err) + + // test that newly created block is sibling of bestBlockHeader + siblings := babeService.blockState.GetAllBlocksAtDepth(bestBlockHeader.ParentHash) + require.GreaterOrEqual(t, len(siblings), 2) + require.Contains(t, bestBlockHeader.Hash(), siblings) +} From 527f51534db2b86d4f105ad433eefc60687625ca Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 22 Aug 2022 22:17:24 +0530 Subject: [PATCH 11/49] temp --- lib/babe/babe.go | 36 ++++++++++++++++++------------- lib/babe/babe_integration_test.go | 13 ++++++++--- 2 files changed, 31 insertions(+), 18 deletions(-) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index e4b8b65c8f..72a0fc604f 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -497,27 +497,32 @@ func (b *Service) handleSlot(epoch, slotNum uint64, return err } - bestBlockSlotNum, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) - if err != nil { - return fmt.Errorf("could not get slot for block %s: %w", parentHeader.Hash(), err) - } - - if bestBlockSlotNum > slotNum { - return errLaggingSlot + if parentHeader == nil { + return errNilParentHeader } - if bestBlockSlotNum == slotNum { - // pick parent of best block instead to handle slot - newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash) + atGenesisBlock := b.blockState.GenesisHash().Equal(parentHeader.Hash()) + if !atGenesisBlock { + bestBlockSlotNum, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) if err != nil { - return fmt.Errorf("could not get header for hash %s: %w", parentHeader.ParentHash, err) + return fmt.Errorf("could not get slot for block %s: %w", parentHeader.Hash(), err) } - parentHeader = newParentHeader - } + if bestBlockSlotNum > slotNum { + return errLaggingSlot + } - if parentHeader == nil { - return errNilParentHeader + if bestBlockSlotNum == slotNum { + // pick parent of best block instead to handle slot + newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash) + if err != nil { + return fmt.Errorf("could not get header for hash %s: %w", parentHeader.ParentHash, err) + } + if newParentHeader == nil { + return errNilParentHeader + } + parentHeader = newParentHeader + } } // there is a chance that the best block header may change in the course of building the block, @@ -557,6 +562,7 @@ func (b *Service) handleSlot(epoch, slotNum uint64, return err } + fmt.Printf("block %s\nblock number %d\n\n", block.Header.Hash(), block.Header.Number) logger.Infof( "built block %d with hash %s, state root %s, epoch %d and slot %d", block.Header.Number, block.Header.Hash(), block.Header.StateRoot, epoch, slotNum) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 0b03489b98..eba0c19ae7 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -6,6 +6,7 @@ package babe import ( + "fmt" "path/filepath" "testing" "time" @@ -388,18 +389,18 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { babeService.blockState.AddBlock(block) time.Sleep(babeService.constants.slotDuration * 10) - + _ = babeService.Stop() bestBlockHeader, err := babeService.blockState.BestBlockHeader() require.NoError(t, err) bestBlockSlotNum, err := babeService.blockState.GetSlotForBlock(bestBlockHeader.Hash()) require.NoError(t, err) - slotnum := uint64(1) + // slotnum := uint64(1) slot := Slot{ start: time.Now(), duration: 1 * time.Second, - number: slotnum, + number: bestBlockSlotNum, } testVRFOutputAndProof := &VrfOutputAndProof{} preRuntimeDigest, err := types.NewBabePrimaryPreDigest( @@ -417,9 +418,15 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { preRuntimeDigest) require.NoError(t, err) + fmt.Printf("\nbestBlockHeader %s\nblock number %d\n\n", bestBlockHeader.Hash(), bestBlockHeader.Number) + time.Sleep(20 * time.Second) // test that newly created block is sibling of bestBlockHeader siblings := babeService.blockState.GetAllBlocksAtDepth(bestBlockHeader.ParentHash) + fmt.Println() + fmt.Println(siblings) + temphead, _ := babeService.blockState.GetHeader(siblings[0]) + fmt.Printf("temphead number %d\n\n", temphead.Number) require.GreaterOrEqual(t, len(siblings), 2) require.Contains(t, bestBlockHeader.Hash(), siblings) } From cecc3086226d012e4a97ce8586e01af2b74d6ecc Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 29 Aug 2022 20:03:08 +0530 Subject: [PATCH 12/49] fixed tests --- dot/services.go | 1 + dot/types/authority.go | 4 +- lib/babe/babe.go | 1 - lib/babe/babe_integration_test.go | 106 +++++++++++++++++++++--------- 4 files changed, 78 insertions(+), 34 deletions(-) diff --git a/dot/services.go b/dot/services.go index a9bc446d3f..4cdbeb73d8 100644 --- a/dot/services.go +++ b/dot/services.go @@ -175,6 +175,7 @@ func (nb nodeBuilder) createBABEService(cfg *Config, st *state.Service, ks keyst cs *core.Service, telemetryMailer telemetry.Client) (babe.ServiceIFace, error) { return nb.createBABEServiceWithBuilder(cfg, st, ks, cs, telemetryMailer, babe.Builder{}) } + func (nodeBuilder) createBABEServiceWithBuilder(cfg *Config, st *state.Service, ks keystore.Keystore, cs *core.Service, telemetryMailer telemetry.Client, newBabeService ServiceBuilder) (babe. ServiceIFace, error) { diff --git a/dot/types/authority.go b/dot/types/authority.go index 8962568880..9005cb911a 100644 --- a/dot/types/authority.go +++ b/dot/types/authority.go @@ -15,7 +15,9 @@ import ( // Authority struct to hold authority data type Authority struct { - Key crypto.PublicKey + Key crypto.PublicKey + // Weight exists for potential improvements in the protocol and could + // have a use-case in the future. In polkadot all authorities have the weight = 1. Weight uint64 } diff --git a/lib/babe/babe.go b/lib/babe/babe.go index 72a0fc604f..f6f18d4e8b 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -562,7 +562,6 @@ func (b *Service) handleSlot(epoch, slotNum uint64, return err } - fmt.Printf("block %s\nblock number %d\n\n", block.Header.Hash(), block.Header.Number) logger.Infof( "built block %d with hash %s, state root %s, epoch %d and slot %d", block.Header.Number, block.Header.Hash(), block.Header.StateRoot, epoch, slotNum) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index eba0c19ae7..5d96f9a8f0 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -6,7 +6,6 @@ package babe import ( - "fmt" "path/filepath" "testing" "time" @@ -330,7 +329,7 @@ func TestService_HandleSlotWithLaggingSlot(t *testing.T) { 1, testEpochIndex, epochData) babeService.blockState.AddBlock(block) - time.Sleep(babeService.constants.slotDuration * 10) + time.Sleep(babeService.constants.slotDuration * 1) header, err := babeService.blockState.BestBlockHeader() require.NoError(t, err) @@ -363,40 +362,95 @@ func TestService_HandleSlotWithLaggingSlot(t *testing.T) { } func TestService_HandleSlotWithSameSlot(t *testing.T) { - cfg := &ServiceConfig{ + alice := keyring.Alice().(*sr25519.Keypair) + bob := keyring.Bob().(*sr25519.Keypair) + + // Create babe service for alice + cfgAlice := &ServiceConfig{ Authority: true, Lead: true, + Keypair: alice, + } + cfgAlice.AuthData = []types.Authority{ + { + Key: alice.Public().(*sr25519.PublicKey), + Weight: 1, + }, + { + Key: bob.Public().(*sr25519.PublicKey), + Weight: 1, + }, } - babeService := createTestService(t, cfg) - err := babeService.Start() + // Create babe service for bob + cfgBob := &ServiceConfig{ + Authority: true, + Lead: true, + Keypair: bob, + } + cfgBob.AuthData = []types.Authority{ + { + Key: alice.Public().(*sr25519.PublicKey), + Weight: 1, + }, + { + Key: bob.Public().(*sr25519.PublicKey), + Weight: 1, + }, + } + + babeServiceBob := createTestService(t, cfgBob) + + err := babeServiceBob.Start() require.NoError(t, err) defer func() { - _ = babeService.Stop() + _ = babeServiceBob.Stop() }() - // add a block - parentHash := babeService.blockState.GenesisHash() - rt, err := babeService.blockState.GetRuntime(nil) + time.Sleep(babeServiceBob.constants.slotDuration * 5) + + // create a block using bob + parentHash := babeServiceBob.blockState.GenesisHash() + rt, err := babeServiceBob.blockState.GetRuntime(nil) require.NoError(t, err) - epochData, err := babeService.initiateEpoch(testEpochIndex) + epochData, err := babeServiceBob.initiateEpoch(testEpochIndex) require.NoError(t, err) ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd}) - block := createTestBlock(t, babeService, emptyHeader, [][]byte{common.MustHexToBytes(ext)}, + block := createTestBlock(t, babeServiceBob, emptyHeader, [][]byte{common.MustHexToBytes(ext)}, 1, testEpochIndex, epochData) - babeService.blockState.AddBlock(block) - time.Sleep(babeService.constants.slotDuration * 10) - _ = babeService.Stop() - bestBlockHeader, err := babeService.blockState.BestBlockHeader() + err = babeServiceBob.Stop() + require.NoError(t, err) + + babeServiceAlice := createTestService(t, cfgAlice) + + err = babeServiceAlice.Start() + require.NoError(t, err) + defer func() { + _ = babeServiceAlice.Stop() + }() + time.Sleep(babeServiceAlice.constants.slotDuration * 1) + + // Add block created by Bob to Alice + babeServiceAlice.blockState.AddBlock(block) + + time.Sleep(babeServiceAlice.constants.slotDuration * 1) + + bestBlockHeader, err := babeServiceAlice.blockState.BestBlockHeader() + require.NoError(t, err) + + require.Equal(t, block.Header.Hash().String(), bestBlockHeader.Hash().String()) + + // If the slot we are claiming is same as slot in best header, test that we don't + // through any error and can claim slot. + bestBlockSlotNum, err := babeServiceAlice.blockState.GetSlotForBlock(bestBlockHeader.Hash()) require.NoError(t, err) - bestBlockSlotNum, err := babeService.blockState.GetSlotForBlock(bestBlockHeader.Hash()) + err = babeServiceAlice.Stop() require.NoError(t, err) - // slotnum := uint64(1) slot := Slot{ start: time.Now(), duration: 1 * time.Second, @@ -408,25 +462,13 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { testVRFOutputAndProof.output, testVRFOutputAndProof.proof, ).ToPreRuntimeDigest() - require.NoError(t, err) - err = babeService.handleSlot( - babeService.epochHandler.epochNumber, + err = babeServiceAlice.handleSlot( + babeServiceAlice.epochHandler.epochNumber, bestBlockSlotNum, - babeService.epochHandler.epochData.authorityIndex, + babeServiceAlice.epochHandler.epochData.authorityIndex, preRuntimeDigest) - require.NoError(t, err) - fmt.Printf("\nbestBlockHeader %s\nblock number %d\n\n", bestBlockHeader.Hash(), bestBlockHeader.Number) - time.Sleep(20 * time.Second) - // test that newly created block is sibling of bestBlockHeader - siblings := babeService.blockState.GetAllBlocksAtDepth(bestBlockHeader.ParentHash) - fmt.Println() - fmt.Println(siblings) - temphead, _ := babeService.blockState.GetHeader(siblings[0]) - fmt.Printf("temphead number %d\n\n", temphead.Number) - require.GreaterOrEqual(t, len(siblings), 2) - require.Contains(t, bestBlockHeader.Hash(), siblings) } From 540c09adf76b85d21919845c727ae1fb38205284 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Fri, 9 Sep 2022 20:15:48 +0800 Subject: [PATCH 13/49] Author a sibling block in case best block's slot is same as current slot (#2726) --- dot/services.go | 1 + dot/types/authority.go | 4 +- lib/babe/babe.go | 24 +++++ lib/babe/babe_integration_test.go | 171 ++++++++++++++++++++++++++++++ lib/babe/errors.go | 1 + lib/genesis/test_utils.go | 17 ++- 6 files changed, 216 insertions(+), 2 deletions(-) diff --git a/dot/services.go b/dot/services.go index 23688eec83..5674fe753f 100644 --- a/dot/services.go +++ b/dot/services.go @@ -175,6 +175,7 @@ func (nb nodeBuilder) createBABEService(cfg *Config, st *state.Service, ks keyst cs *core.Service, telemetryMailer telemetry.Client) (babe.ServiceIFace, error) { return nb.createBABEServiceWithBuilder(cfg, st, ks, cs, telemetryMailer, babe.Builder{}) } + func (nodeBuilder) createBABEServiceWithBuilder(cfg *Config, st *state.Service, ks keystore.Keystore, cs *core.Service, telemetryMailer telemetry.Client, newBabeService ServiceBuilder) (babe. ServiceIFace, error) { diff --git a/dot/types/authority.go b/dot/types/authority.go index a75f6437df..2dff7a4434 100644 --- a/dot/types/authority.go +++ b/dot/types/authority.go @@ -16,7 +16,9 @@ import ( // Authority struct to hold authority data type Authority struct { - Key crypto.PublicKey + Key crypto.PublicKey + // Weight exists for potential improvements in the protocol and could + // have a use-case in the future. In polkadot all authorities have the weight = 1. Weight uint64 } diff --git a/lib/babe/babe.go b/lib/babe/babe.go index 929e77315b..14d65e7fee 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -467,6 +467,30 @@ func (b *Service) handleSlot(epoch, slotNum uint64, return errNilParentHeader } + atGenesisBlock := b.blockState.GenesisHash().Equal(parentHeader.Hash()) + if !atGenesisBlock { + bestBlockSlotNum, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) + if err != nil { + return fmt.Errorf("could not get slot for block %s: %w", parentHeader.Hash(), err) + } + + if bestBlockSlotNum > slotNum { + return errLaggingSlot + } + + if bestBlockSlotNum == slotNum { + // pick parent of best block instead to handle slot + newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash) + if err != nil { + return fmt.Errorf("could not get header for hash %s: %w", parentHeader.ParentHash, err) + } + if newParentHeader == nil { + return errNilParentHeader + } + parentHeader = newParentHeader + } + } + // there is a chance that the best block header may change in the course of building the block, // so let's copy it first. parent, err := parentHeader.DeepCopy() diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index a303385308..1249d38901 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -15,6 +15,7 @@ import ( "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/internal/log" "github.com/ChainSafe/gossamer/lib/babe/mocks" + "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/crypto/sr25519" "github.com/ChainSafe/gossamer/lib/genesis" "github.com/ChainSafe/gossamer/lib/runtime" @@ -293,3 +294,173 @@ func TestService_PauseAndResume(t *testing.T) { err = bs.Stop() require.NoError(t, err) } + +func TestService_HandleSlotWithLaggingSlot(t *testing.T) { + cfg := &ServiceConfig{ + Authority: true, + Lead: true, + } + babeService := createTestService(t, cfg) + + err := babeService.Start() + require.NoError(t, err) + defer func() { + _ = babeService.Stop() + }() + + // add a block + parentHash := babeService.blockState.GenesisHash() + rt, err := babeService.blockState.GetRuntime(nil) + require.NoError(t, err) + + epochData, err := babeService.initiateEpoch(testEpochIndex) + require.NoError(t, err) + + ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd}) + block := createTestBlock(t, babeService, emptyHeader, [][]byte{common.MustHexToBytes(ext)}, + 1, testEpochIndex, epochData) + + babeService.blockState.AddBlock(block) + time.Sleep(babeService.constants.slotDuration * 1) + + header, err := babeService.blockState.BestBlockHeader() + require.NoError(t, err) + + bestBlockSlotNum, err := babeService.blockState.GetSlotForBlock(header.Hash()) + require.NoError(t, err) + + slotnum := uint64(1) + slot := Slot{ + start: time.Now(), + duration: 1 * time.Second, + number: slotnum, + } + testVRFOutputAndProof := &VrfOutputAndProof{} + preRuntimeDigest, err := types.NewBabePrimaryPreDigest( + 0, slot.number, + testVRFOutputAndProof.output, + testVRFOutputAndProof.proof, + ).ToPreRuntimeDigest() + + require.NoError(t, err) + + err = babeService.handleSlot( + babeService.epochHandler.epochNumber, + bestBlockSlotNum-1, + babeService.epochHandler.epochData.authorityIndex, + preRuntimeDigest) + + require.ErrorIs(t, err, errLaggingSlot) +} + +func TestService_HandleSlotWithSameSlot(t *testing.T) { + alice := keyring.Alice().(*sr25519.Keypair) + bob := keyring.Bob().(*sr25519.Keypair) + + // Create babe service for alice + cfgAlice := &ServiceConfig{ + Authority: true, + Lead: true, + Keypair: alice, + } + cfgAlice.AuthData = []types.Authority{ + { + Key: alice.Public().(*sr25519.PublicKey), + Weight: 1, + }, + { + Key: bob.Public().(*sr25519.PublicKey), + Weight: 1, + }, + } + + // Create babe service for bob + cfgBob := &ServiceConfig{ + Authority: true, + Lead: true, + Keypair: bob, + } + cfgBob.AuthData = []types.Authority{ + { + Key: alice.Public().(*sr25519.PublicKey), + Weight: 1, + }, + { + Key: bob.Public().(*sr25519.PublicKey), + Weight: 1, + }, + } + + babeServiceBob := createTestService(t, cfgBob) + + err := babeServiceBob.Start() + require.NoError(t, err) + defer func() { + _ = babeServiceBob.Stop() + }() + + time.Sleep(babeServiceBob.constants.slotDuration * 5) + + // create a block using bob + parentHash := babeServiceBob.blockState.GenesisHash() + rt, err := babeServiceBob.blockState.GetRuntime(nil) + require.NoError(t, err) + + epochData, err := babeServiceBob.initiateEpoch(testEpochIndex) + require.NoError(t, err) + + ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd}) + block := createTestBlock(t, babeServiceBob, emptyHeader, [][]byte{common.MustHexToBytes(ext)}, + 1, testEpochIndex, epochData) + + err = babeServiceBob.Stop() + require.NoError(t, err) + + babeServiceAlice := createTestService(t, cfgAlice) + + err = babeServiceAlice.Start() + require.NoError(t, err) + defer func() { + _ = babeServiceAlice.Stop() + }() + time.Sleep(babeServiceAlice.constants.slotDuration * 1) + + // Add block created by Bob to Alice + babeServiceAlice.blockState.AddBlock(block) + + time.Sleep(babeServiceAlice.constants.slotDuration * 1) + + bestBlockHeader, err := babeServiceAlice.blockState.BestBlockHeader() + require.NoError(t, err) + + require.Equal(t, block.Header.Hash().String(), bestBlockHeader.Hash().String()) + + // If the slot we are claiming is same as slot in best header, test that we don't + // through any error and can claim slot. + bestBlockSlotNum, err := babeServiceAlice.blockState.GetSlotForBlock(bestBlockHeader.Hash()) + require.NoError(t, err) + + err = babeServiceAlice.Stop() + require.NoError(t, err) + + slot := Slot{ + start: time.Now(), + duration: 1 * time.Second, + number: bestBlockSlotNum, + } + testVRFOutputAndProof := &VrfOutputAndProof{} + preRuntimeDigest, err := types.NewBabePrimaryPreDigest( + 0, slot.number, + testVRFOutputAndProof.output, + testVRFOutputAndProof.proof, + ).ToPreRuntimeDigest() + require.NoError(t, err) + + err = babeServiceAlice.handleSlot( + babeServiceAlice.epochHandler.epochNumber, + bestBlockSlotNum, + babeServiceAlice.epochHandler.epochData.authorityIndex, + preRuntimeDigest) + require.NoError(t, err) + +} diff --git a/lib/babe/errors.go b/lib/babe/errors.go index 463832ba0f..15a572b6f7 100644 --- a/lib/babe/errors.go +++ b/lib/babe/errors.go @@ -71,6 +71,7 @@ var ( errInvalidSlotTechnique = errors.New("invalid slot claiming technique") errNoBABEAuthorityKeyProvided = errors.New("cannot create BABE service as authority; no keypair provided") errLastDigestItemNotSeal = errors.New("last digest item is not seal") + errLaggingSlot = errors.New("cannot claim slot, current slot is smaller than slot of best block") other Other invalidCustom InvalidCustom diff --git a/lib/genesis/test_utils.go b/lib/genesis/test_utils.go index f0bfe01ec3..4d63675ca4 100644 --- a/lib/genesis/test_utils.go +++ b/lib/genesis/test_utils.go @@ -13,6 +13,7 @@ import ( "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/trie" "github.com/ChainSafe/gossamer/lib/utils" + "github.com/ChainSafe/gossamer/pkg/scale" "github.com/stretchr/testify/require" ) @@ -100,8 +101,22 @@ func newGenesisTrieAndHeader(t *testing.T, gen *Genesis) (*trie.Trie, *types.Hea genTrie, err := NewTrieFromGenesis(gen) require.NoError(t, err) + babeDigest := types.NewBabeDigest() + err = babeDigest.Set(types.BabePrimaryPreDigest{AuthorityIndex: 0}) + require.NoError(t, err) + + bdEnc, err := scale.Marshal(babeDigest) + require.NoError(t, err) + + digest := types.NewDigest() + err = digest.Add(types.PreRuntimeDigest{ + ConsensusEngineID: types.BabeEngineID, + Data: bdEnc, + }) + require.NoError(t, err) + genesisHeader, err := types.NewHeader(common.NewHash([]byte{0}), - genTrie.MustHash(), trie.EmptyHash, 0, types.NewDigest()) + genTrie.MustHash(), trie.EmptyHash, 0, digest) require.NoError(t, err) return genTrie, genesisHeader From 1edb86bc69ad1110e7407ff51a7192c184bceea3 Mon Sep 17 00:00:00 2001 From: Quentin McGaw Date: Fri, 9 Sep 2022 09:23:43 -0400 Subject: [PATCH 14/49] chore(dot): remove unneeded error functions (#2790) --- dot/core/errors.go | 16 ---------------- dot/sync/errors.go | 6 ------ 2 files changed, 22 deletions(-) diff --git a/dot/core/errors.go b/dot/core/errors.go index c9711f6745..468a29032b 100644 --- a/dot/core/errors.go +++ b/dot/core/errors.go @@ -5,7 +5,6 @@ package core import ( "errors" - "fmt" ) var ( @@ -23,18 +22,3 @@ var ( // ErrEmptyRuntimeCode is returned when the storage :code is empty ErrEmptyRuntimeCode = errors.New("new :code is empty") ) - -// ErrNilChannel is returned if a channel is nil -func ErrNilChannel(s string) error { - return fmt.Errorf("cannot have nil channel %s", s) -} - -// ErrMessageCast is returned if unable to cast a network.Message to a type -func ErrMessageCast(s string) error { - return fmt.Errorf("could not cast network.Message to %s", s) -} - -// ErrUnsupportedMsgType is returned if we receive an unknown message type -func ErrUnsupportedMsgType(d byte) error { - return fmt.Errorf("received unsupported message type %d", d) -} diff --git a/dot/sync/errors.go b/dot/sync/errors.go index d66525f939..4ca0b4bfc1 100644 --- a/dot/sync/errors.go +++ b/dot/sync/errors.go @@ -5,7 +5,6 @@ package sync import ( "errors" - "fmt" ) var ( @@ -40,8 +39,3 @@ var ( errStartAndEndMismatch = errors.New("request start and end hash are not on the same chain") errFailedToGetDescendant = errors.New("failed to find descendant block") ) - -// ErrNilChannel is returned if a channel is nil -func ErrNilChannel(s string) error { - return fmt.Errorf("cannot have nil channel %s", s) -} From 7fa91961017651b8fe4ba0966d683fe5de995e41 Mon Sep 17 00:00:00 2001 From: Quentin McGaw Date: Fri, 9 Sep 2022 09:52:39 -0400 Subject: [PATCH 15/49] chore(wasmer): add helpers.go file with helper functions (#2749) - Split out (CGO related) helper functions from `imports.go` to `lib/runtime/wasmer/helpers.go` - Move pointer size helper functions to `lib/runtime/wasmer/helpers.go` - Change `toWasmMemorySized` to NOT take a size argument (unneeded) - Clarify all comments for helper functions - Update all error wrappings - Review variable names - Use `ptr` instead of `out` for 32 bit pointers - Use `pointerSize` instead of `span` for 64 bit pointers size - Name return values - Other minor renamings such as `res` to `result`, `enc` to `encodedResult` - Optimizations: - `storageAppend`: use slice capacity allocation, `copy` and remove unneeded `append`s - `toKillStorageResultEnum`: use `copy` instead of `append` - `toWasmMemoryOptional`: remove unneeded variable copy --- lib/runtime/common.go | 14 -- lib/runtime/wasmer/helpers.go | 216 ++++++++++++++++++++++++++++ lib/runtime/wasmer/helpers_test.go | 49 +++++++ lib/runtime/wasmer/imports.go | 209 ++------------------------- lib/runtime/wasmer/imports_test.go | 2 +- lib/runtime/wasmer/instance.go | 2 +- lib/runtime/wasmer/instance_test.go | 9 -- 7 files changed, 281 insertions(+), 220 deletions(-) delete mode 100644 lib/runtime/common.go create mode 100644 lib/runtime/wasmer/helpers.go create mode 100644 lib/runtime/wasmer/helpers_test.go diff --git a/lib/runtime/common.go b/lib/runtime/common.go deleted file mode 100644 index 41133b65f9..0000000000 --- a/lib/runtime/common.go +++ /dev/null @@ -1,14 +0,0 @@ -// Copyright 2021 ChainSafe Systems (ON) -// SPDX-License-Identifier: LGPL-3.0-only - -package runtime - -// Int64ToPointerAndSize converts an int64 into a int32 pointer and a int32 length -func Int64ToPointerAndSize(in int64) (ptr, length int32) { - return int32(in), int32(in >> 32) -} - -// PointerAndSizeToInt64 converts int32 pointer and size to a int64 -func PointerAndSizeToInt64(ptr, size int32) int64 { - return int64(ptr) | (int64(size) << 32) -} diff --git a/lib/runtime/wasmer/helpers.go b/lib/runtime/wasmer/helpers.go new file mode 100644 index 0000000000..6065f2d83c --- /dev/null +++ b/lib/runtime/wasmer/helpers.go @@ -0,0 +1,216 @@ +// Copyright 2022 ChainSafe Systems (ON) +// SPDX-License-Identifier: LGPL-3.0-only + +package wasmer + +// #include +import "C" //skipcq: SCC-compile + +import ( + "fmt" + "math/big" + + "github.com/ChainSafe/gossamer/lib/common/types" + "github.com/ChainSafe/gossamer/lib/runtime" + "github.com/ChainSafe/gossamer/pkg/scale" + "github.com/wasmerio/go-ext-wasm/wasmer" +) + +// toPointerSize converts an uint32 pointer and uint32 size +// to an int64 pointer size. +func toPointerSize(ptr, size uint32) (pointerSize int64) { + return int64(ptr) | (int64(size) << 32) +} + +// splitPointerSize converts an int64 pointer size to an +// uint32 pointer and an uint32 size. +func splitPointerSize(pointerSize int64) (ptr, size uint32) { + return uint32(pointerSize), uint32(pointerSize >> 32) +} + +// asMemorySlice converts a 64 bit pointer size to a Go byte slice. +func asMemorySlice(context wasmer.InstanceContext, pointerSize C.int64_t) (data []byte) { + memory := context.Memory().Data() + ptr, size := splitPointerSize(int64(pointerSize)) + return memory[ptr : ptr+size] +} + +// toWasmMemory copies a Go byte slice to wasm memory and returns the corresponding +// 64 bit pointer size. +func toWasmMemory(context wasmer.InstanceContext, data []byte) ( + pointerSize int64, err error) { + allocator := context.Data().(*runtime.Context).Allocator + size := uint32(len(data)) + + ptr, err := allocator.Allocate(size) + if err != nil { + return 0, fmt.Errorf("allocating: %w", err) + } + + memory := context.Memory().Data() + + if uint32(len(memory)) < ptr+size { + panic(fmt.Sprintf("length of memory is less than expected, want %d have %d", ptr+size, len(memory))) + } + + copy(memory[ptr:ptr+size], data) + pointerSize = toPointerSize(ptr, size) + return pointerSize, nil +} + +// toWasmMemorySized copies a Go byte slice to wasm memory and returns the corresponding +// 32 bit pointer. Note the data must have a well known fixed length in the runtime. +func toWasmMemorySized(context wasmer.InstanceContext, data []byte) ( + pointer uint32, err error) { + allocator := context.Data().(*runtime.Context).Allocator + + size := uint32(len(data)) + pointer, err = allocator.Allocate(size) + if err != nil { + return 0, fmt.Errorf("allocating: %w", err) + } + + memory := context.Memory().Data() + copy(memory[pointer:pointer+size], data) + + return pointer, nil +} + +// toWasmMemoryOptional scale encodes the byte slice `data`, writes it to wasm memory +// and returns the corresponding 64 bit pointer size. +func toWasmMemoryOptional(context wasmer.InstanceContext, data []byte) ( + pointerSize int64, err error) { + var optionalSlice *[]byte + if data != nil { + optionalSlice = &data + } + + encoded, err := scale.Marshal(optionalSlice) + if err != nil { + return 0, err + } + + return toWasmMemory(context, encoded) +} + +// toWasmMemoryResult wraps the data byte slice in a Result type, scale encodes it, +// copies it to wasm memory and returns the corresponding 64 bit pointer size. +func toWasmMemoryResult(context wasmer.InstanceContext, data []byte) ( + pointerSize int64, err error) { + var result *types.Result + if len(data) == 0 { + result = types.NewResult(byte(1), nil) + } else { + result = types.NewResult(byte(0), data) + } + + encodedResult, err := result.Encode() + if err != nil { + return 0, fmt.Errorf("encoding result: %w", err) + } + + return toWasmMemory(context, encodedResult) +} + +// toWasmMemoryOptional scale encodes the uint32 pointer `data`, writes it to wasm memory +// and returns the corresponding 64 bit pointer size. +func toWasmMemoryOptionalUint32(context wasmer.InstanceContext, data *uint32) ( + pointerSize int64, err error) { + enc, err := scale.Marshal(data) + if err != nil { + return 0, fmt.Errorf("scale encoding: %w", err) + } + return toWasmMemory(context, enc) +} + +// toKillStorageResultEnum encodes the `allRemoved` flag and +// the `numRemoved` uint32 to a byte slice and returns it. +// The format used is: +// Byte 0: 1 if allRemoved is false, 0 otherwise +// Byte 1-5: scale encoding of numRemoved (up to 4 bytes) +func toKillStorageResultEnum(allRemoved bool, numRemoved uint32) ( + encodedEnumValue []byte, err error) { + encodedNumRemoved, err := scale.Marshal(numRemoved) + if err != nil { + return nil, fmt.Errorf("scale encoding: %w", err) + } + + encodedEnumValue = make([]byte, len(encodedNumRemoved)+1) + if !allRemoved { + // At least one key resides in the child trie due to the supplied limit. + encodedEnumValue[0] = 1 + } + copy(encodedEnumValue[1:], encodedNumRemoved) + + return encodedEnumValue, nil +} + +// toWasmMemoryFixedSizeOptional copies the `data` byte slice to a 64B array, +// scale encodes the pointer to the resulting array, writes it to wasm memory +// and returns the corresponding 64 bit pointer size. +func toWasmMemoryFixedSizeOptional(context wasmer.InstanceContext, data []byte) ( + pointerSize int64, err error) { + var optionalFixedSize [64]byte + copy(optionalFixedSize[:], data) + encodedOptionalFixedSize, err := scale.Marshal(&optionalFixedSize) + if err != nil { + return 0, fmt.Errorf("scale encoding: %w", err) + } + return toWasmMemory(context, encodedOptionalFixedSize) +} + +func storageAppend(storage runtime.Storage, key, valueToAppend []byte) error { + // this function assumes the item in storage is a SCALE encoded array of items + // the valueToAppend is a new item, so it appends the item and increases the length prefix by 1 + currentValue := storage.Get(key) + + var value []byte + if len(currentValue) == 0 { + nextLength := big.NewInt(1) + encodedLength, err := scale.Marshal(nextLength) + if err != nil { + return fmt.Errorf("scale encoding: %w", err) + } + value = make([]byte, len(encodedLength)+len(valueToAppend)) + // append new length prefix to start of items array + copy(value, encodedLength) + copy(value[len(encodedLength):], valueToAppend) + } else { + var currentLength *big.Int + err := scale.Unmarshal(currentValue, ¤tLength) + if err != nil { + logger.Tracef( + "item in storage is not SCALE encoded, overwriting at key 0x%x", key) + value = make([]byte, 1+len(valueToAppend)) + value[0] = 4 + copy(value[1:], valueToAppend) + } else { + lengthBytes, err := scale.Marshal(currentLength) + if err != nil { + return fmt.Errorf("scale encoding: %w", err) + } + + // increase length by 1 + nextLength := big.NewInt(0).Add(currentLength, big.NewInt(1)) + nextLengthBytes, err := scale.Marshal(nextLength) + if err != nil { + return fmt.Errorf("scale encoding next length bytes: %w", err) + } + + // append new item, pop off number of bytes required for length encoding, + // since we're not using old scale.Decoder + value = make([]byte, len(nextLengthBytes)+len(currentValue)-len(lengthBytes)+len(valueToAppend)) + // append new length prefix to start of items array + i := 0 + copy(value[i:], nextLengthBytes) + i += len(nextLengthBytes) + copy(value[i:], currentValue[len(lengthBytes):]) + i += len(currentValue) - len(lengthBytes) + copy(value[i:], valueToAppend) + } + } + + logger.Debugf("resulting value: 0x%x", value) + storage.Set(key, value) + return nil +} diff --git a/lib/runtime/wasmer/helpers_test.go b/lib/runtime/wasmer/helpers_test.go new file mode 100644 index 0000000000..c6bda5f811 --- /dev/null +++ b/lib/runtime/wasmer/helpers_test.go @@ -0,0 +1,49 @@ +// Copyright 2022 ChainSafe Systems (ON) +// SPDX-License-Identifier: LGPL-3.0-only + +package wasmer + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func Test_pointerSize(t *testing.T) { + t.Parallel() + + testCases := map[string]struct { + ptr uint32 + size uint32 + pointerSize int64 + }{ + "0": {}, + "ptr 8 size 32": { + ptr: 8, + size: 32, + pointerSize: int64(8) | (int64(32) << 32), + }, + "ptr max uint32 and size max uint32": { + ptr: ^uint32(0), + size: ^uint32(0), + pointerSize: ^int64(0), + }, + } + + for name, testCase := range testCases { + testCase := testCase + t.Run(name, func(t *testing.T) { + t.Parallel() + + pointerSize := toPointerSize(testCase.ptr, testCase.size) + + require.Equal(t, testCase.pointerSize, pointerSize) + + ptr, size := splitPointerSize(pointerSize) + + assert.Equal(t, testCase.ptr, ptr) + assert.Equal(t, testCase.size, size) + }) + } +} diff --git a/lib/runtime/wasmer/imports.go b/lib/runtime/wasmer/imports.go index cd503780f1..daad753bab 100644 --- a/lib/runtime/wasmer/imports.go +++ b/lib/runtime/wasmer/imports.go @@ -102,7 +102,6 @@ import "C" //skipcq: SCC-compile import ( "encoding/binary" - "errors" "fmt" "math/big" "math/rand" @@ -111,7 +110,6 @@ import ( "unsafe" "github.com/ChainSafe/gossamer/lib/common" - rtype "github.com/ChainSafe/gossamer/lib/common/types" "github.com/ChainSafe/gossamer/lib/crypto" "github.com/ChainSafe/gossamer/lib/crypto/ed25519" "github.com/ChainSafe/gossamer/lib/crypto/secp256k1" @@ -261,7 +259,7 @@ func ext_crypto_ed25519_generate_version_1(context unsafe.Pointer, keyTypeID C.i return 0 } - ret, err := toWasmMemorySized(instanceContext, kp.Public().Encode(), 32) + ret, err := toWasmMemorySized(instanceContext, kp.Public().Encode()) if err != nil { logger.Warnf("failed to allocate memory: %s", err) return 0 @@ -585,7 +583,7 @@ func ext_crypto_sr25519_generate_version_1(context unsafe.Pointer, keyTypeID C.i return 0 } - ret, err := toWasmMemorySized(instanceContext, kp.Public().Encode(), 32) + ret, err := toWasmMemorySized(instanceContext, kp.Public().Encode()) if err != nil { logger.Errorf("failed to allocate memory: %s", err) return 0 @@ -1009,7 +1007,7 @@ func ext_default_child_storage_read_version_1(context unsafe.Pointer, return 0 } - valueBuf, valueLen := runtime.Int64ToPointerAndSize(int64(valueOut)) + valueBuf, valueLen := splitPointerSize(int64(valueOut)) copy(memory[valueBuf:valueBuf+valueLen], value[offset:]) size := uint32(len(value[offset:])) @@ -1333,7 +1331,7 @@ func ext_hashing_blake2_128_version_1(context unsafe.Pointer, dataSpan C.int64_t "data 0x%x has hash 0x%x", data, hash) - out, err := toWasmMemorySized(instanceContext, hash, 16) + out, err := toWasmMemorySized(instanceContext, hash) if err != nil { logger.Errorf("failed to allocate: %s", err) return 0 @@ -1357,7 +1355,7 @@ func ext_hashing_blake2_256_version_1(context unsafe.Pointer, dataSpan C.int64_t logger.Debugf("data 0x%x has hash %s", data, hash) - out, err := toWasmMemorySized(instanceContext, hash[:], 32) + out, err := toWasmMemorySized(instanceContext, hash[:]) if err != nil { logger.Errorf("failed to allocate: %s", err) return 0 @@ -1381,7 +1379,7 @@ func ext_hashing_keccak_256_version_1(context unsafe.Pointer, dataSpan C.int64_t logger.Debugf("data 0x%x has hash %s", data, hash) - out, err := toWasmMemorySized(instanceContext, hash[:], 32) + out, err := toWasmMemorySized(instanceContext, hash[:]) if err != nil { logger.Errorf("failed to allocate: %s", err) return 0 @@ -1400,7 +1398,7 @@ func ext_hashing_sha2_256_version_1(context unsafe.Pointer, dataSpan C.int64_t) logger.Debugf("data 0x%x has hash %s", data, hash) - out, err := toWasmMemorySized(instanceContext, hash[:], 32) + out, err := toWasmMemorySized(instanceContext, hash[:]) if err != nil { logger.Errorf("failed to allocate: %s", err) return 0 @@ -1424,7 +1422,7 @@ func ext_hashing_twox_256_version_1(context unsafe.Pointer, dataSpan C.int64_t) logger.Debugf("data 0x%x has hash %s", data, hash) - out, err := toWasmMemorySized(instanceContext, hash[:], 32) + out, err := toWasmMemorySized(instanceContext, hash[:]) if err != nil { logger.Errorf("failed to allocate: %s", err) return 0 @@ -1449,7 +1447,7 @@ func ext_hashing_twox_128_version_1(context unsafe.Pointer, dataSpan C.int64_t) "data 0x%x hash hash 0x%x", data, hash) - out, err := toWasmMemorySized(instanceContext, hash, 16) + out, err := toWasmMemorySized(instanceContext, hash) if err != nil { logger.Errorf("failed to allocate: %s", err) return 0 @@ -1475,7 +1473,7 @@ func ext_hashing_twox_64_version_1(context unsafe.Pointer, dataSpan C.int64_t) C "data 0x%x has hash 0x%x", data, hash) - out, err := toWasmMemorySized(instanceContext, hash, 8) + out, err := toWasmMemorySized(instanceContext, hash) if err != nil { logger.Errorf("failed to allocate: %s", err) return 0 @@ -1647,13 +1645,8 @@ func ext_offchain_network_state_version_1(context unsafe.Pointer) C.int64_t { return 0 } - // copy network state length to memory writtenOut location - nsEncLen := uint32(len(nsEnc)) - buf := make([]byte, 4) - binary.LittleEndian.PutUint32(buf, nsEncLen) - // allocate memory for value and copy value to memory - ptr, err := toWasmMemorySized(instanceContext, nsEnc, nsEncLen) + ptr, err := toWasmMemorySized(instanceContext, nsEnc) if err != nil { logger.Errorf("failed to allocate memory: %s", err) return 0 @@ -1672,7 +1665,7 @@ func ext_offchain_random_seed_version_1(context unsafe.Pointer) C.int32_t { if err != nil { logger.Errorf("failed to generate random seed: %s", err) } - ptr, err := toWasmMemorySized(instanceContext, seed, 32) + ptr, err := toWasmMemorySized(instanceContext, seed) if err != nil { logger.Errorf("failed to allocate memory: %s", err) } @@ -1809,51 +1802,6 @@ func ext_offchain_http_request_add_header_version_1(context unsafe.Pointer, return C.int64_t(ptr) } -func storageAppend(storage runtime.Storage, key, valueToAppend []byte) error { - nextLength := big.NewInt(1) - var valueRes []byte - - // this function assumes the item in storage is a SCALE encoded array of items - // the valueToAppend is a new item, so it appends the item and increases the length prefix by 1 - valueCurr := storage.Get(key) - - if len(valueCurr) == 0 { - valueRes = valueToAppend - } else { - var currLength *big.Int - err := scale.Unmarshal(valueCurr, &currLength) - if err != nil { - logger.Tracef( - "item in storage is not SCALE encoded, overwriting at key 0x%x", key) - storage.Set(key, append([]byte{4}, valueToAppend...)) - return nil //nolint:nilerr - } - - lengthBytes, err := scale.Marshal(currLength) - if err != nil { - return err - } - // append new item, pop off number of bytes required for length encoding, - // since we're not using old scale.Decoder - valueRes = append(valueCurr[len(lengthBytes):], valueToAppend...) - - // increase length by 1 - nextLength = big.NewInt(0).Add(currLength, big.NewInt(1)) - } - - lengthEnc, err := scale.Marshal(nextLength) - if err != nil { - logger.Tracef("failed to encode new length: %s", err) - return err - } - - // append new length prefix to start of items array - lengthEnc = append(lengthEnc, valueRes...) - logger.Debugf("resulting value: 0x%x", lengthEnc) - storage.Set(key, lengthEnc) - return nil -} - //export ext_storage_append_version_1 func ext_storage_append_version_1(context unsafe.Pointer, keySpan, valueSpan C.int64_t) { logger.Trace("executing...") @@ -2046,12 +1994,9 @@ func ext_storage_read_version_1(context unsafe.Pointer, keySpan, valueOut C.int6 } var size uint32 - - if int(offset) > len(value) { - size = uint32(0) - } else { + if uint32(offset) <= uint32(len(value)) { size = uint32(len(value[offset:])) - valueBuf, valueLen := runtime.Int64ToPointerAndSize(int64(valueOut)) + valueBuf, valueLen := splitPointerSize(int64(valueOut)) copy(memory[valueBuf:valueBuf+valueLen], value[offset:]) } @@ -2135,132 +2080,6 @@ func ext_storage_commit_transaction_version_1(context unsafe.Pointer) { instanceContext.Data().(*runtime.Context).Storage.CommitStorageTransaction() } -// Convert 64bit wasm span descriptor to Go memory slice -func asMemorySlice(context wasm.InstanceContext, span C.int64_t) []byte { - memory := context.Memory().Data() - ptr, size := runtime.Int64ToPointerAndSize(int64(span)) - return memory[ptr : ptr+size] -} - -// Copy a byte slice to wasm memory and return the resulting 64bit span descriptor -func toWasmMemory(context wasm.InstanceContext, data []byte) (int64, error) { - allocator := context.Data().(*runtime.Context).Allocator - size := uint32(len(data)) - - out, err := allocator.Allocate(size) - if err != nil { - return 0, err - } - - memory := context.Memory().Data() - - if uint32(len(memory)) < out+size { - panic(fmt.Sprintf("length of memory is less than expected, want %d have %d", out+size, len(memory))) - } - - copy(memory[out:out+size], data) - return runtime.PointerAndSizeToInt64(int32(out), int32(size)), nil -} - -// Copy a byte slice of a fixed size to wasm memory and return resulting pointer -func toWasmMemorySized(context wasm.InstanceContext, data []byte, size uint32) (uint32, error) { - if int(size) != len(data) { - return 0, errors.New("internal byte array size missmatch") - } - - allocator := context.Data().(*runtime.Context).Allocator - - out, err := allocator.Allocate(size) - if err != nil { - return 0, err - } - - memory := context.Memory().Data() - copy(memory[out:out+size], data) - - return out, nil -} - -// Wraps slice in optional.Bytes and copies result to wasm memory. Returns resulting 64bit span descriptor -func toWasmMemoryOptional(context wasm.InstanceContext, data []byte) (int64, error) { - var opt *[]byte - if data != nil { - temp := data - opt = &temp - } - - enc, err := scale.Marshal(opt) - if err != nil { - return 0, err - } - - return toWasmMemory(context, enc) -} - -// Wraps slice in Result type and copies result to wasm memory. Returns resulting 64bit span descriptor -func toWasmMemoryResult(context wasm.InstanceContext, data []byte) (int64, error) { - var res *rtype.Result - if len(data) == 0 { - res = rtype.NewResult(byte(1), nil) - } else { - res = rtype.NewResult(byte(0), data) - } - - enc, err := res.Encode() - if err != nil { - return 0, err - } - - return toWasmMemory(context, enc) -} - -// Wraps slice in optional and copies result to wasm memory. Returns resulting 64bit span descriptor -func toWasmMemoryOptionalUint32(context wasm.InstanceContext, data *uint32) (int64, error) { - var opt *uint32 - if data != nil { - temp := *data - opt = &temp - } - - enc, err := scale.Marshal(opt) - if err != nil { - return int64(0), err - } - return toWasmMemory(context, enc) -} - -// toKillStorageResult returns enum encoded value -func toKillStorageResultEnum(allRemoved bool, numRemoved uint32) ([]byte, error) { - var b, sbytes []byte - sbytes, err := scale.Marshal(numRemoved) - if err != nil { - return nil, err - } - - if allRemoved { - // No key remains in the child trie. - b = append(b, byte(0)) - } else { - // At least one key still resides in the child trie due to the supplied limit. - b = append(b, byte(1)) - } - - b = append(b, sbytes...) - - return b, err -} - -// Wraps slice in optional.FixedSizeBytes and copies result to wasm memory. Returns resulting 64bit span descriptor -func toWasmMemoryFixedSizeOptional(context wasm.InstanceContext, data []byte) (int64, error) { - var opt [64]byte - copy(opt[:], data) - enc, err := scale.Marshal(&opt) - if err != nil { - return 0, err - } - return toWasmMemory(context, enc) -} - // importsNodeRuntime returns the WASM imports for the node runtime. func importsNodeRuntime() (imports *wasm.Imports, err error) { imports = wasm.NewImports() diff --git a/lib/runtime/wasmer/imports_test.go b/lib/runtime/wasmer/imports_test.go index 5ba1db2b98..7061110a77 100644 --- a/lib/runtime/wasmer/imports_test.go +++ b/lib/runtime/wasmer/imports_test.go @@ -41,7 +41,7 @@ func Test_ext_offchain_timestamp_version_1(t *testing.T) { res, err := runtimeFunc(0, 0) require.NoError(t, err) - outputPtr, outputLength := runtime.Int64ToPointerAndSize(res.ToI64()) + outputPtr, outputLength := splitPointerSize(res.ToI64()) memory := inst.vm.Memory.Data() data := memory[outputPtr : outputPtr+outputLength] var timestamp int64 diff --git a/lib/runtime/wasmer/instance.go b/lib/runtime/wasmer/instance.go index 0bcf13c3d0..3e2bc6efea 100644 --- a/lib/runtime/wasmer/instance.go +++ b/lib/runtime/wasmer/instance.go @@ -321,7 +321,7 @@ func (in *Instance) Exec(function string, data []byte) (result []byte, err error return nil, fmt.Errorf("running runtime function: %w", err) } - outputPtr, outputLength := runtime.Int64ToPointerAndSize(wasmValue.ToI64()) + outputPtr, outputLength := splitPointerSize(wasmValue.ToI64()) memory = in.vm.Memory.Data() // call Data() again to get larger slice return memory[outputPtr : outputPtr+outputLength], nil } diff --git a/lib/runtime/wasmer/instance_test.go b/lib/runtime/wasmer/instance_test.go index b67baa0dac..dd1e22686b 100644 --- a/lib/runtime/wasmer/instance_test.go +++ b/lib/runtime/wasmer/instance_test.go @@ -27,15 +27,6 @@ func TestConcurrentRuntimeCalls(t *testing.T) { }() } -func TestPointerSize(t *testing.T) { - in := int64(8) + int64(32)<<32 - ptr, length := runtime.Int64ToPointerAndSize(in) - require.Equal(t, int32(8), ptr) - require.Equal(t, int32(32), length) - res := runtime.PointerAndSizeToInt64(ptr, length) - require.Equal(t, in, res) -} - func Test_GetRuntimeVersion(t *testing.T) { polkadotRuntimeFilepath, err := runtime.GetRuntime( context.Background(), runtime.POLKADOT_RUNTIME) From 95a7a3568969b430fd2d4ccbcc2954511d32add5 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Tue, 13 Sep 2022 15:22:43 +0530 Subject: [PATCH 16/49] merge fix --- lib/babe/babe_integration_test.go | 21 ++++++++++++++++----- lib/babe/build_integration_test.go | 3 ++- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 1249d38901..cbde9c60e1 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -62,6 +62,14 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { genesisHeader = genHeader var err error + if cfg.BlockImportHandler == nil { + blockImportHandler := new(mocks.BlockImportHandler) + blockImportHandler. + On("HandleBlockProduced", + mock.AnythingOfType("*types.Block"), mock.AnythingOfType("*storage.TrieState")). + Return(nil) + cfg.BlockImportHandler = blockImportHandler + } if cfg.Keypair == nil { cfg.Keypair = keyring.Alice().(*sr25519.Keypair) @@ -296,7 +304,7 @@ func TestService_PauseAndResume(t *testing.T) { } func TestService_HandleSlotWithLaggingSlot(t *testing.T) { - cfg := &ServiceConfig{ + cfg := ServiceConfig{ Authority: true, Lead: true, } @@ -358,7 +366,7 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { bob := keyring.Bob().(*sr25519.Keypair) // Create babe service for alice - cfgAlice := &ServiceConfig{ + cfgAlice := ServiceConfig{ Authority: true, Lead: true, Keypair: alice, @@ -375,7 +383,7 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { } // Create babe service for bob - cfgBob := &ServiceConfig{ + cfgBob := ServiceConfig{ Authority: true, Lead: true, Keypair: bob, @@ -403,14 +411,17 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { // create a block using bob parentHash := babeServiceBob.blockState.GenesisHash() - rt, err := babeServiceBob.blockState.GetRuntime(nil) + parentHeader, err := babeServiceBob.blockState.GetHeader(parentHash) + require.NoError(t, err) + + rt, err := babeServiceBob.blockState.GetRuntime(&parentHash) require.NoError(t, err) epochData, err := babeServiceBob.initiateEpoch(testEpochIndex) require.NoError(t, err) ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd}) - block := createTestBlock(t, babeServiceBob, emptyHeader, [][]byte{common.MustHexToBytes(ext)}, + block := createTestBlock(t, babeServiceBob, parentHeader, [][]byte{common.MustHexToBytes(ext)}, 1, testEpochIndex, epochData) err = babeServiceBob.Stop() diff --git a/lib/babe/build_integration_test.go b/lib/babe/build_integration_test.go index f1ac699221..23603ed7ee 100644 --- a/lib/babe/build_integration_test.go +++ b/lib/babe/build_integration_test.go @@ -59,7 +59,8 @@ func createTestBlock(t *testing.T, babeService *Service, parent *types.Header, exts [][]byte, slotNumber, epoch uint64, epochData *epochData) *types.Block { for _, ext := range exts { vtx := transaction.NewValidTransaction(ext, &transaction.Validity{}) - _, _ = babeService.transactionState.Push(vtx) + _, err := babeService.transactionState.Push(vtx) + require.NoError(t, err) } duration, err := time.ParseDuration("1s") From 11471e85eda6fc36eadb05c207988c82a05db873 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Thu, 15 Sep 2022 10:41:15 +0530 Subject: [PATCH 17/49] intermediate --- lib/babe/babe_integration_test.go | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index cbde9c60e1..4355c99022 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -416,13 +416,19 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { rt, err := babeServiceBob.blockState.GetRuntime(&parentHash) require.NoError(t, err) + time.Sleep(babeServiceBob.constants.slotDuration * 5) + + epochNumber := babeServiceBob.epochHandler.epochNumber - epochData, err := babeServiceBob.initiateEpoch(testEpochIndex) + epochData, err := babeServiceBob.initiateEpoch(epochNumber) + require.NoError(t, err) + + slotNumber, err := babeServiceBob.blockState.GetSlotForBlock(parentHash) require.NoError(t, err) ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd}) block := createTestBlock(t, babeServiceBob, parentHeader, [][]byte{common.MustHexToBytes(ext)}, - 1, testEpochIndex, epochData) + slotNumber+1, epochNumber, epochData) err = babeServiceBob.Stop() require.NoError(t, err) From e0109dcd732e0e77a8d56e5908426fb3ae82413e Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Thu, 15 Sep 2022 10:53:10 +0530 Subject: [PATCH 18/49] it probably fixes the test --- lib/babe/babe_integration_test.go | 21 ++------------------- 1 file changed, 2 insertions(+), 19 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 4355c99022..f94576d3a3 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -407,29 +407,12 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { _ = babeServiceBob.Stop() }() + // wait till bob creates a block time.Sleep(babeServiceBob.constants.slotDuration * 5) - // create a block using bob - parentHash := babeServiceBob.blockState.GenesisHash() - parentHeader, err := babeServiceBob.blockState.GetHeader(parentHash) + block, err := babeServiceBob.blockState.BestBlock() require.NoError(t, err) - rt, err := babeServiceBob.blockState.GetRuntime(&parentHash) - require.NoError(t, err) - time.Sleep(babeServiceBob.constants.slotDuration * 5) - - epochNumber := babeServiceBob.epochHandler.epochNumber - - epochData, err := babeServiceBob.initiateEpoch(epochNumber) - require.NoError(t, err) - - slotNumber, err := babeServiceBob.blockState.GetSlotForBlock(parentHash) - require.NoError(t, err) - - ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd}) - block := createTestBlock(t, babeServiceBob, parentHeader, [][]byte{common.MustHexToBytes(ext)}, - slotNumber+1, epochNumber, epochData) - err = babeServiceBob.Stop() require.NoError(t, err) From fdb1fd2f36b267405b745193a1a9ba718791b4ed Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Thu, 15 Sep 2022 19:06:11 +0530 Subject: [PATCH 19/49] Use a real block import handler --- dot/core/helpers_test.go | 155 ------------------------------ dot/core/mock_telemetry_test.go | 47 --------- dot/state/block_notify.go | 1 + lib/babe/babe_integration_test.go | 121 ++++++++++++++++++----- 4 files changed, 97 insertions(+), 227 deletions(-) delete mode 100644 dot/core/helpers_test.go delete mode 100644 dot/core/mock_telemetry_test.go diff --git a/dot/core/helpers_test.go b/dot/core/helpers_test.go deleted file mode 100644 index cfd82aaea6..0000000000 --- a/dot/core/helpers_test.go +++ /dev/null @@ -1,155 +0,0 @@ -// Copyright 2021 ChainSafe Systems (ON) -// SPDX-License-Identifier: LGPL-3.0-only - -package core - -import ( - "path/filepath" - "testing" - - "github.com/ChainSafe/gossamer/dot/state" - "github.com/ChainSafe/gossamer/internal/log" - "github.com/ChainSafe/gossamer/lib/common" - "github.com/ChainSafe/gossamer/lib/crypto/sr25519" - "github.com/ChainSafe/gossamer/lib/genesis" - "github.com/ChainSafe/gossamer/lib/keystore" - "github.com/ChainSafe/gossamer/lib/runtime" - rtstorage "github.com/ChainSafe/gossamer/lib/runtime/storage" - "github.com/ChainSafe/gossamer/lib/runtime/wasmer" - "github.com/ChainSafe/gossamer/lib/utils" - "github.com/golang/mock/gomock" - "github.com/stretchr/testify/require" -) - -// NewTestService creates a new test core service -func NewTestService(t *testing.T, cfg *Config) *Service { - t.Helper() - ctrl := gomock.NewController(t) - - if cfg == nil { - cfg = &Config{} - } - - if cfg.Keystore == nil { - cfg.Keystore = keystore.NewGlobalKeystore() - kp, err := sr25519.GenerateKeypair() - if err != nil { - t.Fatal(err) - } - err = cfg.Keystore.Acco.Insert(kp) - require.NoError(t, err) - } - - cfg.LogLvl = 3 - - var stateSrvc *state.Service - testDatadirPath := t.TempDir() - - gen, genTrie, genHeader := genesis.NewTestGenesisWithTrieAndHeader(t) - - if cfg.BlockState == nil || cfg.StorageState == nil || - cfg.TransactionState == nil || cfg.EpochState == nil || - cfg.CodeSubstitutedState == nil { - telemetryMock := NewMockClient(ctrl) - telemetryMock.EXPECT().SendMessage(gomock.Any()).AnyTimes() - - config := state.Config{ - Path: testDatadirPath, - LogLevel: log.Info, - Telemetry: telemetryMock, - } - - stateSrvc = state.NewService(config) - stateSrvc.UseMemDB() - - err := stateSrvc.Initialise(gen, genHeader, genTrie) - require.NoError(t, err) - - err = stateSrvc.Start() - require.NoError(t, err) - } - - if cfg.BlockState == nil { - cfg.BlockState = stateSrvc.Block - } - - if cfg.StorageState == nil { - cfg.StorageState = stateSrvc.Storage - } - - if cfg.TransactionState == nil { - cfg.TransactionState = stateSrvc.Transaction - } - - if cfg.EpochState == nil { - cfg.EpochState = stateSrvc.Epoch - } - - if cfg.CodeSubstitutedState == nil { - cfg.CodeSubstitutedState = stateSrvc.Base - } - - if cfg.Runtime == nil { - var rtCfg wasmer.Config - - rtCfg.Storage = rtstorage.NewTrieState(genTrie) - - var err error - rtCfg.CodeHash, err = cfg.StorageState.LoadCodeHash(nil) - require.NoError(t, err) - - nodeStorage := runtime.NodeStorage{} - - if stateSrvc != nil { - nodeStorage.BaseDB = stateSrvc.Base - } else { - nodeStorage.BaseDB, err = utils.SetupDatabase(filepath.Join(testDatadirPath, "offline_storage"), false) - require.NoError(t, err) - } - - rtCfg.NodeStorage = nodeStorage - - cfg.Runtime, err = wasmer.NewRuntimeFromGenesis(rtCfg) - require.NoError(t, err) - } - cfg.BlockState.StoreRuntime(cfg.BlockState.BestBlockHash(), cfg.Runtime) - - if cfg.CodeSubstitutes == nil { - cfg.CodeSubstitutes = make(map[common.Hash]string) - - genesisData, err := cfg.CodeSubstitutedState.(*state.BaseState).LoadGenesisData() - require.NoError(t, err) - - for k, v := range genesisData.CodeSubstitutes { - cfg.CodeSubstitutes[common.MustHexToHash(k)] = v - } - } - - if cfg.CodeSubstitutedState == nil { - cfg.CodeSubstitutedState = stateSrvc.Base - } - - s, err := NewService(cfg) - require.NoError(t, err) - - return s -} - -func getGssmrRuntimeCode(t *testing.T) (code []byte) { - t.Helper() - - path, err := utils.GetGssmrGenesisRawPath() - require.NoError(t, err) - - gssmrGenesis, err := genesis.NewGenesisFromJSONRaw(path) - require.NoError(t, err) - - trie, err := genesis.NewTrieFromGenesis(gssmrGenesis) - require.NoError(t, err) - - trieState := rtstorage.NewTrieState(trie) - - return trieState.LoadCode() -} - -func hashPtr(h common.Hash) *common.Hash { return &h } diff --git a/dot/core/mock_telemetry_test.go b/dot/core/mock_telemetry_test.go deleted file mode 100644 index a6462d87ea..0000000000 --- a/dot/core/mock_telemetry_test.go +++ /dev/null @@ -1,47 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/ChainSafe/gossamer/dot/telemetry (interfaces: Client) - -// Package core is a generated GoMock package. -package core - -import ( - reflect "reflect" - - telemetry "github.com/ChainSafe/gossamer/dot/telemetry" - gomock "github.com/golang/mock/gomock" -) - -// MockClient is a mock of Client interface. -type MockClient struct { - ctrl *gomock.Controller - recorder *MockClientMockRecorder -} - -// MockClientMockRecorder is the mock recorder for MockClient. -type MockClientMockRecorder struct { - mock *MockClient -} - -// NewMockClient creates a new mock instance. -func NewMockClient(ctrl *gomock.Controller) *MockClient { - mock := &MockClient{ctrl: ctrl} - mock.recorder = &MockClientMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockClient) EXPECT() *MockClientMockRecorder { - return m.recorder -} - -// SendMessage mocks base method. -func (m *MockClient) SendMessage(arg0 telemetry.Message) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "SendMessage", arg0) -} - -// SendMessage indicates an expected call of SendMessage. -func (mr *MockClientMockRecorder) SendMessage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockClient)(nil).SendMessage), arg0) -} diff --git a/dot/state/block_notify.go b/dot/state/block_notify.go index 168bd6b2d1..2475d3d9dd 100644 --- a/dot/state/block_notify.go +++ b/dot/state/block_notify.go @@ -68,6 +68,7 @@ func (bs *BlockState) notifyImported(block *types.Block) { } }(ch) } + } func (bs *BlockState) notifyFinalized(hash common.Hash, round, setID uint64) { diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index f94576d3a3..fa935c3098 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -7,10 +7,13 @@ package babe import ( "path/filepath" + reflect "reflect" "testing" "time" "github.com/ChainSafe/gossamer/dot/core" + "github.com/ChainSafe/gossamer/dot/network" + "github.com/ChainSafe/gossamer/dot/peerset" "github.com/ChainSafe/gossamer/dot/state" "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/internal/log" @@ -25,6 +28,7 @@ import ( "github.com/ChainSafe/gossamer/lib/utils" "github.com/ChainSafe/gossamer/pkg/scale" "github.com/golang/mock/gomock" + "github.com/libp2p/go-libp2p-core/peer" mock "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" @@ -62,14 +66,6 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { genesisHeader = genHeader var err error - if cfg.BlockImportHandler == nil { - blockImportHandler := new(mocks.BlockImportHandler) - blockImportHandler. - On("HandleBlockProduced", - mock.AnythingOfType("*types.Block"), mock.AnythingOfType("*storage.TrieState")). - Return(nil) - cfg.BlockImportHandler = blockImportHandler - } if cfg.Keypair == nil { cfg.Keypair = keyring.Alice().(*sr25519.Keypair) @@ -145,9 +141,89 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { cfg.LogLvl = defaultTestLogLvl babeService, err := NewService(&cfg) require.NoError(t, err) + + mockNetwork := NewMockNetwork(ctrl) + mockNetwork.EXPECT().GossipMessage(gomock.Any()).AnyTimes() + + coreConfig := core.Config{ + BlockState: dbSrv.Block, + EpochState: dbSrv.Epoch, + StorageState: storageState, + TransactionState: dbSrv.Transaction, + Runtime: rt, + Keystore: rtCfg.Keystore, + Network: mockNetwork, + CodeSubstitutedState: dbSrv.Base, + CodeSubstitutes: make(map[common.Hash]string), + } + + babeService.blockImportHandler = core.NewTestService(t, &coreConfig) + return babeService } +// TODO for Kishan: move to a separate file or reuse it +// MockNetwork is a mock of Network interface. +type MockNetwork struct { + ctrl *gomock.Controller + recorder *MockNetworkMockRecorder +} + +// MockNetworkMockRecorder is the mock recorder for MockNetwork. +type MockNetworkMockRecorder struct { + mock *MockNetwork +} + +// NewMockNetwork creates a new mock instance. +func NewMockNetwork(ctrl *gomock.Controller) *MockNetwork { + mock := &MockNetwork{ctrl: ctrl} + mock.recorder = &MockNetworkMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockNetwork) EXPECT() *MockNetworkMockRecorder { + return m.recorder +} + +// GossipMessage mocks base method. +func (m *MockNetwork) GossipMessage(arg0 network.NotificationsMessage) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "GossipMessage", arg0) +} + +// GossipMessage indicates an expected call of GossipMessage. +func (mr *MockNetworkMockRecorder) GossipMessage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GossipMessage", reflect.TypeOf((*MockNetwork)(nil).GossipMessage), arg0) +} + +// IsSynced mocks base method. +func (m *MockNetwork) IsSynced() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsSynced") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsSynced indicates an expected call of IsSynced. +func (mr *MockNetworkMockRecorder) IsSynced() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSynced", reflect.TypeOf((*MockNetwork)(nil).IsSynced)) +} + +// ReportPeer mocks base method. +func (m *MockNetwork) ReportPeer(arg0 peerset.ReputationChange, arg1 peer.ID) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "ReportPeer", arg0, arg1) +} + +// ReportPeer indicates an expected call of ReportPeer. +func (mr *MockNetworkMockRecorder) ReportPeer(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), arg0, arg1) +} + func newTestServiceSetupParameters(t *testing.T) (*Service, *state.EpochState, *types.BabeConfiguration) { ctrl := gomock.NewController(t) telemetryMock := NewMockClient(ctrl) @@ -408,31 +484,27 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { }() // wait till bob creates a block - time.Sleep(babeServiceBob.constants.slotDuration * 5) + time.Sleep(babeServiceBob.constants.slotDuration * 1) + require.NoError(t, err) - block, err := babeServiceBob.blockState.BestBlock() + block, err := babeServiceBob.blockState.GetBlockByNumber(1) require.NoError(t, err) err = babeServiceBob.Stop() require.NoError(t, err) - babeServiceAlice := createTestService(t, cfgAlice) + time.Sleep(babeServiceBob.constants.slotDuration * 1) - err = babeServiceAlice.Start() - require.NoError(t, err) - defer func() { - _ = babeServiceAlice.Stop() - }() - time.Sleep(babeServiceAlice.constants.slotDuration * 1) + babeServiceAlice := createTestService(t, cfgAlice) // Add block created by Bob to Alice - babeServiceAlice.blockState.AddBlock(block) + err = babeServiceAlice.blockState.AddBlock(block) + require.NoError(t, err) - time.Sleep(babeServiceAlice.constants.slotDuration * 1) + time.Sleep(babeServiceBob.constants.slotDuration * 1) bestBlockHeader, err := babeServiceAlice.blockState.BestBlockHeader() require.NoError(t, err) - require.Equal(t, block.Header.Hash().String(), bestBlockHeader.Hash().String()) // If the slot we are claiming is same as slot in best header, test that we don't @@ -440,9 +512,6 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { bestBlockSlotNum, err := babeServiceAlice.blockState.GetSlotForBlock(bestBlockHeader.Hash()) require.NoError(t, err) - err = babeServiceAlice.Stop() - require.NoError(t, err) - slot := Slot{ start: time.Now(), duration: 1 * time.Second, @@ -456,10 +525,12 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { ).ToPreRuntimeDigest() require.NoError(t, err) + // slot gets occupied even if it has been occupied by a block + // authored by someone else err = babeServiceAlice.handleSlot( - babeServiceAlice.epochHandler.epochNumber, + testEpochIndex, bestBlockSlotNum, - babeServiceAlice.epochHandler.epochData.authorityIndex, + 0, preRuntimeDigest) require.NoError(t, err) From 388678a2ff032094108baf3516c278c7ab8a726f Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Fri, 16 Sep 2022 12:02:10 +0530 Subject: [PATCH 20/49] more fix --- dot/core/mock_telemetry.go | 47 +++++++++++ dot/core/test_helpers.go | 155 +++++++++++++++++++++++++++++++++++++ 2 files changed, 202 insertions(+) create mode 100644 dot/core/mock_telemetry.go create mode 100644 dot/core/test_helpers.go diff --git a/dot/core/mock_telemetry.go b/dot/core/mock_telemetry.go new file mode 100644 index 0000000000..a6462d87ea --- /dev/null +++ b/dot/core/mock_telemetry.go @@ -0,0 +1,47 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/ChainSafe/gossamer/dot/telemetry (interfaces: Client) + +// Package core is a generated GoMock package. +package core + +import ( + reflect "reflect" + + telemetry "github.com/ChainSafe/gossamer/dot/telemetry" + gomock "github.com/golang/mock/gomock" +) + +// MockClient is a mock of Client interface. +type MockClient struct { + ctrl *gomock.Controller + recorder *MockClientMockRecorder +} + +// MockClientMockRecorder is the mock recorder for MockClient. +type MockClientMockRecorder struct { + mock *MockClient +} + +// NewMockClient creates a new mock instance. +func NewMockClient(ctrl *gomock.Controller) *MockClient { + mock := &MockClient{ctrl: ctrl} + mock.recorder = &MockClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder +} + +// SendMessage mocks base method. +func (m *MockClient) SendMessage(arg0 telemetry.Message) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SendMessage", arg0) +} + +// SendMessage indicates an expected call of SendMessage. +func (mr *MockClientMockRecorder) SendMessage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockClient)(nil).SendMessage), arg0) +} diff --git a/dot/core/test_helpers.go b/dot/core/test_helpers.go new file mode 100644 index 0000000000..cfd82aaea6 --- /dev/null +++ b/dot/core/test_helpers.go @@ -0,0 +1,155 @@ +// Copyright 2021 ChainSafe Systems (ON) +// SPDX-License-Identifier: LGPL-3.0-only + +package core + +import ( + "path/filepath" + "testing" + + "github.com/ChainSafe/gossamer/dot/state" + "github.com/ChainSafe/gossamer/internal/log" + "github.com/ChainSafe/gossamer/lib/common" + "github.com/ChainSafe/gossamer/lib/crypto/sr25519" + "github.com/ChainSafe/gossamer/lib/genesis" + "github.com/ChainSafe/gossamer/lib/keystore" + "github.com/ChainSafe/gossamer/lib/runtime" + rtstorage "github.com/ChainSafe/gossamer/lib/runtime/storage" + "github.com/ChainSafe/gossamer/lib/runtime/wasmer" + "github.com/ChainSafe/gossamer/lib/utils" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/require" +) + +// NewTestService creates a new test core service +func NewTestService(t *testing.T, cfg *Config) *Service { + t.Helper() + ctrl := gomock.NewController(t) + + if cfg == nil { + cfg = &Config{} + } + + if cfg.Keystore == nil { + cfg.Keystore = keystore.NewGlobalKeystore() + kp, err := sr25519.GenerateKeypair() + if err != nil { + t.Fatal(err) + } + err = cfg.Keystore.Acco.Insert(kp) + require.NoError(t, err) + } + + cfg.LogLvl = 3 + + var stateSrvc *state.Service + testDatadirPath := t.TempDir() + + gen, genTrie, genHeader := genesis.NewTestGenesisWithTrieAndHeader(t) + + if cfg.BlockState == nil || cfg.StorageState == nil || + cfg.TransactionState == nil || cfg.EpochState == nil || + cfg.CodeSubstitutedState == nil { + telemetryMock := NewMockClient(ctrl) + telemetryMock.EXPECT().SendMessage(gomock.Any()).AnyTimes() + + config := state.Config{ + Path: testDatadirPath, + LogLevel: log.Info, + Telemetry: telemetryMock, + } + + stateSrvc = state.NewService(config) + stateSrvc.UseMemDB() + + err := stateSrvc.Initialise(gen, genHeader, genTrie) + require.NoError(t, err) + + err = stateSrvc.Start() + require.NoError(t, err) + } + + if cfg.BlockState == nil { + cfg.BlockState = stateSrvc.Block + } + + if cfg.StorageState == nil { + cfg.StorageState = stateSrvc.Storage + } + + if cfg.TransactionState == nil { + cfg.TransactionState = stateSrvc.Transaction + } + + if cfg.EpochState == nil { + cfg.EpochState = stateSrvc.Epoch + } + + if cfg.CodeSubstitutedState == nil { + cfg.CodeSubstitutedState = stateSrvc.Base + } + + if cfg.Runtime == nil { + var rtCfg wasmer.Config + + rtCfg.Storage = rtstorage.NewTrieState(genTrie) + + var err error + rtCfg.CodeHash, err = cfg.StorageState.LoadCodeHash(nil) + require.NoError(t, err) + + nodeStorage := runtime.NodeStorage{} + + if stateSrvc != nil { + nodeStorage.BaseDB = stateSrvc.Base + } else { + nodeStorage.BaseDB, err = utils.SetupDatabase(filepath.Join(testDatadirPath, "offline_storage"), false) + require.NoError(t, err) + } + + rtCfg.NodeStorage = nodeStorage + + cfg.Runtime, err = wasmer.NewRuntimeFromGenesis(rtCfg) + require.NoError(t, err) + } + cfg.BlockState.StoreRuntime(cfg.BlockState.BestBlockHash(), cfg.Runtime) + + if cfg.CodeSubstitutes == nil { + cfg.CodeSubstitutes = make(map[common.Hash]string) + + genesisData, err := cfg.CodeSubstitutedState.(*state.BaseState).LoadGenesisData() + require.NoError(t, err) + + for k, v := range genesisData.CodeSubstitutes { + cfg.CodeSubstitutes[common.MustHexToHash(k)] = v + } + } + + if cfg.CodeSubstitutedState == nil { + cfg.CodeSubstitutedState = stateSrvc.Base + } + + s, err := NewService(cfg) + require.NoError(t, err) + + return s +} + +func getGssmrRuntimeCode(t *testing.T) (code []byte) { + t.Helper() + + path, err := utils.GetGssmrGenesisRawPath() + require.NoError(t, err) + + gssmrGenesis, err := genesis.NewGenesisFromJSONRaw(path) + require.NoError(t, err) + + trie, err := genesis.NewTrieFromGenesis(gssmrGenesis) + require.NoError(t, err) + + trieState := rtstorage.NewTrieState(trie) + + return trieState.LoadCode() +} + +func hashPtr(h common.Hash) *common.Hash { return &h } From 0862104d15d0a1a975b88324bf0e2e8ec420718e Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Fri, 16 Sep 2022 14:12:20 +0530 Subject: [PATCH 21/49] improved createTestService --- lib/babe/babe_integration_test.go | 67 +++++++++++++++--------------- lib/babe/build_integration_test.go | 42 ++----------------- 2 files changed, 37 insertions(+), 72 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index fa935c3098..57bc614118 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -93,29 +93,27 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { require.NoError(t, err) var dbSrv *state.Service - if cfg.BlockState == nil || cfg.StorageState == nil || cfg.EpochState == nil { - config := state.Config{ - Path: testDatadirPath, - LogLevel: log.Info, - Telemetry: telemetryMock, - } - dbSrv = state.NewService(config) - dbSrv.UseMemDB() + config := state.Config{ + Path: testDatadirPath, + LogLevel: log.Info, + Telemetry: telemetryMock, + } + dbSrv = state.NewService(config) + dbSrv.UseMemDB() - err = dbSrv.Initialise(gen, genHeader, genTrie) - require.NoError(t, err) + err = dbSrv.Initialise(gen, genHeader, genTrie) + require.NoError(t, err) - err = dbSrv.Start() - require.NoError(t, err) + err = dbSrv.Start() + require.NoError(t, err) - t.Cleanup(func() { - _ = dbSrv.Stop() - }) + t.Cleanup(func() { + _ = dbSrv.Stop() + }) - cfg.BlockState = dbSrv.Block - cfg.StorageState = dbSrv.Storage - cfg.EpochState = dbSrv.Epoch - } + cfg.BlockState = dbSrv.Block + cfg.StorageState = dbSrv.Storage + cfg.EpochState = dbSrv.Epoch var rtCfg wasmer.Config rtCfg.Storage = rtstorage.NewTrieState(genTrie) @@ -195,7 +193,8 @@ func (m *MockNetwork) GossipMessage(arg0 network.NotificationsMessage) { // GossipMessage indicates an expected call of GossipMessage. func (mr *MockNetworkMockRecorder) GossipMessage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GossipMessage", reflect.TypeOf((*MockNetwork)(nil).GossipMessage), arg0) + return mr.mock.ctrl.RecordCallWithMethodType( + mr.mock, "GossipMessage", reflect.TypeOf((*MockNetwork)(nil).GossipMessage), arg0) } // IsSynced mocks base method. @@ -209,7 +208,8 @@ func (m *MockNetwork) IsSynced() bool { // IsSynced indicates an expected call of IsSynced. func (mr *MockNetworkMockRecorder) IsSynced() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSynced", reflect.TypeOf((*MockNetwork)(nil).IsSynced)) + return mr.mock.ctrl.RecordCallWithMethodType( + mr.mock, "IsSynced", reflect.TypeOf((*MockNetwork)(nil).IsSynced)) } // ReportPeer mocks base method. @@ -221,7 +221,8 @@ func (m *MockNetwork) ReportPeer(arg0 peerset.ReputationChange, arg1 peer.ID) { // ReportPeer indicates an expected call of ReportPeer. func (mr *MockNetworkMockRecorder) ReportPeer(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType( + mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), arg0, arg1) } func newTestServiceSetupParameters(t *testing.T) (*Service, *state.EpochState, *types.BabeConfiguration) { @@ -282,15 +283,15 @@ func TestService_SlotDuration(t *testing.T) { } func TestService_ProducesBlocks(t *testing.T) { - blockImportHandler := mocks.NewBlockImportHandler(t) - blockImportHandler. - On("HandleBlockProduced", - mock.AnythingOfType("*types.Block"), mock.AnythingOfType("*storage.TrieState")). - Return(nil) + // blockImportHandler := mocks.NewBlockImportHandler(t) + // blockImportHandler. + // On("HandleBlockProduced", + // mock.AnythingOfType("*types.Block"), mock.AnythingOfType("*storage.TrieState")). + // Return(nil) cfg := ServiceConfig{ - Authority: true, - Lead: true, - BlockImportHandler: blockImportHandler, + Authority: true, + Lead: true, + // BlockImportHandler: blockImportHandler, } babeService := createTestService(t, cfg) @@ -342,8 +343,7 @@ func TestService_GetAuthorityIndex(t *testing.T) { } func TestStartAndStop(t *testing.T) { - serviceConfig := ServiceConfig{} - bs := createTestService(t, serviceConfig) + bs := createTestService(t, ServiceConfig{}) err := bs.Start() require.NoError(t, err) err = bs.Stop() @@ -351,8 +351,7 @@ func TestStartAndStop(t *testing.T) { } func TestService_PauseAndResume(t *testing.T) { - serviceConfig := ServiceConfig{} - bs := createTestService(t, serviceConfig) + bs := createTestService(t, ServiceConfig{}) err := bs.Start() require.NoError(t, err) time.Sleep(time.Second) diff --git a/lib/babe/build_integration_test.go b/lib/babe/build_integration_test.go index 23603ed7ee..94e98b16f6 100644 --- a/lib/babe/build_integration_test.go +++ b/lib/babe/build_integration_test.go @@ -10,14 +10,12 @@ import ( "testing" "time" - "github.com/ChainSafe/gossamer/dot/state" "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/crypto/sr25519" "github.com/ChainSafe/gossamer/lib/runtime" "github.com/ChainSafe/gossamer/lib/transaction" "github.com/ChainSafe/gossamer/pkg/scale" - "github.com/golang/mock/gomock" cscale "github.com/centrifuge/go-substrate-rpc-client/v4/scale" "github.com/centrifuge/go-substrate-rpc-client/v4/signature" @@ -88,15 +86,7 @@ func createTestBlock(t *testing.T, babeService *Service, parent *types.Header, // TODO: add test against latest dev runtime // See https://github.com/ChainSafe/gossamer/issues/2704 func TestBuildBlock_ok(t *testing.T) { - ctrl := gomock.NewController(t) - telemetryMock := NewMockClient(ctrl) - telemetryMock.EXPECT().SendMessage(gomock.Any()).AnyTimes() - - cfg := ServiceConfig{ - TransactionState: state.NewTransactionState(telemetryMock), - } - - babeService := createTestService(t, cfg) + babeService := createTestService(t, ServiceConfig{}) parentHash := babeService.blockState.GenesisHash() rt, err := babeService.blockState.GetRuntime(nil) @@ -128,15 +118,7 @@ func TestBuildBlock_ok(t *testing.T) { // TODO: add test against latest dev runtime // See https://github.com/ChainSafe/gossamer/issues/2704 func TestApplyExtrinsic(t *testing.T) { - ctrl := gomock.NewController(t) - telemetryMock := NewMockClient(ctrl) - telemetryMock.EXPECT().SendMessage(gomock.Any()).AnyTimes() - - cfg := ServiceConfig{ - TransactionState: state.NewTransactionState(telemetryMock), - } - - babeService := createTestService(t, cfg) + babeService := createTestService(t, ServiceConfig{}) const authorityIndex = 0 duration, err := time.ParseDuration("1s") @@ -223,15 +205,7 @@ func TestApplyExtrinsic(t *testing.T) { // TODO: add test against latest dev runtime // See https://github.com/ChainSafe/gossamer/issues/2704 func TestBuildAndApplyExtrinsic(t *testing.T) { - ctrl := gomock.NewController(t) - telemetryMock := NewMockClient(ctrl) - telemetryMock.EXPECT().SendMessage(gomock.Any()).AnyTimes() - - cfg := ServiceConfig{ - TransactionState: state.NewTransactionState(telemetryMock), - } - - babeService := createTestService(t, cfg) + babeService := createTestService(t, ServiceConfig{}) parentHash := common.MustHexToHash("0x35a28a7dbaf0ba07d1485b0f3da7757e3880509edc8c31d0850cb6dd6219361d") header, err := types.NewHeader(parentHash, common.Hash{}, common.Hash{}, 1, types.NewDigest()) @@ -303,15 +277,7 @@ func TestBuildAndApplyExtrinsic(t *testing.T) { func TestBuildBlock_failing(t *testing.T) { t.Skip() - ctrl := gomock.NewController(t) - telemetryMock := NewMockClient(ctrl) - telemetryMock.EXPECT().SendMessage(gomock.Any()).AnyTimes() - - cfg := ServiceConfig{ - TransactionState: state.NewTransactionState(telemetryMock), - } - - babeService := createTestService(t, cfg) + babeService := createTestService(t, ServiceConfig{}) // see https://github.com/noot/substrate/blob/add-blob/core/test-runtime/src/system.rs#L468 // add a valid transaction From 26f87694935954c29493dfdd35f19ac9dc59c91d Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Fri, 16 Sep 2022 14:34:55 +0530 Subject: [PATCH 22/49] reuse network mocks --- dot/core/{mocks_test.go => mocks.go} | 0 dot/core/mocks_generate.go | 6 ++ dot/core/mocks_generate_test.go | 6 -- ...mocks_runtime_test.go => mocks_runtime.go} | 0 lib/babe/babe_integration_test.go | 84 +------------------ 5 files changed, 8 insertions(+), 88 deletions(-) rename dot/core/{mocks_test.go => mocks.go} (100%) create mode 100644 dot/core/mocks_generate.go delete mode 100644 dot/core/mocks_generate_test.go rename dot/core/{mocks_runtime_test.go => mocks_runtime.go} (100%) diff --git a/dot/core/mocks_test.go b/dot/core/mocks.go similarity index 100% rename from dot/core/mocks_test.go rename to dot/core/mocks.go diff --git a/dot/core/mocks_generate.go b/dot/core/mocks_generate.go new file mode 100644 index 0000000000..d7c1cff2c4 --- /dev/null +++ b/dot/core/mocks_generate.go @@ -0,0 +1,6 @@ +// Copyright 2022 ChainSafe Systems (ON) +// SPDX-License-Identifier: LGPL-3.0-only + +package core + +//go:generate mockgen -destination=mocks.go -package $GOPACKAGE . BlockState,StorageState,TransactionState,Network,EpochState,CodeSubstitutedState,RuntimeInstance diff --git a/dot/core/mocks_generate_test.go b/dot/core/mocks_generate_test.go deleted file mode 100644 index 9a33173f78..0000000000 --- a/dot/core/mocks_generate_test.go +++ /dev/null @@ -1,6 +0,0 @@ -// Copyright 2022 ChainSafe Systems (ON) -// SPDX-License-Identifier: LGPL-3.0-only - -package core - -//go:generate mockgen -destination=mocks_test.go -package $GOPACKAGE . BlockState,StorageState,TransactionState,Network,EpochState,CodeSubstitutedState,RuntimeInstance diff --git a/dot/core/mocks_runtime_test.go b/dot/core/mocks_runtime.go similarity index 100% rename from dot/core/mocks_runtime_test.go rename to dot/core/mocks_runtime.go diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 57bc614118..48b0dc7e27 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -6,14 +6,10 @@ package babe import ( - "path/filepath" - reflect "reflect" "testing" "time" "github.com/ChainSafe/gossamer/dot/core" - "github.com/ChainSafe/gossamer/dot/network" - "github.com/ChainSafe/gossamer/dot/peerset" "github.com/ChainSafe/gossamer/dot/state" "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/internal/log" @@ -25,10 +21,8 @@ import ( rtstorage "github.com/ChainSafe/gossamer/lib/runtime/storage" "github.com/ChainSafe/gossamer/lib/runtime/wasmer" "github.com/ChainSafe/gossamer/lib/trie" - "github.com/ChainSafe/gossamer/lib/utils" "github.com/ChainSafe/gossamer/pkg/scale" "github.com/golang/mock/gomock" - "github.com/libp2p/go-libp2p-core/peer" mock "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" @@ -85,10 +79,6 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { cfg.Telemetry = telemetryMock - if cfg.TransactionState == nil { - cfg.TransactionState = state.NewTransactionState(telemetryMock) - } - testDatadirPath := t.TempDir() require.NoError(t, err) @@ -123,12 +113,7 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { require.NoError(t, err) nodeStorage := runtime.NodeStorage{} - if dbSrv != nil { - nodeStorage.BaseDB = dbSrv.Base - } else { - nodeStorage.BaseDB, err = utils.SetupDatabase(filepath.Join(testDatadirPath, "offline_storage"), false) - require.NoError(t, err) - } + nodeStorage.BaseDB = dbSrv.Base rtCfg.NodeStorage = nodeStorage rt, err := wasmer.NewRuntimeFromGenesis(rtCfg) @@ -140,7 +125,7 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { babeService, err := NewService(&cfg) require.NoError(t, err) - mockNetwork := NewMockNetwork(ctrl) + mockNetwork := core.NewMockNetwork(ctrl) mockNetwork.EXPECT().GossipMessage(gomock.Any()).AnyTimes() coreConfig := core.Config{ @@ -160,71 +145,6 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { return babeService } -// TODO for Kishan: move to a separate file or reuse it -// MockNetwork is a mock of Network interface. -type MockNetwork struct { - ctrl *gomock.Controller - recorder *MockNetworkMockRecorder -} - -// MockNetworkMockRecorder is the mock recorder for MockNetwork. -type MockNetworkMockRecorder struct { - mock *MockNetwork -} - -// NewMockNetwork creates a new mock instance. -func NewMockNetwork(ctrl *gomock.Controller) *MockNetwork { - mock := &MockNetwork{ctrl: ctrl} - mock.recorder = &MockNetworkMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockNetwork) EXPECT() *MockNetworkMockRecorder { - return m.recorder -} - -// GossipMessage mocks base method. -func (m *MockNetwork) GossipMessage(arg0 network.NotificationsMessage) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "GossipMessage", arg0) -} - -// GossipMessage indicates an expected call of GossipMessage. -func (mr *MockNetworkMockRecorder) GossipMessage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType( - mr.mock, "GossipMessage", reflect.TypeOf((*MockNetwork)(nil).GossipMessage), arg0) -} - -// IsSynced mocks base method. -func (m *MockNetwork) IsSynced() bool { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsSynced") - ret0, _ := ret[0].(bool) - return ret0 -} - -// IsSynced indicates an expected call of IsSynced. -func (mr *MockNetworkMockRecorder) IsSynced() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType( - mr.mock, "IsSynced", reflect.TypeOf((*MockNetwork)(nil).IsSynced)) -} - -// ReportPeer mocks base method. -func (m *MockNetwork) ReportPeer(arg0 peerset.ReputationChange, arg1 peer.ID) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "ReportPeer", arg0, arg1) -} - -// ReportPeer indicates an expected call of ReportPeer. -func (mr *MockNetworkMockRecorder) ReportPeer(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType( - mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), arg0, arg1) -} - func newTestServiceSetupParameters(t *testing.T) (*Service, *state.EpochState, *types.BabeConfiguration) { ctrl := gomock.NewController(t) telemetryMock := NewMockClient(ctrl) From 22d9b2caf6652df0beafe5bfa2837e5d65e14cc2 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Fri, 16 Sep 2022 15:21:16 +0530 Subject: [PATCH 23/49] more fix --- lib/babe/babe_integration_test.go | 49 ++++++++++++++++--------------- 1 file changed, 26 insertions(+), 23 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 48b0dc7e27..8868f8a696 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -24,7 +24,7 @@ import ( "github.com/ChainSafe/gossamer/pkg/scale" "github.com/golang/mock/gomock" - mock "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" ) @@ -104,6 +104,7 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { cfg.BlockState = dbSrv.Block cfg.StorageState = dbSrv.Storage cfg.EpochState = dbSrv.Epoch + cfg.TransactionState = dbSrv.Transaction var rtCfg wasmer.Config rtCfg.Storage = rtstorage.NewTrieState(genTrie) @@ -125,23 +126,25 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { babeService, err := NewService(&cfg) require.NoError(t, err) - mockNetwork := core.NewMockNetwork(ctrl) - mockNetwork.EXPECT().GossipMessage(gomock.Any()).AnyTimes() + if cfg.BlockImportHandler == nil { + mockNetwork := core.NewMockNetwork(ctrl) + mockNetwork.EXPECT().GossipMessage(gomock.Any()).AnyTimes() + + coreConfig := core.Config{ + BlockState: dbSrv.Block, + EpochState: dbSrv.Epoch, + StorageState: storageState, + TransactionState: dbSrv.Transaction, + Runtime: rt, + Keystore: rtCfg.Keystore, + Network: mockNetwork, + CodeSubstitutedState: dbSrv.Base, + CodeSubstitutes: make(map[common.Hash]string), + } - coreConfig := core.Config{ - BlockState: dbSrv.Block, - EpochState: dbSrv.Epoch, - StorageState: storageState, - TransactionState: dbSrv.Transaction, - Runtime: rt, - Keystore: rtCfg.Keystore, - Network: mockNetwork, - CodeSubstitutedState: dbSrv.Base, - CodeSubstitutes: make(map[common.Hash]string), + babeService.blockImportHandler = core.NewTestService(t, &coreConfig) } - babeService.blockImportHandler = core.NewTestService(t, &coreConfig) - return babeService } @@ -203,15 +206,15 @@ func TestService_SlotDuration(t *testing.T) { } func TestService_ProducesBlocks(t *testing.T) { - // blockImportHandler := mocks.NewBlockImportHandler(t) - // blockImportHandler. - // On("HandleBlockProduced", - // mock.AnythingOfType("*types.Block"), mock.AnythingOfType("*storage.TrieState")). - // Return(nil) + blockImportHandler := mocks.NewBlockImportHandler(t) + blockImportHandler. + On("HandleBlockProduced", + mock.AnythingOfType("*types.Block"), mock.AnythingOfType("*storage.TrieState")). + Return(nil) cfg := ServiceConfig{ - Authority: true, - Lead: true, - // BlockImportHandler: blockImportHandler, + Authority: true, + Lead: true, + BlockImportHandler: blockImportHandler, } babeService := createTestService(t, cfg) From 3e2aa7f32bf9a82d38f873d6b1082df3f97752c5 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:40:22 +0800 Subject: [PATCH 24/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 8868f8a696..269d426148 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -427,7 +427,7 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { bestBlockHeader, err := babeServiceAlice.blockState.BestBlockHeader() require.NoError(t, err) - require.Equal(t, block.Header.Hash().String(), bestBlockHeader.Hash().String()) + require.Equal(t, block.Header.Hash(), bestBlockHeader.Hash()) // If the slot we are claiming is same as slot in best header, test that we don't // through any error and can claim slot. From 1589dc99f550b5436d31a28ce84d4f8f43f595f2 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:41:00 +0800 Subject: [PATCH 25/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 269d426148..055116bcac 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -429,8 +429,8 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { require.NoError(t, err) require.Equal(t, block.Header.Hash(), bestBlockHeader.Hash()) - // If the slot we are claiming is same as slot in best header, test that we don't - // through any error and can claim slot. + // If the slot we are claiming is the same as the slot of the best block header, test that we can + // still claim the slot without error. bestBlockSlotNum, err := babeServiceAlice.blockState.GetSlotForBlock(bestBlockHeader.Hash()) require.NoError(t, err) From 8ec533cf84ce261ed32ea85b5cb15c41dd667b88 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:41:08 +0800 Subject: [PATCH 26/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 055116bcac..c102b22567 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -436,7 +436,7 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { slot := Slot{ start: time.Now(), - duration: 1 * time.Second, + duration: time.Second, number: bestBlockSlotNum, } testVRFOutputAndProof := &VrfOutputAndProof{} From 844886391d9c393f237e53c8ab1ec3cfab74fd93 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:42:57 +0800 Subject: [PATCH 27/49] Update lib/babe/babe.go Co-authored-by: Quentin McGaw --- lib/babe/babe.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index 14d65e7fee..83a44651f4 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -475,7 +475,8 @@ func (b *Service) handleSlot(epoch, slotNum uint64, } if bestBlockSlotNum > slotNum { - return errLaggingSlot + return fmt.Errorf("%w: best block slot number is %d and got slot number %d", + errLaggingSlot, bestBlockSlotNum, slotNum) } if bestBlockSlotNum == slotNum { From ce9e19504a95f87e8d28025c9bf28471a1401504 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:43:57 +0800 Subject: [PATCH 28/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index c102b22567..00bd30f01d 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -327,7 +327,7 @@ func TestService_HandleSlotWithLaggingSlot(t *testing.T) { 1, testEpochIndex, epochData) babeService.blockState.AddBlock(block) - time.Sleep(babeService.constants.slotDuration * 1) + time.Sleep(babeService.constants.slotDuration) header, err := babeService.blockState.BestBlockHeader() require.NoError(t, err) From bcdf2b569ed07bd6947d6539c1eab0ec7aedcd85 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:44:09 +0800 Subject: [PATCH 29/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 00bd30f01d..85de588805 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -338,7 +338,7 @@ func TestService_HandleSlotWithLaggingSlot(t *testing.T) { slotnum := uint64(1) slot := Slot{ start: time.Now(), - duration: 1 * time.Second, + duration: time.Second, number: slotnum, } testVRFOutputAndProof := &VrfOutputAndProof{} From 9a9f26dbfcd5404ed055d327f246028f9f8f77a5 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:44:35 +0800 Subject: [PATCH 30/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 85de588805..bfe91fb595 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -415,7 +415,7 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { err = babeServiceBob.Stop() require.NoError(t, err) - time.Sleep(babeServiceBob.constants.slotDuration * 1) + time.Sleep(babeServiceBob.constants.slotDuration) babeServiceAlice := createTestService(t, cfgAlice) From b065fb890561e4de3e95bb058481ab91f28010df Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:44:47 +0800 Subject: [PATCH 31/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index bfe91fb595..14b6ca1cef 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -423,7 +423,7 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { err = babeServiceAlice.blockState.AddBlock(block) require.NoError(t, err) - time.Sleep(babeServiceBob.constants.slotDuration * 1) + time.Sleep(babeServiceBob.constants.slotDuration) bestBlockHeader, err := babeServiceAlice.blockState.BestBlockHeader() require.NoError(t, err) From 264db416f366af9c41656784dd7f519099392d07 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 19 Sep 2022 17:45:28 +0800 Subject: [PATCH 32/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 14b6ca1cef..d90910d54a 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -311,7 +311,8 @@ func TestService_HandleSlotWithLaggingSlot(t *testing.T) { err := babeService.Start() require.NoError(t, err) defer func() { - _ = babeService.Stop() + err = babeService.Stop() + require.NoError(t, err) }() // add a block From 24e69e6211e2e9f3ac364729ebb7254897b7b694 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 15:37:44 +0800 Subject: [PATCH 33/49] Update dot/state/block_notify.go Co-authored-by: Quentin McGaw --- dot/state/block_notify.go | 1 - 1 file changed, 1 deletion(-) diff --git a/dot/state/block_notify.go b/dot/state/block_notify.go index 2475d3d9dd..168bd6b2d1 100644 --- a/dot/state/block_notify.go +++ b/dot/state/block_notify.go @@ -68,7 +68,6 @@ func (bs *BlockState) notifyImported(block *types.Block) { } }(ch) } - } func (bs *BlockState) notifyFinalized(hash common.Hash, round, setID uint64) { From 2fd728a946a1dab327d873c8b052fc83eb39be30 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 15:40:38 +0800 Subject: [PATCH 34/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index d90910d54a..30c2f414d5 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -369,15 +369,15 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { Authority: true, Lead: true, Keypair: alice, - } - cfgAlice.AuthData = []types.Authority{ - { - Key: alice.Public().(*sr25519.PublicKey), - Weight: 1, - }, - { - Key: bob.Public().(*sr25519.PublicKey), - Weight: 1, + AuthData: []types.Authority{ + { + Key: alice.Public().(*sr25519.PublicKey), + Weight: 1, + }, + { + Key: bob.Public().(*sr25519.PublicKey), + Weight: 1, + }, }, } From 34800ee9b13e840c4af73cca282c4949846686de Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 16:04:09 +0800 Subject: [PATCH 35/49] Update lib/babe/babe.go Co-authored-by: Quentin McGaw --- lib/babe/babe.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index 83a44651f4..a1c5bab69e 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -483,7 +483,7 @@ func (b *Service) handleSlot(epoch, slotNum uint64, // pick parent of best block instead to handle slot newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash) if err != nil { - return fmt.Errorf("could not get header for hash %s: %w", parentHeader.ParentHash, err) + return fmt.Errorf("could not get header: %w", err) } if newParentHeader == nil { return errNilParentHeader From 8155d436366680ba6faee61d2bed563532d1e380 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 16:05:47 +0800 Subject: [PATCH 36/49] Update lib/babe/babe.go Co-authored-by: Quentin McGaw --- lib/babe/babe.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index a1c5bab69e..eee12c7a5a 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -486,7 +486,7 @@ func (b *Service) handleSlot(epoch, slotNum uint64, return fmt.Errorf("could not get header: %w", err) } if newParentHeader == nil { - return errNilParentHeader + return fmt.Errorf("%w: for block hash %s", errNilParentHeader, parentHeader.ParentHash) } parentHeader = newParentHeader } From d0b2a1b4b4afac7bce9e1fed37138dee050593b3 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 16:06:59 +0800 Subject: [PATCH 37/49] Update lib/babe/babe.go Co-authored-by: Quentin McGaw --- lib/babe/babe.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index eee12c7a5a..51e7c6ad56 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -471,7 +471,7 @@ func (b *Service) handleSlot(epoch, slotNum uint64, if !atGenesisBlock { bestBlockSlotNum, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) if err != nil { - return fmt.Errorf("could not get slot for block %s: %w", parentHeader.Hash(), err) + return fmt.Errorf("could not get slot for block: %w", err) } if bestBlockSlotNum > slotNum { From 03db54db8488535e613f615fdb912a2f50ce0df4 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 18:38:50 +0800 Subject: [PATCH 38/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index d3d83b6c7b..fa9bf0be7f 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -441,11 +441,10 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { duration: time.Second, number: bestBlockSlotNum, } - testVRFOutputAndProof := &VrfOutputAndProof{} preRuntimeDigest, err := types.NewBabePrimaryPreDigest( 0, slot.number, - testVRFOutputAndProof.output, - testVRFOutputAndProof.proof, + [sr25519.VRFOutputLength]byte{}, + [sr25519.VRFProofLength]byte{}, ).ToPreRuntimeDigest() require.NoError(t, err) From 45b5fd3e972286207df48180974fadfda953fe00 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 18:38:57 +0800 Subject: [PATCH 39/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index fa9bf0be7f..97dec29dfd 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -343,11 +343,10 @@ func TestService_HandleSlotWithLaggingSlot(t *testing.T) { duration: time.Second, number: slotnum, } - testVRFOutputAndProof := &VrfOutputAndProof{} preRuntimeDigest, err := types.NewBabePrimaryPreDigest( 0, slot.number, - testVRFOutputAndProof.output, - testVRFOutputAndProof.proof, + [sr25519.VRFOutputLength]byte, + [sr25519.VRFProofLength]byte, ).ToPreRuntimeDigest() require.NoError(t, err) From a71de072dcd1138394a43c0e144210fc3b8b7adc Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 20:48:57 +0800 Subject: [PATCH 40/49] Update lib/babe/errors.go Co-authored-by: Quentin McGaw --- lib/babe/errors.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/errors.go b/lib/babe/errors.go index 15a572b6f7..e666d80717 100644 --- a/lib/babe/errors.go +++ b/lib/babe/errors.go @@ -71,7 +71,7 @@ var ( errInvalidSlotTechnique = errors.New("invalid slot claiming technique") errNoBABEAuthorityKeyProvided = errors.New("cannot create BABE service as authority; no keypair provided") errLastDigestItemNotSeal = errors.New("last digest item is not seal") - errLaggingSlot = errors.New("cannot claim slot, current slot is smaller than slot of best block") + errLaggingSlot = errors.New("current slot is smaller than slot of best block") other Other invalidCustom InvalidCustom From 37b41ca4c036ec4bb21e4eb5c170d1d5a97689b8 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 18:30:42 +0530 Subject: [PATCH 41/49] fix --- lib/babe/babe_integration_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 97dec29dfd..2396a4541d 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -345,8 +345,8 @@ func TestService_HandleSlotWithLaggingSlot(t *testing.T) { } preRuntimeDigest, err := types.NewBabePrimaryPreDigest( 0, slot.number, - [sr25519.VRFOutputLength]byte, - [sr25519.VRFProofLength]byte, + [sr25519.VRFOutputLength]byte{}, + [sr25519.VRFProofLength]byte{}, ).ToPreRuntimeDigest() require.NoError(t, err) From 532c617e4a47dfbfbe1dbbc8f5e802728881aa3b Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 18:44:08 +0530 Subject: [PATCH 42/49] split handleSlot function --- lib/babe/babe.go | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/lib/babe/babe.go b/lib/babe/babe.go index 51e7c6ad56..1b615f6265 100644 --- a/lib/babe/babe.go +++ b/lib/babe/babe.go @@ -454,28 +454,25 @@ func (b *Service) handleEpoch(epoch uint64) (next uint64, err error) { return next, nil } -func (b *Service) handleSlot(epoch, slotNum uint64, - authorityIndex uint32, - preRuntimeDigest *types.PreRuntimeDigest, -) error { +func (b *Service) getParentForBlockAuthoring(slotNum uint64) (*types.Header, error) { parentHeader, err := b.blockState.BestBlockHeader() if err != nil { - return err + return nil, fmt.Errorf("could not get best block header: %w", err) } if parentHeader == nil { - return errNilParentHeader + return nil, errNilParentHeader } atGenesisBlock := b.blockState.GenesisHash().Equal(parentHeader.Hash()) if !atGenesisBlock { bestBlockSlotNum, err := b.blockState.GetSlotForBlock(parentHeader.Hash()) if err != nil { - return fmt.Errorf("could not get slot for block: %w", err) + return nil, fmt.Errorf("could not get slot for block: %w", err) } if bestBlockSlotNum > slotNum { - return fmt.Errorf("%w: best block slot number is %d and got slot number %d", + return nil, fmt.Errorf("%w: best block slot number is %d and got slot number %d", errLaggingSlot, bestBlockSlotNum, slotNum) } @@ -483,10 +480,10 @@ func (b *Service) handleSlot(epoch, slotNum uint64, // pick parent of best block instead to handle slot newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash) if err != nil { - return fmt.Errorf("could not get header: %w", err) + return nil, fmt.Errorf("could not get header: %w", err) } if newParentHeader == nil { - return fmt.Errorf("%w: for block hash %s", errNilParentHeader, parentHeader.ParentHash) + return nil, fmt.Errorf("%w: for block hash %s", errNilParentHeader, parentHeader.ParentHash) } parentHeader = newParentHeader } @@ -496,15 +493,26 @@ func (b *Service) handleSlot(epoch, slotNum uint64, // so let's copy it first. parent, err := parentHeader.DeepCopy() if err != nil { - return err + return nil, fmt.Errorf("could not create deep copy of parent header: %w", err) } + return parent, nil +} + +func (b *Service) handleSlot(epoch, slotNum uint64, + authorityIndex uint32, + preRuntimeDigest *types.PreRuntimeDigest, +) error { currentSlot := Slot{ start: time.Now(), duration: b.constants.slotDuration, number: slotNum, } + parent, err := b.getParentForBlockAuthoring(slotNum) + if err != nil { + return fmt.Errorf("could not get parent for claiming slot %d: %w", slotNum, err) + } b.storageState.Lock() defer b.storageState.Unlock() From f56e154becfc28b139b0588ac1598460887e8172 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 23:20:53 +0800 Subject: [PATCH 43/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 2396a4541d..b876e27f16 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -407,7 +407,7 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { }() // wait till bob creates a block - time.Sleep(babeServiceBob.constants.slotDuration * 1) + time.Sleep(babeServiceBob.constants.slotDuration) require.NoError(t, err) block, err := babeServiceBob.blockState.GetBlockByNumber(1) From 849ad82376fd5082c1a57202304f4ff5793382a6 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Wed, 21 Sep 2022 23:21:43 +0800 Subject: [PATCH 44/49] Update lib/babe/babe_integration_test.go Co-authored-by: Quentin McGaw --- lib/babe/babe_integration_test.go | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index b876e27f16..e2e0ee6838 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -386,15 +386,15 @@ func TestService_HandleSlotWithSameSlot(t *testing.T) { Authority: true, Lead: true, Keypair: bob, - } - cfgBob.AuthData = []types.Authority{ - { - Key: alice.Public().(*sr25519.PublicKey), - Weight: 1, - }, - { - Key: bob.Public().(*sr25519.PublicKey), - Weight: 1, + AuthData: []types.Authority{ + { + Key: alice.Public().(*sr25519.PublicKey), + Weight: 1, + }, + { + Key: bob.Public().(*sr25519.PublicKey), + Weight: 1, + }, }, } From 9ba1b588e48895765ec92de2bf50fc2a471d8ae8 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Thu, 22 Sep 2022 18:31:25 +0530 Subject: [PATCH 45/49] separate mock interface --- dot/core/{test_helpers.go => helpers_test.go} | 0 ...ck_telemetry.go => mock_telemetry_test.go} | 0 ...cks_generate.go => mocks_generate_test.go} | 0 ...mocks_runtime.go => mocks_runtime_test.go} | 0 dot/core/{mocks.go => mocks_test.go} | 0 lib/babe/babe_integration_test.go | 4 +- lib/babe/helpers_test.go | 126 ++++++++++++++++++ lib/babe/mocks/network.go | 75 +++++++++++ 8 files changed, 203 insertions(+), 2 deletions(-) rename dot/core/{test_helpers.go => helpers_test.go} (100%) rename dot/core/{mock_telemetry.go => mock_telemetry_test.go} (100%) rename dot/core/{mocks_generate.go => mocks_generate_test.go} (100%) rename dot/core/{mocks_runtime.go => mocks_runtime_test.go} (100%) rename dot/core/{mocks.go => mocks_test.go} (100%) create mode 100644 lib/babe/mocks/network.go diff --git a/dot/core/test_helpers.go b/dot/core/helpers_test.go similarity index 100% rename from dot/core/test_helpers.go rename to dot/core/helpers_test.go diff --git a/dot/core/mock_telemetry.go b/dot/core/mock_telemetry_test.go similarity index 100% rename from dot/core/mock_telemetry.go rename to dot/core/mock_telemetry_test.go diff --git a/dot/core/mocks_generate.go b/dot/core/mocks_generate_test.go similarity index 100% rename from dot/core/mocks_generate.go rename to dot/core/mocks_generate_test.go diff --git a/dot/core/mocks_runtime.go b/dot/core/mocks_runtime_test.go similarity index 100% rename from dot/core/mocks_runtime.go rename to dot/core/mocks_runtime_test.go diff --git a/dot/core/mocks.go b/dot/core/mocks_test.go similarity index 100% rename from dot/core/mocks.go rename to dot/core/mocks_test.go diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index 2396a4541d..5b3e81dcb6 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -128,7 +128,7 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { require.NoError(t, err) if cfg.BlockImportHandler == nil { - mockNetwork := core.NewMockNetwork(ctrl) + mockNetwork := mocks.NewMockNetwork(ctrl) mockNetwork.EXPECT().GossipMessage(gomock.Any()).AnyTimes() coreConfig := core.Config{ @@ -143,7 +143,7 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { CodeSubstitutes: make(map[common.Hash]string), } - babeService.blockImportHandler = core.NewTestService(t, &coreConfig) + babeService.blockImportHandler = NewTestService(t, &coreConfig) } return babeService diff --git a/lib/babe/helpers_test.go b/lib/babe/helpers_test.go index 37ae424e4d..8e6a200260 100644 --- a/lib/babe/helpers_test.go +++ b/lib/babe/helpers_test.go @@ -1,20 +1,146 @@ // Copyright 2022 ChainSafe Systems (ON) // SPDX-License-Identifier: LGPL-3.0-only +// Copyright 2021 ChainSafe Systems (ON) +// SPDX-License-Identifier: LGPL-3.0-only + package babe import ( + "path/filepath" "testing" + "github.com/ChainSafe/gossamer/dot/core" + "github.com/ChainSafe/gossamer/dot/state" "github.com/ChainSafe/gossamer/dot/types" + "github.com/ChainSafe/gossamer/internal/log" "github.com/ChainSafe/gossamer/lib/common" + "github.com/ChainSafe/gossamer/lib/crypto/sr25519" "github.com/ChainSafe/gossamer/lib/genesis" + "github.com/ChainSafe/gossamer/lib/keystore" + "github.com/ChainSafe/gossamer/lib/runtime" + rtstorage "github.com/ChainSafe/gossamer/lib/runtime/storage" "github.com/ChainSafe/gossamer/lib/runtime/wasmer" "github.com/ChainSafe/gossamer/lib/trie" "github.com/ChainSafe/gossamer/lib/utils" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/require" ) +// NewTestService creates a new test core service +func NewTestService(t *testing.T, cfg *core.Config) *core.Service { + t.Helper() + ctrl := gomock.NewController(t) + + if cfg == nil { + cfg = &core.Config{} + } + + if cfg.Keystore == nil { + cfg.Keystore = keystore.NewGlobalKeystore() + kp, err := sr25519.GenerateKeypair() + if err != nil { + t.Fatal(err) + } + err = cfg.Keystore.Acco.Insert(kp) + require.NoError(t, err) + } + + cfg.LogLvl = 3 + + var stateSrvc *state.Service + testDatadirPath := t.TempDir() + + gen, genesisTrie, genesisHeader := newTestGenesisWithTrieAndHeader(t) + + if cfg.BlockState == nil || cfg.StorageState == nil || + cfg.TransactionState == nil || cfg.EpochState == nil || + cfg.CodeSubstitutedState == nil { + telemetryMock := NewMockClient(ctrl) + telemetryMock.EXPECT().SendMessage(gomock.Any()).AnyTimes() + + config := state.Config{ + Path: testDatadirPath, + LogLevel: log.Info, + Telemetry: telemetryMock, + } + + stateSrvc = state.NewService(config) + stateSrvc.UseMemDB() + + err := stateSrvc.Initialise(&gen, &genesisHeader, &genesisTrie) + require.NoError(t, err) + + err = stateSrvc.Start() + require.NoError(t, err) + } + + if cfg.BlockState == nil { + cfg.BlockState = stateSrvc.Block + } + + if cfg.StorageState == nil { + cfg.StorageState = stateSrvc.Storage + } + + if cfg.TransactionState == nil { + cfg.TransactionState = stateSrvc.Transaction + } + + if cfg.EpochState == nil { + cfg.EpochState = stateSrvc.Epoch + } + + if cfg.CodeSubstitutedState == nil { + cfg.CodeSubstitutedState = stateSrvc.Base + } + + if cfg.Runtime == nil { + var rtCfg wasmer.Config + + rtCfg.Storage = rtstorage.NewTrieState(&genesisTrie) + + var err error + rtCfg.CodeHash, err = cfg.StorageState.LoadCodeHash(nil) + require.NoError(t, err) + + nodeStorage := runtime.NodeStorage{} + + if stateSrvc != nil { + nodeStorage.BaseDB = stateSrvc.Base + } else { + nodeStorage.BaseDB, err = utils.SetupDatabase(filepath.Join(testDatadirPath, "offline_storage"), false) + require.NoError(t, err) + } + + rtCfg.NodeStorage = nodeStorage + + cfg.Runtime, err = wasmer.NewRuntimeFromGenesis(rtCfg) + require.NoError(t, err) + } + cfg.BlockState.StoreRuntime(cfg.BlockState.BestBlockHash(), cfg.Runtime) + + if cfg.CodeSubstitutes == nil { + cfg.CodeSubstitutes = make(map[common.Hash]string) + + genesisData, err := cfg.CodeSubstitutedState.(*state.BaseState).LoadGenesisData() + require.NoError(t, err) + + for k, v := range genesisData.CodeSubstitutes { + cfg.CodeSubstitutes[common.MustHexToHash(k)] = v + } + } + + if cfg.CodeSubstitutedState == nil { + cfg.CodeSubstitutedState = stateSrvc.Base + } + + s, err := core.NewService(cfg) + require.NoError(t, err) + + return s +} + // newDevGenesisWithTrieAndHeader generates test dev genesis, genesis trie and genesis header func newDevGenesisWithTrieAndHeader(t *testing.T) ( gen genesis.Genesis, genesisTrie trie.Trie, genesisHeader types.Header) { diff --git a/lib/babe/mocks/network.go b/lib/babe/mocks/network.go new file mode 100644 index 0000000000..1f1314e3cb --- /dev/null +++ b/lib/babe/mocks/network.go @@ -0,0 +1,75 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/ChainSafe/gossamer/dot/core (interfaces: Network) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + reflect "reflect" + + network "github.com/ChainSafe/gossamer/dot/network" + peerset "github.com/ChainSafe/gossamer/dot/peerset" + gomock "github.com/golang/mock/gomock" + peer "github.com/libp2p/go-libp2p-core/peer" +) + +// MockNetwork is a mock of Network interface. +type MockNetwork struct { + ctrl *gomock.Controller + recorder *MockNetworkMockRecorder +} + +// MockNetworkMockRecorder is the mock recorder for MockNetwork. +type MockNetworkMockRecorder struct { + mock *MockNetwork +} + +// NewMockNetwork creates a new mock instance. +func NewMockNetwork(ctrl *gomock.Controller) *MockNetwork { + mock := &MockNetwork{ctrl: ctrl} + mock.recorder = &MockNetworkMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockNetwork) EXPECT() *MockNetworkMockRecorder { + return m.recorder +} + +// GossipMessage mocks base method. +func (m *MockNetwork) GossipMessage(arg0 network.NotificationsMessage) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "GossipMessage", arg0) +} + +// GossipMessage indicates an expected call of GossipMessage. +func (mr *MockNetworkMockRecorder) GossipMessage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GossipMessage", reflect.TypeOf((*MockNetwork)(nil).GossipMessage), arg0) +} + +// IsSynced mocks base method. +func (m *MockNetwork) IsSynced() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsSynced") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsSynced indicates an expected call of IsSynced. +func (mr *MockNetworkMockRecorder) IsSynced() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSynced", reflect.TypeOf((*MockNetwork)(nil).IsSynced)) +} + +// ReportPeer mocks base method. +func (m *MockNetwork) ReportPeer(arg0 peerset.ReputationChange, arg1 peer.ID) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "ReportPeer", arg0, arg1) +} + +// ReportPeer indicates an expected call of ReportPeer. +func (mr *MockNetworkMockRecorder) ReportPeer(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), arg0, arg1) +} From db736bacc6690a4fe670e03f2231c7b8a38c99ca Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Thu, 22 Sep 2022 18:47:36 +0530 Subject: [PATCH 46/49] some clean up --- dot/core/mocks_generate_test.go | 2 +- lib/babe/helpers_test.go | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/dot/core/mocks_generate_test.go b/dot/core/mocks_generate_test.go index d7c1cff2c4..9a33173f78 100644 --- a/dot/core/mocks_generate_test.go +++ b/dot/core/mocks_generate_test.go @@ -3,4 +3,4 @@ package core -//go:generate mockgen -destination=mocks.go -package $GOPACKAGE . BlockState,StorageState,TransactionState,Network,EpochState,CodeSubstitutedState,RuntimeInstance +//go:generate mockgen -destination=mocks_test.go -package $GOPACKAGE . BlockState,StorageState,TransactionState,Network,EpochState,CodeSubstitutedState,RuntimeInstance diff --git a/lib/babe/helpers_test.go b/lib/babe/helpers_test.go index 8e6a200260..24b07449ff 100644 --- a/lib/babe/helpers_test.go +++ b/lib/babe/helpers_test.go @@ -1,9 +1,6 @@ // Copyright 2022 ChainSafe Systems (ON) // SPDX-License-Identifier: LGPL-3.0-only -// Copyright 2021 ChainSafe Systems (ON) -// SPDX-License-Identifier: LGPL-3.0-only - package babe import ( From 3366ecc0b5e8e3881e9a95d6bc6fb0b266ebc769 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Thu, 22 Sep 2022 22:53:29 +0800 Subject: [PATCH 47/49] Update lib/babe/babe_integration_test.go MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Eclésio Junior --- lib/babe/babe_integration_test.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/lib/babe/babe_integration_test.go b/lib/babe/babe_integration_test.go index f4e0b6ea22..6096916f24 100644 --- a/lib/babe/babe_integration_test.go +++ b/lib/babe/babe_integration_test.go @@ -90,8 +90,6 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service { dbSrv = state.NewService(config) dbSrv.UseMemDB() - // err = dbSrv.Initialise(gen, genHeader, genTrie) - // require.NoError(t, err) err = dbSrv.Initialise(&gen, &genHeader, &genTrie) require.NoError(t, err) From 65f649e4d315766e287c9f8b79abd7297f3a0fba Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 26 Sep 2022 16:52:01 +0530 Subject: [PATCH 48/49] added mock generate file --- lib/babe/mocks/network.go | 1113 ++++++++++++++++++++++++++++++- lib/babe/mocks_generate_test.go | 6 + 2 files changed, 1114 insertions(+), 5 deletions(-) create mode 100644 lib/babe/mocks_generate_test.go diff --git a/lib/babe/mocks/network.go b/lib/babe/mocks/network.go index 1f1314e3cb..c27f5df670 100644 --- a/lib/babe/mocks/network.go +++ b/lib/babe/mocks/network.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/ChainSafe/gossamer/dot/core (interfaces: Network) +// Source: ../../dot/core/interface.go // Package mocks is a generated GoMock package. package mocks @@ -9,10 +9,995 @@ import ( network "github.com/ChainSafe/gossamer/dot/network" peerset "github.com/ChainSafe/gossamer/dot/peerset" + types "github.com/ChainSafe/gossamer/dot/types" + common "github.com/ChainSafe/gossamer/lib/common" + keystore "github.com/ChainSafe/gossamer/lib/keystore" + runtime "github.com/ChainSafe/gossamer/lib/runtime" + storage "github.com/ChainSafe/gossamer/lib/runtime/storage" + transaction "github.com/ChainSafe/gossamer/lib/transaction" gomock "github.com/golang/mock/gomock" peer "github.com/libp2p/go-libp2p-core/peer" ) +// MockRuntimeInstance is a mock of RuntimeInstance interface. +type MockRuntimeInstance struct { + ctrl *gomock.Controller + recorder *MockRuntimeInstanceMockRecorder +} + +// MockRuntimeInstanceMockRecorder is the mock recorder for MockRuntimeInstance. +type MockRuntimeInstanceMockRecorder struct { + mock *MockRuntimeInstance +} + +// NewMockRuntimeInstance creates a new mock instance. +func NewMockRuntimeInstance(ctrl *gomock.Controller) *MockRuntimeInstance { + mock := &MockRuntimeInstance{ctrl: ctrl} + mock.recorder = &MockRuntimeInstanceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRuntimeInstance) EXPECT() *MockRuntimeInstanceMockRecorder { + return m.recorder +} + +// ApplyExtrinsic mocks base method. +func (m *MockRuntimeInstance) ApplyExtrinsic(data types.Extrinsic) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ApplyExtrinsic", data) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ApplyExtrinsic indicates an expected call of ApplyExtrinsic. +func (mr *MockRuntimeInstanceMockRecorder) ApplyExtrinsic(data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyExtrinsic", reflect.TypeOf((*MockRuntimeInstance)(nil).ApplyExtrinsic), data) +} + +// BabeConfiguration mocks base method. +func (m *MockRuntimeInstance) BabeConfiguration() (*types.BabeConfiguration, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BabeConfiguration") + ret0, _ := ret[0].(*types.BabeConfiguration) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BabeConfiguration indicates an expected call of BabeConfiguration. +func (mr *MockRuntimeInstanceMockRecorder) BabeConfiguration() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BabeConfiguration", reflect.TypeOf((*MockRuntimeInstance)(nil).BabeConfiguration)) +} + +// CheckInherents mocks base method. +func (m *MockRuntimeInstance) CheckInherents() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "CheckInherents") +} + +// CheckInherents indicates an expected call of CheckInherents. +func (mr *MockRuntimeInstanceMockRecorder) CheckInherents() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckInherents", reflect.TypeOf((*MockRuntimeInstance)(nil).CheckInherents)) +} + +// DecodeSessionKeys mocks base method. +func (m *MockRuntimeInstance) DecodeSessionKeys(enc []byte) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecodeSessionKeys", enc) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DecodeSessionKeys indicates an expected call of DecodeSessionKeys. +func (mr *MockRuntimeInstanceMockRecorder) DecodeSessionKeys(enc interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeSessionKeys", reflect.TypeOf((*MockRuntimeInstance)(nil).DecodeSessionKeys), enc) +} + +// Exec mocks base method. +func (m *MockRuntimeInstance) Exec(function string, data []byte) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Exec", function, data) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Exec indicates an expected call of Exec. +func (mr *MockRuntimeInstanceMockRecorder) Exec(function, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockRuntimeInstance)(nil).Exec), function, data) +} + +// ExecuteBlock mocks base method. +func (m *MockRuntimeInstance) ExecuteBlock(block *types.Block) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExecuteBlock", block) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExecuteBlock indicates an expected call of ExecuteBlock. +func (mr *MockRuntimeInstanceMockRecorder) ExecuteBlock(block interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteBlock", reflect.TypeOf((*MockRuntimeInstance)(nil).ExecuteBlock), block) +} + +// FinalizeBlock mocks base method. +func (m *MockRuntimeInstance) FinalizeBlock() (*types.Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FinalizeBlock") + ret0, _ := ret[0].(*types.Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FinalizeBlock indicates an expected call of FinalizeBlock. +func (mr *MockRuntimeInstanceMockRecorder) FinalizeBlock() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeBlock", reflect.TypeOf((*MockRuntimeInstance)(nil).FinalizeBlock)) +} + +// GenerateSessionKeys mocks base method. +func (m *MockRuntimeInstance) GenerateSessionKeys() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "GenerateSessionKeys") +} + +// GenerateSessionKeys indicates an expected call of GenerateSessionKeys. +func (mr *MockRuntimeInstanceMockRecorder) GenerateSessionKeys() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateSessionKeys", reflect.TypeOf((*MockRuntimeInstance)(nil).GenerateSessionKeys)) +} + +// GetCodeHash mocks base method. +func (m *MockRuntimeInstance) GetCodeHash() common.Hash { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCodeHash") + ret0, _ := ret[0].(common.Hash) + return ret0 +} + +// GetCodeHash indicates an expected call of GetCodeHash. +func (mr *MockRuntimeInstanceMockRecorder) GetCodeHash() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCodeHash", reflect.TypeOf((*MockRuntimeInstance)(nil).GetCodeHash)) +} + +// GrandpaAuthorities mocks base method. +func (m *MockRuntimeInstance) GrandpaAuthorities() ([]types.Authority, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GrandpaAuthorities") + ret0, _ := ret[0].([]types.Authority) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GrandpaAuthorities indicates an expected call of GrandpaAuthorities. +func (mr *MockRuntimeInstanceMockRecorder) GrandpaAuthorities() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrandpaAuthorities", reflect.TypeOf((*MockRuntimeInstance)(nil).GrandpaAuthorities)) +} + +// InherentExtrinsics mocks base method. +func (m *MockRuntimeInstance) InherentExtrinsics(data []byte) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InherentExtrinsics", data) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InherentExtrinsics indicates an expected call of InherentExtrinsics. +func (mr *MockRuntimeInstanceMockRecorder) InherentExtrinsics(data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InherentExtrinsics", reflect.TypeOf((*MockRuntimeInstance)(nil).InherentExtrinsics), data) +} + +// InitializeBlock mocks base method. +func (m *MockRuntimeInstance) InitializeBlock(header *types.Header) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InitializeBlock", header) + ret0, _ := ret[0].(error) + return ret0 +} + +// InitializeBlock indicates an expected call of InitializeBlock. +func (mr *MockRuntimeInstanceMockRecorder) InitializeBlock(header interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitializeBlock", reflect.TypeOf((*MockRuntimeInstance)(nil).InitializeBlock), header) +} + +// Keystore mocks base method. +func (m *MockRuntimeInstance) Keystore() *keystore.GlobalKeystore { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Keystore") + ret0, _ := ret[0].(*keystore.GlobalKeystore) + return ret0 +} + +// Keystore indicates an expected call of Keystore. +func (mr *MockRuntimeInstanceMockRecorder) Keystore() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keystore", reflect.TypeOf((*MockRuntimeInstance)(nil).Keystore)) +} + +// Metadata mocks base method. +func (m *MockRuntimeInstance) Metadata() ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Metadata") + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Metadata indicates an expected call of Metadata. +func (mr *MockRuntimeInstanceMockRecorder) Metadata() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Metadata", reflect.TypeOf((*MockRuntimeInstance)(nil).Metadata)) +} + +// NetworkService mocks base method. +func (m *MockRuntimeInstance) NetworkService() runtime.BasicNetwork { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NetworkService") + ret0, _ := ret[0].(runtime.BasicNetwork) + return ret0 +} + +// NetworkService indicates an expected call of NetworkService. +func (mr *MockRuntimeInstanceMockRecorder) NetworkService() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkService", reflect.TypeOf((*MockRuntimeInstance)(nil).NetworkService)) +} + +// NodeStorage mocks base method. +func (m *MockRuntimeInstance) NodeStorage() runtime.NodeStorage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NodeStorage") + ret0, _ := ret[0].(runtime.NodeStorage) + return ret0 +} + +// NodeStorage indicates an expected call of NodeStorage. +func (mr *MockRuntimeInstanceMockRecorder) NodeStorage() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeStorage", reflect.TypeOf((*MockRuntimeInstance)(nil).NodeStorage)) +} + +// OffchainWorker mocks base method. +func (m *MockRuntimeInstance) OffchainWorker() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "OffchainWorker") +} + +// OffchainWorker indicates an expected call of OffchainWorker. +func (mr *MockRuntimeInstanceMockRecorder) OffchainWorker() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OffchainWorker", reflect.TypeOf((*MockRuntimeInstance)(nil).OffchainWorker)) +} + +// PaymentQueryInfo mocks base method. +func (m *MockRuntimeInstance) PaymentQueryInfo(ext []byte) (*types.TransactionPaymentQueryInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PaymentQueryInfo", ext) + ret0, _ := ret[0].(*types.TransactionPaymentQueryInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PaymentQueryInfo indicates an expected call of PaymentQueryInfo. +func (mr *MockRuntimeInstanceMockRecorder) PaymentQueryInfo(ext interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentQueryInfo", reflect.TypeOf((*MockRuntimeInstance)(nil).PaymentQueryInfo), ext) +} + +// RandomSeed mocks base method. +func (m *MockRuntimeInstance) RandomSeed() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RandomSeed") +} + +// RandomSeed indicates an expected call of RandomSeed. +func (mr *MockRuntimeInstanceMockRecorder) RandomSeed() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomSeed", reflect.TypeOf((*MockRuntimeInstance)(nil).RandomSeed)) +} + +// SetContextStorage mocks base method. +func (m *MockRuntimeInstance) SetContextStorage(s runtime.Storage) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetContextStorage", s) +} + +// SetContextStorage indicates an expected call of SetContextStorage. +func (mr *MockRuntimeInstanceMockRecorder) SetContextStorage(s interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContextStorage", reflect.TypeOf((*MockRuntimeInstance)(nil).SetContextStorage), s) +} + +// Stop mocks base method. +func (m *MockRuntimeInstance) Stop() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Stop") +} + +// Stop indicates an expected call of Stop. +func (mr *MockRuntimeInstanceMockRecorder) Stop() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockRuntimeInstance)(nil).Stop)) +} + +// UpdateRuntimeCode mocks base method. +func (m *MockRuntimeInstance) UpdateRuntimeCode(arg0 []byte) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRuntimeCode", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateRuntimeCode indicates an expected call of UpdateRuntimeCode. +func (mr *MockRuntimeInstanceMockRecorder) UpdateRuntimeCode(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRuntimeCode", reflect.TypeOf((*MockRuntimeInstance)(nil).UpdateRuntimeCode), arg0) +} + +// ValidateTransaction mocks base method. +func (m *MockRuntimeInstance) ValidateTransaction(e types.Extrinsic) (*transaction.Validity, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ValidateTransaction", e) + ret0, _ := ret[0].(*transaction.Validity) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ValidateTransaction indicates an expected call of ValidateTransaction. +func (mr *MockRuntimeInstanceMockRecorder) ValidateTransaction(e interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateTransaction", reflect.TypeOf((*MockRuntimeInstance)(nil).ValidateTransaction), e) +} + +// Validator mocks base method. +func (m *MockRuntimeInstance) Validator() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Validator") + ret0, _ := ret[0].(bool) + return ret0 +} + +// Validator indicates an expected call of Validator. +func (mr *MockRuntimeInstanceMockRecorder) Validator() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validator", reflect.TypeOf((*MockRuntimeInstance)(nil).Validator)) +} + +// Version mocks base method. +func (m *MockRuntimeInstance) Version() runtime.Version { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Version") + ret0, _ := ret[0].(runtime.Version) + return ret0 +} + +// Version indicates an expected call of Version. +func (mr *MockRuntimeInstanceMockRecorder) Version() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockRuntimeInstance)(nil).Version)) +} + +// MockBlockState is a mock of BlockState interface. +type MockBlockState struct { + ctrl *gomock.Controller + recorder *MockBlockStateMockRecorder +} + +// MockBlockStateMockRecorder is the mock recorder for MockBlockState. +type MockBlockStateMockRecorder struct { + mock *MockBlockState +} + +// NewMockBlockState creates a new mock instance. +func NewMockBlockState(ctrl *gomock.Controller) *MockBlockState { + mock := &MockBlockState{ctrl: ctrl} + mock.recorder = &MockBlockStateMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBlockState) EXPECT() *MockBlockStateMockRecorder { + return m.recorder +} + +// AddBlock mocks base method. +func (m *MockBlockState) AddBlock(arg0 *types.Block) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddBlock", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddBlock indicates an expected call of AddBlock. +func (mr *MockBlockStateMockRecorder) AddBlock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlock", reflect.TypeOf((*MockBlockState)(nil).AddBlock), arg0) +} + +// BestBlock mocks base method. +func (m *MockBlockState) BestBlock() (*types.Block, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BestBlock") + ret0, _ := ret[0].(*types.Block) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BestBlock indicates an expected call of BestBlock. +func (mr *MockBlockStateMockRecorder) BestBlock() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlock", reflect.TypeOf((*MockBlockState)(nil).BestBlock)) +} + +// BestBlockHash mocks base method. +func (m *MockBlockState) BestBlockHash() common.Hash { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BestBlockHash") + ret0, _ := ret[0].(common.Hash) + return ret0 +} + +// BestBlockHash indicates an expected call of BestBlockHash. +func (mr *MockBlockStateMockRecorder) BestBlockHash() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlockHash", reflect.TypeOf((*MockBlockState)(nil).BestBlockHash)) +} + +// BestBlockHeader mocks base method. +func (m *MockBlockState) BestBlockHeader() (*types.Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BestBlockHeader") + ret0, _ := ret[0].(*types.Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BestBlockHeader indicates an expected call of BestBlockHeader. +func (mr *MockBlockStateMockRecorder) BestBlockHeader() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlockHeader", reflect.TypeOf((*MockBlockState)(nil).BestBlockHeader)) +} + +// BestBlockNumber mocks base method. +func (m *MockBlockState) BestBlockNumber() (uint, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BestBlockNumber") + ret0, _ := ret[0].(uint) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BestBlockNumber indicates an expected call of BestBlockNumber. +func (mr *MockBlockStateMockRecorder) BestBlockNumber() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlockNumber", reflect.TypeOf((*MockBlockState)(nil).BestBlockNumber)) +} + +// BestBlockStateRoot mocks base method. +func (m *MockBlockState) BestBlockStateRoot() (common.Hash, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BestBlockStateRoot") + ret0, _ := ret[0].(common.Hash) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BestBlockStateRoot indicates an expected call of BestBlockStateRoot. +func (mr *MockBlockStateMockRecorder) BestBlockStateRoot() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlockStateRoot", reflect.TypeOf((*MockBlockState)(nil).BestBlockStateRoot)) +} + +// FreeFinalisedNotifierChannel mocks base method. +func (m *MockBlockState) FreeFinalisedNotifierChannel(ch chan *types.FinalisationInfo) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "FreeFinalisedNotifierChannel", ch) +} + +// FreeFinalisedNotifierChannel indicates an expected call of FreeFinalisedNotifierChannel. +func (mr *MockBlockStateMockRecorder) FreeFinalisedNotifierChannel(ch interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FreeFinalisedNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).FreeFinalisedNotifierChannel), ch) +} + +// FreeImportedBlockNotifierChannel mocks base method. +func (m *MockBlockState) FreeImportedBlockNotifierChannel(ch chan *types.Block) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "FreeImportedBlockNotifierChannel", ch) +} + +// FreeImportedBlockNotifierChannel indicates an expected call of FreeImportedBlockNotifierChannel. +func (mr *MockBlockStateMockRecorder) FreeImportedBlockNotifierChannel(ch interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FreeImportedBlockNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).FreeImportedBlockNotifierChannel), ch) +} + +// GenesisHash mocks base method. +func (m *MockBlockState) GenesisHash() common.Hash { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenesisHash") + ret0, _ := ret[0].(common.Hash) + return ret0 +} + +// GenesisHash indicates an expected call of GenesisHash. +func (mr *MockBlockStateMockRecorder) GenesisHash() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenesisHash", reflect.TypeOf((*MockBlockState)(nil).GenesisHash)) +} + +// GetAllBlocksAtDepth mocks base method. +func (m *MockBlockState) GetAllBlocksAtDepth(hash common.Hash) []common.Hash { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAllBlocksAtDepth", hash) + ret0, _ := ret[0].([]common.Hash) + return ret0 +} + +// GetAllBlocksAtDepth indicates an expected call of GetAllBlocksAtDepth. +func (mr *MockBlockStateMockRecorder) GetAllBlocksAtDepth(hash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBlocksAtDepth", reflect.TypeOf((*MockBlockState)(nil).GetAllBlocksAtDepth), hash) +} + +// GetBlockBody mocks base method. +func (m *MockBlockState) GetBlockBody(hash common.Hash) (*types.Body, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBlockBody", hash) + ret0, _ := ret[0].(*types.Body) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBlockBody indicates an expected call of GetBlockBody. +func (mr *MockBlockStateMockRecorder) GetBlockBody(hash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockBody", reflect.TypeOf((*MockBlockState)(nil).GetBlockBody), hash) +} + +// GetBlockByHash mocks base method. +func (m *MockBlockState) GetBlockByHash(arg0 common.Hash) (*types.Block, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBlockByHash", arg0) + ret0, _ := ret[0].(*types.Block) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBlockByHash indicates an expected call of GetBlockByHash. +func (mr *MockBlockStateMockRecorder) GetBlockByHash(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByHash", reflect.TypeOf((*MockBlockState)(nil).GetBlockByHash), arg0) +} + +// GetBlockStateRoot mocks base method. +func (m *MockBlockState) GetBlockStateRoot(bhash common.Hash) (common.Hash, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBlockStateRoot", bhash) + ret0, _ := ret[0].(common.Hash) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBlockStateRoot indicates an expected call of GetBlockStateRoot. +func (mr *MockBlockStateMockRecorder) GetBlockStateRoot(bhash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockStateRoot", reflect.TypeOf((*MockBlockState)(nil).GetBlockStateRoot), bhash) +} + +// GetFinalisedHash mocks base method. +func (m *MockBlockState) GetFinalisedHash(arg0, arg1 uint64) (common.Hash, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFinalisedHash", arg0, arg1) + ret0, _ := ret[0].(common.Hash) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFinalisedHash indicates an expected call of GetFinalisedHash. +func (mr *MockBlockStateMockRecorder) GetFinalisedHash(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinalisedHash", reflect.TypeOf((*MockBlockState)(nil).GetFinalisedHash), arg0, arg1) +} + +// GetFinalisedHeader mocks base method. +func (m *MockBlockState) GetFinalisedHeader(arg0, arg1 uint64) (*types.Header, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFinalisedHeader", arg0, arg1) + ret0, _ := ret[0].(*types.Header) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFinalisedHeader indicates an expected call of GetFinalisedHeader. +func (mr *MockBlockStateMockRecorder) GetFinalisedHeader(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinalisedHeader", reflect.TypeOf((*MockBlockState)(nil).GetFinalisedHeader), arg0, arg1) +} + +// GetFinalisedNotifierChannel mocks base method. +func (m *MockBlockState) GetFinalisedNotifierChannel() chan *types.FinalisationInfo { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFinalisedNotifierChannel") + ret0, _ := ret[0].(chan *types.FinalisationInfo) + return ret0 +} + +// GetFinalisedNotifierChannel indicates an expected call of GetFinalisedNotifierChannel. +func (mr *MockBlockStateMockRecorder) GetFinalisedNotifierChannel() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinalisedNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).GetFinalisedNotifierChannel)) +} + +// GetImportedBlockNotifierChannel mocks base method. +func (m *MockBlockState) GetImportedBlockNotifierChannel() chan *types.Block { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetImportedBlockNotifierChannel") + ret0, _ := ret[0].(chan *types.Block) + return ret0 +} + +// GetImportedBlockNotifierChannel indicates an expected call of GetImportedBlockNotifierChannel. +func (mr *MockBlockStateMockRecorder) GetImportedBlockNotifierChannel() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImportedBlockNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).GetImportedBlockNotifierChannel)) +} + +// GetRuntime mocks base method. +func (m *MockBlockState) GetRuntime(arg0 *common.Hash) (runtime.Instance, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRuntime", arg0) + ret0, _ := ret[0].(runtime.Instance) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRuntime indicates an expected call of GetRuntime. +func (mr *MockBlockStateMockRecorder) GetRuntime(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRuntime", reflect.TypeOf((*MockBlockState)(nil).GetRuntime), arg0) +} + +// GetSlotForBlock mocks base method. +func (m *MockBlockState) GetSlotForBlock(arg0 common.Hash) (uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSlotForBlock", arg0) + ret0, _ := ret[0].(uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSlotForBlock indicates an expected call of GetSlotForBlock. +func (mr *MockBlockStateMockRecorder) GetSlotForBlock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSlotForBlock", reflect.TypeOf((*MockBlockState)(nil).GetSlotForBlock), arg0) +} + +// HandleRuntimeChanges mocks base method. +func (m *MockBlockState) HandleRuntimeChanges(newState *storage.TrieState, in runtime.Instance, bHash common.Hash) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleRuntimeChanges", newState, in, bHash) + ret0, _ := ret[0].(error) + return ret0 +} + +// HandleRuntimeChanges indicates an expected call of HandleRuntimeChanges. +func (mr *MockBlockStateMockRecorder) HandleRuntimeChanges(newState, in, bHash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRuntimeChanges", reflect.TypeOf((*MockBlockState)(nil).HandleRuntimeChanges), newState, in, bHash) +} + +// HighestCommonAncestor mocks base method. +func (m *MockBlockState) HighestCommonAncestor(a, b common.Hash) (common.Hash, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HighestCommonAncestor", a, b) + ret0, _ := ret[0].(common.Hash) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HighestCommonAncestor indicates an expected call of HighestCommonAncestor. +func (mr *MockBlockStateMockRecorder) HighestCommonAncestor(a, b interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HighestCommonAncestor", reflect.TypeOf((*MockBlockState)(nil).HighestCommonAncestor), a, b) +} + +// StoreRuntime mocks base method. +func (m *MockBlockState) StoreRuntime(arg0 common.Hash, arg1 runtime.Instance) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "StoreRuntime", arg0, arg1) +} + +// StoreRuntime indicates an expected call of StoreRuntime. +func (mr *MockBlockStateMockRecorder) StoreRuntime(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreRuntime", reflect.TypeOf((*MockBlockState)(nil).StoreRuntime), arg0, arg1) +} + +// SubChain mocks base method. +func (m *MockBlockState) SubChain(start, end common.Hash) ([]common.Hash, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SubChain", start, end) + ret0, _ := ret[0].([]common.Hash) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubChain indicates an expected call of SubChain. +func (mr *MockBlockStateMockRecorder) SubChain(start, end interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubChain", reflect.TypeOf((*MockBlockState)(nil).SubChain), start, end) +} + +// MockStorageState is a mock of StorageState interface. +type MockStorageState struct { + ctrl *gomock.Controller + recorder *MockStorageStateMockRecorder +} + +// MockStorageStateMockRecorder is the mock recorder for MockStorageState. +type MockStorageStateMockRecorder struct { + mock *MockStorageState +} + +// NewMockStorageState creates a new mock instance. +func NewMockStorageState(ctrl *gomock.Controller) *MockStorageState { + mock := &MockStorageState{ctrl: ctrl} + mock.recorder = &MockStorageStateMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStorageState) EXPECT() *MockStorageStateMockRecorder { + return m.recorder +} + +// GenerateTrieProof mocks base method. +func (m *MockStorageState) GenerateTrieProof(stateRoot common.Hash, keys [][]byte) ([][]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateTrieProof", stateRoot, keys) + ret0, _ := ret[0].([][]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateTrieProof indicates an expected call of GenerateTrieProof. +func (mr *MockStorageStateMockRecorder) GenerateTrieProof(stateRoot, keys interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateTrieProof", reflect.TypeOf((*MockStorageState)(nil).GenerateTrieProof), stateRoot, keys) +} + +// GetStateRootFromBlock mocks base method. +func (m *MockStorageState) GetStateRootFromBlock(bhash *common.Hash) (*common.Hash, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetStateRootFromBlock", bhash) + ret0, _ := ret[0].(*common.Hash) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetStateRootFromBlock indicates an expected call of GetStateRootFromBlock. +func (mr *MockStorageStateMockRecorder) GetStateRootFromBlock(bhash interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateRootFromBlock", reflect.TypeOf((*MockStorageState)(nil).GetStateRootFromBlock), bhash) +} + +// GetStorage mocks base method. +func (m *MockStorageState) GetStorage(root *common.Hash, key []byte) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetStorage", root, key) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetStorage indicates an expected call of GetStorage. +func (mr *MockStorageStateMockRecorder) GetStorage(root, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorage", reflect.TypeOf((*MockStorageState)(nil).GetStorage), root, key) +} + +// LoadCode mocks base method. +func (m *MockStorageState) LoadCode(root *common.Hash) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadCode", root) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadCode indicates an expected call of LoadCode. +func (mr *MockStorageStateMockRecorder) LoadCode(root interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadCode", reflect.TypeOf((*MockStorageState)(nil).LoadCode), root) +} + +// LoadCodeHash mocks base method. +func (m *MockStorageState) LoadCodeHash(root *common.Hash) (common.Hash, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadCodeHash", root) + ret0, _ := ret[0].(common.Hash) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LoadCodeHash indicates an expected call of LoadCodeHash. +func (mr *MockStorageStateMockRecorder) LoadCodeHash(root interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadCodeHash", reflect.TypeOf((*MockStorageState)(nil).LoadCodeHash), root) +} + +// Lock mocks base method. +func (m *MockStorageState) Lock() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Lock") +} + +// Lock indicates an expected call of Lock. +func (mr *MockStorageStateMockRecorder) Lock() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockStorageState)(nil).Lock)) +} + +// StoreTrie mocks base method. +func (m *MockStorageState) StoreTrie(arg0 *storage.TrieState, arg1 *types.Header) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StoreTrie", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// StoreTrie indicates an expected call of StoreTrie. +func (mr *MockStorageStateMockRecorder) StoreTrie(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreTrie", reflect.TypeOf((*MockStorageState)(nil).StoreTrie), arg0, arg1) +} + +// TrieState mocks base method. +func (m *MockStorageState) TrieState(root *common.Hash) (*storage.TrieState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TrieState", root) + ret0, _ := ret[0].(*storage.TrieState) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TrieState indicates an expected call of TrieState. +func (mr *MockStorageStateMockRecorder) TrieState(root interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrieState", reflect.TypeOf((*MockStorageState)(nil).TrieState), root) +} + +// Unlock mocks base method. +func (m *MockStorageState) Unlock() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Unlock") +} + +// Unlock indicates an expected call of Unlock. +func (mr *MockStorageStateMockRecorder) Unlock() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockStorageState)(nil).Unlock)) +} + +// MockTransactionState is a mock of TransactionState interface. +type MockTransactionState struct { + ctrl *gomock.Controller + recorder *MockTransactionStateMockRecorder +} + +// MockTransactionStateMockRecorder is the mock recorder for MockTransactionState. +type MockTransactionStateMockRecorder struct { + mock *MockTransactionState +} + +// NewMockTransactionState creates a new mock instance. +func NewMockTransactionState(ctrl *gomock.Controller) *MockTransactionState { + mock := &MockTransactionState{ctrl: ctrl} + mock.recorder = &MockTransactionStateMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTransactionState) EXPECT() *MockTransactionStateMockRecorder { + return m.recorder +} + +// AddToPool mocks base method. +func (m *MockTransactionState) AddToPool(vt *transaction.ValidTransaction) common.Hash { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddToPool", vt) + ret0, _ := ret[0].(common.Hash) + return ret0 +} + +// AddToPool indicates an expected call of AddToPool. +func (mr *MockTransactionStateMockRecorder) AddToPool(vt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddToPool", reflect.TypeOf((*MockTransactionState)(nil).AddToPool), vt) +} + +// Exists mocks base method. +func (m *MockTransactionState) Exists(ext types.Extrinsic) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Exists", ext) + ret0, _ := ret[0].(bool) + return ret0 +} + +// Exists indicates an expected call of Exists. +func (mr *MockTransactionStateMockRecorder) Exists(ext interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockTransactionState)(nil).Exists), ext) +} + +// PendingInPool mocks base method. +func (m *MockTransactionState) PendingInPool() []*transaction.ValidTransaction { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PendingInPool") + ret0, _ := ret[0].([]*transaction.ValidTransaction) + return ret0 +} + +// PendingInPool indicates an expected call of PendingInPool. +func (mr *MockTransactionStateMockRecorder) PendingInPool() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingInPool", reflect.TypeOf((*MockTransactionState)(nil).PendingInPool)) +} + +// Push mocks base method. +func (m *MockTransactionState) Push(vt *transaction.ValidTransaction) (common.Hash, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Push", vt) + ret0, _ := ret[0].(common.Hash) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Push indicates an expected call of Push. +func (mr *MockTransactionStateMockRecorder) Push(vt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockTransactionState)(nil).Push), vt) +} + +// RemoveExtrinsic mocks base method. +func (m *MockTransactionState) RemoveExtrinsic(ext types.Extrinsic) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RemoveExtrinsic", ext) +} + +// RemoveExtrinsic indicates an expected call of RemoveExtrinsic. +func (mr *MockTransactionStateMockRecorder) RemoveExtrinsic(ext interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveExtrinsic", reflect.TypeOf((*MockTransactionState)(nil).RemoveExtrinsic), ext) +} + +// RemoveExtrinsicFromPool mocks base method. +func (m *MockTransactionState) RemoveExtrinsicFromPool(ext types.Extrinsic) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RemoveExtrinsicFromPool", ext) +} + +// RemoveExtrinsicFromPool indicates an expected call of RemoveExtrinsicFromPool. +func (mr *MockTransactionStateMockRecorder) RemoveExtrinsicFromPool(ext interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveExtrinsicFromPool", reflect.TypeOf((*MockTransactionState)(nil).RemoveExtrinsicFromPool), ext) +} + // MockNetwork is a mock of Network interface. type MockNetwork struct { ctrl *gomock.Controller @@ -63,13 +1048,131 @@ func (mr *MockNetworkMockRecorder) IsSynced() *gomock.Call { } // ReportPeer mocks base method. -func (m *MockNetwork) ReportPeer(arg0 peerset.ReputationChange, arg1 peer.ID) { +func (m *MockNetwork) ReportPeer(change peerset.ReputationChange, p peer.ID) { m.ctrl.T.Helper() - m.ctrl.Call(m, "ReportPeer", arg0, arg1) + m.ctrl.Call(m, "ReportPeer", change, p) } // ReportPeer indicates an expected call of ReportPeer. -func (mr *MockNetworkMockRecorder) ReportPeer(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockNetworkMockRecorder) ReportPeer(change, p interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), change, p) +} + +// MockEpochState is a mock of EpochState interface. +type MockEpochState struct { + ctrl *gomock.Controller + recorder *MockEpochStateMockRecorder +} + +// MockEpochStateMockRecorder is the mock recorder for MockEpochState. +type MockEpochStateMockRecorder struct { + mock *MockEpochState +} + +// NewMockEpochState creates a new mock instance. +func NewMockEpochState(ctrl *gomock.Controller) *MockEpochState { + mock := &MockEpochState{ctrl: ctrl} + mock.recorder = &MockEpochStateMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockEpochState) EXPECT() *MockEpochStateMockRecorder { + return m.recorder +} + +// GetCurrentEpoch mocks base method. +func (m *MockEpochState) GetCurrentEpoch() (uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCurrentEpoch") + ret0, _ := ret[0].(uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCurrentEpoch indicates an expected call of GetCurrentEpoch. +func (mr *MockEpochStateMockRecorder) GetCurrentEpoch() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentEpoch", reflect.TypeOf((*MockEpochState)(nil).GetCurrentEpoch)) +} + +// GetEpochForBlock mocks base method. +func (m *MockEpochState) GetEpochForBlock(header *types.Header) (uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEpochForBlock", header) + ret0, _ := ret[0].(uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetEpochForBlock indicates an expected call of GetEpochForBlock. +func (mr *MockEpochStateMockRecorder) GetEpochForBlock(header interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpochForBlock", reflect.TypeOf((*MockEpochState)(nil).GetEpochForBlock), header) +} + +// SetCurrentEpoch mocks base method. +func (m *MockEpochState) SetCurrentEpoch(epoch uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetCurrentEpoch", epoch) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetCurrentEpoch indicates an expected call of SetCurrentEpoch. +func (mr *MockEpochStateMockRecorder) SetCurrentEpoch(epoch interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentEpoch", reflect.TypeOf((*MockEpochState)(nil).SetCurrentEpoch), epoch) +} + +// MockCodeSubstitutedState is a mock of CodeSubstitutedState interface. +type MockCodeSubstitutedState struct { + ctrl *gomock.Controller + recorder *MockCodeSubstitutedStateMockRecorder +} + +// MockCodeSubstitutedStateMockRecorder is the mock recorder for MockCodeSubstitutedState. +type MockCodeSubstitutedStateMockRecorder struct { + mock *MockCodeSubstitutedState +} + +// NewMockCodeSubstitutedState creates a new mock instance. +func NewMockCodeSubstitutedState(ctrl *gomock.Controller) *MockCodeSubstitutedState { + mock := &MockCodeSubstitutedState{ctrl: ctrl} + mock.recorder = &MockCodeSubstitutedStateMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCodeSubstitutedState) EXPECT() *MockCodeSubstitutedStateMockRecorder { + return m.recorder +} + +// LoadCodeSubstitutedBlockHash mocks base method. +func (m *MockCodeSubstitutedState) LoadCodeSubstitutedBlockHash() common.Hash { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadCodeSubstitutedBlockHash") + ret0, _ := ret[0].(common.Hash) + return ret0 +} + +// LoadCodeSubstitutedBlockHash indicates an expected call of LoadCodeSubstitutedBlockHash. +func (mr *MockCodeSubstitutedStateMockRecorder) LoadCodeSubstitutedBlockHash() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadCodeSubstitutedBlockHash", reflect.TypeOf((*MockCodeSubstitutedState)(nil).LoadCodeSubstitutedBlockHash)) +} + +// StoreCodeSubstitutedBlockHash mocks base method. +func (m *MockCodeSubstitutedState) StoreCodeSubstitutedBlockHash(hash common.Hash) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StoreCodeSubstitutedBlockHash", hash) + ret0, _ := ret[0].(error) + return ret0 +} + +// StoreCodeSubstitutedBlockHash indicates an expected call of StoreCodeSubstitutedBlockHash. +func (mr *MockCodeSubstitutedStateMockRecorder) StoreCodeSubstitutedBlockHash(hash interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreCodeSubstitutedBlockHash", reflect.TypeOf((*MockCodeSubstitutedState)(nil).StoreCodeSubstitutedBlockHash), hash) } diff --git a/lib/babe/mocks_generate_test.go b/lib/babe/mocks_generate_test.go new file mode 100644 index 0000000000..706f2433cb --- /dev/null +++ b/lib/babe/mocks_generate_test.go @@ -0,0 +1,6 @@ +// Copyright 2022 ChainSafe Systems (ON) +// SPDX-License-Identifier: LGPL-3.0-only + +package babe + +//go:generate mockgen -destination=mocks/network.go -source=../../dot/core/interface.go -package mocks dot/core Network From 06313f164ef965972648a67b99cb79b6c19abf81 Mon Sep 17 00:00:00 2001 From: Kishan Sagathiya Date: Mon, 26 Sep 2022 19:49:18 +0530 Subject: [PATCH 49/49] fixed the mock generation command --- lib/babe/mocks/network.go | 1113 +------------------------------ lib/babe/mocks_generate_test.go | 2 +- 2 files changed, 6 insertions(+), 1109 deletions(-) diff --git a/lib/babe/mocks/network.go b/lib/babe/mocks/network.go index c27f5df670..1f1314e3cb 100644 --- a/lib/babe/mocks/network.go +++ b/lib/babe/mocks/network.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: ../../dot/core/interface.go +// Source: github.com/ChainSafe/gossamer/dot/core (interfaces: Network) // Package mocks is a generated GoMock package. package mocks @@ -9,995 +9,10 @@ import ( network "github.com/ChainSafe/gossamer/dot/network" peerset "github.com/ChainSafe/gossamer/dot/peerset" - types "github.com/ChainSafe/gossamer/dot/types" - common "github.com/ChainSafe/gossamer/lib/common" - keystore "github.com/ChainSafe/gossamer/lib/keystore" - runtime "github.com/ChainSafe/gossamer/lib/runtime" - storage "github.com/ChainSafe/gossamer/lib/runtime/storage" - transaction "github.com/ChainSafe/gossamer/lib/transaction" gomock "github.com/golang/mock/gomock" peer "github.com/libp2p/go-libp2p-core/peer" ) -// MockRuntimeInstance is a mock of RuntimeInstance interface. -type MockRuntimeInstance struct { - ctrl *gomock.Controller - recorder *MockRuntimeInstanceMockRecorder -} - -// MockRuntimeInstanceMockRecorder is the mock recorder for MockRuntimeInstance. -type MockRuntimeInstanceMockRecorder struct { - mock *MockRuntimeInstance -} - -// NewMockRuntimeInstance creates a new mock instance. -func NewMockRuntimeInstance(ctrl *gomock.Controller) *MockRuntimeInstance { - mock := &MockRuntimeInstance{ctrl: ctrl} - mock.recorder = &MockRuntimeInstanceMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockRuntimeInstance) EXPECT() *MockRuntimeInstanceMockRecorder { - return m.recorder -} - -// ApplyExtrinsic mocks base method. -func (m *MockRuntimeInstance) ApplyExtrinsic(data types.Extrinsic) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ApplyExtrinsic", data) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ApplyExtrinsic indicates an expected call of ApplyExtrinsic. -func (mr *MockRuntimeInstanceMockRecorder) ApplyExtrinsic(data interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyExtrinsic", reflect.TypeOf((*MockRuntimeInstance)(nil).ApplyExtrinsic), data) -} - -// BabeConfiguration mocks base method. -func (m *MockRuntimeInstance) BabeConfiguration() (*types.BabeConfiguration, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BabeConfiguration") - ret0, _ := ret[0].(*types.BabeConfiguration) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BabeConfiguration indicates an expected call of BabeConfiguration. -func (mr *MockRuntimeInstanceMockRecorder) BabeConfiguration() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BabeConfiguration", reflect.TypeOf((*MockRuntimeInstance)(nil).BabeConfiguration)) -} - -// CheckInherents mocks base method. -func (m *MockRuntimeInstance) CheckInherents() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "CheckInherents") -} - -// CheckInherents indicates an expected call of CheckInherents. -func (mr *MockRuntimeInstanceMockRecorder) CheckInherents() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckInherents", reflect.TypeOf((*MockRuntimeInstance)(nil).CheckInherents)) -} - -// DecodeSessionKeys mocks base method. -func (m *MockRuntimeInstance) DecodeSessionKeys(enc []byte) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DecodeSessionKeys", enc) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DecodeSessionKeys indicates an expected call of DecodeSessionKeys. -func (mr *MockRuntimeInstanceMockRecorder) DecodeSessionKeys(enc interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeSessionKeys", reflect.TypeOf((*MockRuntimeInstance)(nil).DecodeSessionKeys), enc) -} - -// Exec mocks base method. -func (m *MockRuntimeInstance) Exec(function string, data []byte) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Exec", function, data) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Exec indicates an expected call of Exec. -func (mr *MockRuntimeInstanceMockRecorder) Exec(function, data interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockRuntimeInstance)(nil).Exec), function, data) -} - -// ExecuteBlock mocks base method. -func (m *MockRuntimeInstance) ExecuteBlock(block *types.Block) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExecuteBlock", block) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExecuteBlock indicates an expected call of ExecuteBlock. -func (mr *MockRuntimeInstanceMockRecorder) ExecuteBlock(block interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteBlock", reflect.TypeOf((*MockRuntimeInstance)(nil).ExecuteBlock), block) -} - -// FinalizeBlock mocks base method. -func (m *MockRuntimeInstance) FinalizeBlock() (*types.Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FinalizeBlock") - ret0, _ := ret[0].(*types.Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FinalizeBlock indicates an expected call of FinalizeBlock. -func (mr *MockRuntimeInstanceMockRecorder) FinalizeBlock() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeBlock", reflect.TypeOf((*MockRuntimeInstance)(nil).FinalizeBlock)) -} - -// GenerateSessionKeys mocks base method. -func (m *MockRuntimeInstance) GenerateSessionKeys() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "GenerateSessionKeys") -} - -// GenerateSessionKeys indicates an expected call of GenerateSessionKeys. -func (mr *MockRuntimeInstanceMockRecorder) GenerateSessionKeys() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateSessionKeys", reflect.TypeOf((*MockRuntimeInstance)(nil).GenerateSessionKeys)) -} - -// GetCodeHash mocks base method. -func (m *MockRuntimeInstance) GetCodeHash() common.Hash { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCodeHash") - ret0, _ := ret[0].(common.Hash) - return ret0 -} - -// GetCodeHash indicates an expected call of GetCodeHash. -func (mr *MockRuntimeInstanceMockRecorder) GetCodeHash() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCodeHash", reflect.TypeOf((*MockRuntimeInstance)(nil).GetCodeHash)) -} - -// GrandpaAuthorities mocks base method. -func (m *MockRuntimeInstance) GrandpaAuthorities() ([]types.Authority, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GrandpaAuthorities") - ret0, _ := ret[0].([]types.Authority) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GrandpaAuthorities indicates an expected call of GrandpaAuthorities. -func (mr *MockRuntimeInstanceMockRecorder) GrandpaAuthorities() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrandpaAuthorities", reflect.TypeOf((*MockRuntimeInstance)(nil).GrandpaAuthorities)) -} - -// InherentExtrinsics mocks base method. -func (m *MockRuntimeInstance) InherentExtrinsics(data []byte) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "InherentExtrinsics", data) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// InherentExtrinsics indicates an expected call of InherentExtrinsics. -func (mr *MockRuntimeInstanceMockRecorder) InherentExtrinsics(data interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InherentExtrinsics", reflect.TypeOf((*MockRuntimeInstance)(nil).InherentExtrinsics), data) -} - -// InitializeBlock mocks base method. -func (m *MockRuntimeInstance) InitializeBlock(header *types.Header) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "InitializeBlock", header) - ret0, _ := ret[0].(error) - return ret0 -} - -// InitializeBlock indicates an expected call of InitializeBlock. -func (mr *MockRuntimeInstanceMockRecorder) InitializeBlock(header interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitializeBlock", reflect.TypeOf((*MockRuntimeInstance)(nil).InitializeBlock), header) -} - -// Keystore mocks base method. -func (m *MockRuntimeInstance) Keystore() *keystore.GlobalKeystore { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Keystore") - ret0, _ := ret[0].(*keystore.GlobalKeystore) - return ret0 -} - -// Keystore indicates an expected call of Keystore. -func (mr *MockRuntimeInstanceMockRecorder) Keystore() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keystore", reflect.TypeOf((*MockRuntimeInstance)(nil).Keystore)) -} - -// Metadata mocks base method. -func (m *MockRuntimeInstance) Metadata() ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Metadata") - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Metadata indicates an expected call of Metadata. -func (mr *MockRuntimeInstanceMockRecorder) Metadata() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Metadata", reflect.TypeOf((*MockRuntimeInstance)(nil).Metadata)) -} - -// NetworkService mocks base method. -func (m *MockRuntimeInstance) NetworkService() runtime.BasicNetwork { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NetworkService") - ret0, _ := ret[0].(runtime.BasicNetwork) - return ret0 -} - -// NetworkService indicates an expected call of NetworkService. -func (mr *MockRuntimeInstanceMockRecorder) NetworkService() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkService", reflect.TypeOf((*MockRuntimeInstance)(nil).NetworkService)) -} - -// NodeStorage mocks base method. -func (m *MockRuntimeInstance) NodeStorage() runtime.NodeStorage { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NodeStorage") - ret0, _ := ret[0].(runtime.NodeStorage) - return ret0 -} - -// NodeStorage indicates an expected call of NodeStorage. -func (mr *MockRuntimeInstanceMockRecorder) NodeStorage() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeStorage", reflect.TypeOf((*MockRuntimeInstance)(nil).NodeStorage)) -} - -// OffchainWorker mocks base method. -func (m *MockRuntimeInstance) OffchainWorker() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "OffchainWorker") -} - -// OffchainWorker indicates an expected call of OffchainWorker. -func (mr *MockRuntimeInstanceMockRecorder) OffchainWorker() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OffchainWorker", reflect.TypeOf((*MockRuntimeInstance)(nil).OffchainWorker)) -} - -// PaymentQueryInfo mocks base method. -func (m *MockRuntimeInstance) PaymentQueryInfo(ext []byte) (*types.TransactionPaymentQueryInfo, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PaymentQueryInfo", ext) - ret0, _ := ret[0].(*types.TransactionPaymentQueryInfo) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PaymentQueryInfo indicates an expected call of PaymentQueryInfo. -func (mr *MockRuntimeInstanceMockRecorder) PaymentQueryInfo(ext interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaymentQueryInfo", reflect.TypeOf((*MockRuntimeInstance)(nil).PaymentQueryInfo), ext) -} - -// RandomSeed mocks base method. -func (m *MockRuntimeInstance) RandomSeed() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "RandomSeed") -} - -// RandomSeed indicates an expected call of RandomSeed. -func (mr *MockRuntimeInstanceMockRecorder) RandomSeed() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomSeed", reflect.TypeOf((*MockRuntimeInstance)(nil).RandomSeed)) -} - -// SetContextStorage mocks base method. -func (m *MockRuntimeInstance) SetContextStorage(s runtime.Storage) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "SetContextStorage", s) -} - -// SetContextStorage indicates an expected call of SetContextStorage. -func (mr *MockRuntimeInstanceMockRecorder) SetContextStorage(s interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContextStorage", reflect.TypeOf((*MockRuntimeInstance)(nil).SetContextStorage), s) -} - -// Stop mocks base method. -func (m *MockRuntimeInstance) Stop() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Stop") -} - -// Stop indicates an expected call of Stop. -func (mr *MockRuntimeInstanceMockRecorder) Stop() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockRuntimeInstance)(nil).Stop)) -} - -// UpdateRuntimeCode mocks base method. -func (m *MockRuntimeInstance) UpdateRuntimeCode(arg0 []byte) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateRuntimeCode", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// UpdateRuntimeCode indicates an expected call of UpdateRuntimeCode. -func (mr *MockRuntimeInstanceMockRecorder) UpdateRuntimeCode(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRuntimeCode", reflect.TypeOf((*MockRuntimeInstance)(nil).UpdateRuntimeCode), arg0) -} - -// ValidateTransaction mocks base method. -func (m *MockRuntimeInstance) ValidateTransaction(e types.Extrinsic) (*transaction.Validity, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ValidateTransaction", e) - ret0, _ := ret[0].(*transaction.Validity) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ValidateTransaction indicates an expected call of ValidateTransaction. -func (mr *MockRuntimeInstanceMockRecorder) ValidateTransaction(e interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateTransaction", reflect.TypeOf((*MockRuntimeInstance)(nil).ValidateTransaction), e) -} - -// Validator mocks base method. -func (m *MockRuntimeInstance) Validator() bool { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Validator") - ret0, _ := ret[0].(bool) - return ret0 -} - -// Validator indicates an expected call of Validator. -func (mr *MockRuntimeInstanceMockRecorder) Validator() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validator", reflect.TypeOf((*MockRuntimeInstance)(nil).Validator)) -} - -// Version mocks base method. -func (m *MockRuntimeInstance) Version() runtime.Version { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Version") - ret0, _ := ret[0].(runtime.Version) - return ret0 -} - -// Version indicates an expected call of Version. -func (mr *MockRuntimeInstanceMockRecorder) Version() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockRuntimeInstance)(nil).Version)) -} - -// MockBlockState is a mock of BlockState interface. -type MockBlockState struct { - ctrl *gomock.Controller - recorder *MockBlockStateMockRecorder -} - -// MockBlockStateMockRecorder is the mock recorder for MockBlockState. -type MockBlockStateMockRecorder struct { - mock *MockBlockState -} - -// NewMockBlockState creates a new mock instance. -func NewMockBlockState(ctrl *gomock.Controller) *MockBlockState { - mock := &MockBlockState{ctrl: ctrl} - mock.recorder = &MockBlockStateMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockBlockState) EXPECT() *MockBlockStateMockRecorder { - return m.recorder -} - -// AddBlock mocks base method. -func (m *MockBlockState) AddBlock(arg0 *types.Block) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddBlock", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// AddBlock indicates an expected call of AddBlock. -func (mr *MockBlockStateMockRecorder) AddBlock(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlock", reflect.TypeOf((*MockBlockState)(nil).AddBlock), arg0) -} - -// BestBlock mocks base method. -func (m *MockBlockState) BestBlock() (*types.Block, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BestBlock") - ret0, _ := ret[0].(*types.Block) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BestBlock indicates an expected call of BestBlock. -func (mr *MockBlockStateMockRecorder) BestBlock() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlock", reflect.TypeOf((*MockBlockState)(nil).BestBlock)) -} - -// BestBlockHash mocks base method. -func (m *MockBlockState) BestBlockHash() common.Hash { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BestBlockHash") - ret0, _ := ret[0].(common.Hash) - return ret0 -} - -// BestBlockHash indicates an expected call of BestBlockHash. -func (mr *MockBlockStateMockRecorder) BestBlockHash() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlockHash", reflect.TypeOf((*MockBlockState)(nil).BestBlockHash)) -} - -// BestBlockHeader mocks base method. -func (m *MockBlockState) BestBlockHeader() (*types.Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BestBlockHeader") - ret0, _ := ret[0].(*types.Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BestBlockHeader indicates an expected call of BestBlockHeader. -func (mr *MockBlockStateMockRecorder) BestBlockHeader() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlockHeader", reflect.TypeOf((*MockBlockState)(nil).BestBlockHeader)) -} - -// BestBlockNumber mocks base method. -func (m *MockBlockState) BestBlockNumber() (uint, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BestBlockNumber") - ret0, _ := ret[0].(uint) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BestBlockNumber indicates an expected call of BestBlockNumber. -func (mr *MockBlockStateMockRecorder) BestBlockNumber() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlockNumber", reflect.TypeOf((*MockBlockState)(nil).BestBlockNumber)) -} - -// BestBlockStateRoot mocks base method. -func (m *MockBlockState) BestBlockStateRoot() (common.Hash, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BestBlockStateRoot") - ret0, _ := ret[0].(common.Hash) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BestBlockStateRoot indicates an expected call of BestBlockStateRoot. -func (mr *MockBlockStateMockRecorder) BestBlockStateRoot() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestBlockStateRoot", reflect.TypeOf((*MockBlockState)(nil).BestBlockStateRoot)) -} - -// FreeFinalisedNotifierChannel mocks base method. -func (m *MockBlockState) FreeFinalisedNotifierChannel(ch chan *types.FinalisationInfo) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "FreeFinalisedNotifierChannel", ch) -} - -// FreeFinalisedNotifierChannel indicates an expected call of FreeFinalisedNotifierChannel. -func (mr *MockBlockStateMockRecorder) FreeFinalisedNotifierChannel(ch interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FreeFinalisedNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).FreeFinalisedNotifierChannel), ch) -} - -// FreeImportedBlockNotifierChannel mocks base method. -func (m *MockBlockState) FreeImportedBlockNotifierChannel(ch chan *types.Block) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "FreeImportedBlockNotifierChannel", ch) -} - -// FreeImportedBlockNotifierChannel indicates an expected call of FreeImportedBlockNotifierChannel. -func (mr *MockBlockStateMockRecorder) FreeImportedBlockNotifierChannel(ch interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FreeImportedBlockNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).FreeImportedBlockNotifierChannel), ch) -} - -// GenesisHash mocks base method. -func (m *MockBlockState) GenesisHash() common.Hash { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GenesisHash") - ret0, _ := ret[0].(common.Hash) - return ret0 -} - -// GenesisHash indicates an expected call of GenesisHash. -func (mr *MockBlockStateMockRecorder) GenesisHash() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenesisHash", reflect.TypeOf((*MockBlockState)(nil).GenesisHash)) -} - -// GetAllBlocksAtDepth mocks base method. -func (m *MockBlockState) GetAllBlocksAtDepth(hash common.Hash) []common.Hash { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAllBlocksAtDepth", hash) - ret0, _ := ret[0].([]common.Hash) - return ret0 -} - -// GetAllBlocksAtDepth indicates an expected call of GetAllBlocksAtDepth. -func (mr *MockBlockStateMockRecorder) GetAllBlocksAtDepth(hash interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBlocksAtDepth", reflect.TypeOf((*MockBlockState)(nil).GetAllBlocksAtDepth), hash) -} - -// GetBlockBody mocks base method. -func (m *MockBlockState) GetBlockBody(hash common.Hash) (*types.Body, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetBlockBody", hash) - ret0, _ := ret[0].(*types.Body) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetBlockBody indicates an expected call of GetBlockBody. -func (mr *MockBlockStateMockRecorder) GetBlockBody(hash interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockBody", reflect.TypeOf((*MockBlockState)(nil).GetBlockBody), hash) -} - -// GetBlockByHash mocks base method. -func (m *MockBlockState) GetBlockByHash(arg0 common.Hash) (*types.Block, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetBlockByHash", arg0) - ret0, _ := ret[0].(*types.Block) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetBlockByHash indicates an expected call of GetBlockByHash. -func (mr *MockBlockStateMockRecorder) GetBlockByHash(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByHash", reflect.TypeOf((*MockBlockState)(nil).GetBlockByHash), arg0) -} - -// GetBlockStateRoot mocks base method. -func (m *MockBlockState) GetBlockStateRoot(bhash common.Hash) (common.Hash, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetBlockStateRoot", bhash) - ret0, _ := ret[0].(common.Hash) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetBlockStateRoot indicates an expected call of GetBlockStateRoot. -func (mr *MockBlockStateMockRecorder) GetBlockStateRoot(bhash interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockStateRoot", reflect.TypeOf((*MockBlockState)(nil).GetBlockStateRoot), bhash) -} - -// GetFinalisedHash mocks base method. -func (m *MockBlockState) GetFinalisedHash(arg0, arg1 uint64) (common.Hash, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetFinalisedHash", arg0, arg1) - ret0, _ := ret[0].(common.Hash) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetFinalisedHash indicates an expected call of GetFinalisedHash. -func (mr *MockBlockStateMockRecorder) GetFinalisedHash(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinalisedHash", reflect.TypeOf((*MockBlockState)(nil).GetFinalisedHash), arg0, arg1) -} - -// GetFinalisedHeader mocks base method. -func (m *MockBlockState) GetFinalisedHeader(arg0, arg1 uint64) (*types.Header, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetFinalisedHeader", arg0, arg1) - ret0, _ := ret[0].(*types.Header) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetFinalisedHeader indicates an expected call of GetFinalisedHeader. -func (mr *MockBlockStateMockRecorder) GetFinalisedHeader(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinalisedHeader", reflect.TypeOf((*MockBlockState)(nil).GetFinalisedHeader), arg0, arg1) -} - -// GetFinalisedNotifierChannel mocks base method. -func (m *MockBlockState) GetFinalisedNotifierChannel() chan *types.FinalisationInfo { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetFinalisedNotifierChannel") - ret0, _ := ret[0].(chan *types.FinalisationInfo) - return ret0 -} - -// GetFinalisedNotifierChannel indicates an expected call of GetFinalisedNotifierChannel. -func (mr *MockBlockStateMockRecorder) GetFinalisedNotifierChannel() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinalisedNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).GetFinalisedNotifierChannel)) -} - -// GetImportedBlockNotifierChannel mocks base method. -func (m *MockBlockState) GetImportedBlockNotifierChannel() chan *types.Block { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetImportedBlockNotifierChannel") - ret0, _ := ret[0].(chan *types.Block) - return ret0 -} - -// GetImportedBlockNotifierChannel indicates an expected call of GetImportedBlockNotifierChannel. -func (mr *MockBlockStateMockRecorder) GetImportedBlockNotifierChannel() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImportedBlockNotifierChannel", reflect.TypeOf((*MockBlockState)(nil).GetImportedBlockNotifierChannel)) -} - -// GetRuntime mocks base method. -func (m *MockBlockState) GetRuntime(arg0 *common.Hash) (runtime.Instance, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRuntime", arg0) - ret0, _ := ret[0].(runtime.Instance) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetRuntime indicates an expected call of GetRuntime. -func (mr *MockBlockStateMockRecorder) GetRuntime(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRuntime", reflect.TypeOf((*MockBlockState)(nil).GetRuntime), arg0) -} - -// GetSlotForBlock mocks base method. -func (m *MockBlockState) GetSlotForBlock(arg0 common.Hash) (uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSlotForBlock", arg0) - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSlotForBlock indicates an expected call of GetSlotForBlock. -func (mr *MockBlockStateMockRecorder) GetSlotForBlock(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSlotForBlock", reflect.TypeOf((*MockBlockState)(nil).GetSlotForBlock), arg0) -} - -// HandleRuntimeChanges mocks base method. -func (m *MockBlockState) HandleRuntimeChanges(newState *storage.TrieState, in runtime.Instance, bHash common.Hash) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HandleRuntimeChanges", newState, in, bHash) - ret0, _ := ret[0].(error) - return ret0 -} - -// HandleRuntimeChanges indicates an expected call of HandleRuntimeChanges. -func (mr *MockBlockStateMockRecorder) HandleRuntimeChanges(newState, in, bHash interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRuntimeChanges", reflect.TypeOf((*MockBlockState)(nil).HandleRuntimeChanges), newState, in, bHash) -} - -// HighestCommonAncestor mocks base method. -func (m *MockBlockState) HighestCommonAncestor(a, b common.Hash) (common.Hash, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HighestCommonAncestor", a, b) - ret0, _ := ret[0].(common.Hash) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// HighestCommonAncestor indicates an expected call of HighestCommonAncestor. -func (mr *MockBlockStateMockRecorder) HighestCommonAncestor(a, b interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HighestCommonAncestor", reflect.TypeOf((*MockBlockState)(nil).HighestCommonAncestor), a, b) -} - -// StoreRuntime mocks base method. -func (m *MockBlockState) StoreRuntime(arg0 common.Hash, arg1 runtime.Instance) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "StoreRuntime", arg0, arg1) -} - -// StoreRuntime indicates an expected call of StoreRuntime. -func (mr *MockBlockStateMockRecorder) StoreRuntime(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreRuntime", reflect.TypeOf((*MockBlockState)(nil).StoreRuntime), arg0, arg1) -} - -// SubChain mocks base method. -func (m *MockBlockState) SubChain(start, end common.Hash) ([]common.Hash, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SubChain", start, end) - ret0, _ := ret[0].([]common.Hash) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SubChain indicates an expected call of SubChain. -func (mr *MockBlockStateMockRecorder) SubChain(start, end interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubChain", reflect.TypeOf((*MockBlockState)(nil).SubChain), start, end) -} - -// MockStorageState is a mock of StorageState interface. -type MockStorageState struct { - ctrl *gomock.Controller - recorder *MockStorageStateMockRecorder -} - -// MockStorageStateMockRecorder is the mock recorder for MockStorageState. -type MockStorageStateMockRecorder struct { - mock *MockStorageState -} - -// NewMockStorageState creates a new mock instance. -func NewMockStorageState(ctrl *gomock.Controller) *MockStorageState { - mock := &MockStorageState{ctrl: ctrl} - mock.recorder = &MockStorageStateMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockStorageState) EXPECT() *MockStorageStateMockRecorder { - return m.recorder -} - -// GenerateTrieProof mocks base method. -func (m *MockStorageState) GenerateTrieProof(stateRoot common.Hash, keys [][]byte) ([][]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GenerateTrieProof", stateRoot, keys) - ret0, _ := ret[0].([][]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GenerateTrieProof indicates an expected call of GenerateTrieProof. -func (mr *MockStorageStateMockRecorder) GenerateTrieProof(stateRoot, keys interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateTrieProof", reflect.TypeOf((*MockStorageState)(nil).GenerateTrieProof), stateRoot, keys) -} - -// GetStateRootFromBlock mocks base method. -func (m *MockStorageState) GetStateRootFromBlock(bhash *common.Hash) (*common.Hash, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetStateRootFromBlock", bhash) - ret0, _ := ret[0].(*common.Hash) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetStateRootFromBlock indicates an expected call of GetStateRootFromBlock. -func (mr *MockStorageStateMockRecorder) GetStateRootFromBlock(bhash interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateRootFromBlock", reflect.TypeOf((*MockStorageState)(nil).GetStateRootFromBlock), bhash) -} - -// GetStorage mocks base method. -func (m *MockStorageState) GetStorage(root *common.Hash, key []byte) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetStorage", root, key) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetStorage indicates an expected call of GetStorage. -func (mr *MockStorageStateMockRecorder) GetStorage(root, key interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorage", reflect.TypeOf((*MockStorageState)(nil).GetStorage), root, key) -} - -// LoadCode mocks base method. -func (m *MockStorageState) LoadCode(root *common.Hash) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LoadCode", root) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LoadCode indicates an expected call of LoadCode. -func (mr *MockStorageStateMockRecorder) LoadCode(root interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadCode", reflect.TypeOf((*MockStorageState)(nil).LoadCode), root) -} - -// LoadCodeHash mocks base method. -func (m *MockStorageState) LoadCodeHash(root *common.Hash) (common.Hash, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LoadCodeHash", root) - ret0, _ := ret[0].(common.Hash) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LoadCodeHash indicates an expected call of LoadCodeHash. -func (mr *MockStorageStateMockRecorder) LoadCodeHash(root interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadCodeHash", reflect.TypeOf((*MockStorageState)(nil).LoadCodeHash), root) -} - -// Lock mocks base method. -func (m *MockStorageState) Lock() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Lock") -} - -// Lock indicates an expected call of Lock. -func (mr *MockStorageStateMockRecorder) Lock() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockStorageState)(nil).Lock)) -} - -// StoreTrie mocks base method. -func (m *MockStorageState) StoreTrie(arg0 *storage.TrieState, arg1 *types.Header) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StoreTrie", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// StoreTrie indicates an expected call of StoreTrie. -func (mr *MockStorageStateMockRecorder) StoreTrie(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreTrie", reflect.TypeOf((*MockStorageState)(nil).StoreTrie), arg0, arg1) -} - -// TrieState mocks base method. -func (m *MockStorageState) TrieState(root *common.Hash) (*storage.TrieState, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TrieState", root) - ret0, _ := ret[0].(*storage.TrieState) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TrieState indicates an expected call of TrieState. -func (mr *MockStorageStateMockRecorder) TrieState(root interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrieState", reflect.TypeOf((*MockStorageState)(nil).TrieState), root) -} - -// Unlock mocks base method. -func (m *MockStorageState) Unlock() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Unlock") -} - -// Unlock indicates an expected call of Unlock. -func (mr *MockStorageStateMockRecorder) Unlock() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockStorageState)(nil).Unlock)) -} - -// MockTransactionState is a mock of TransactionState interface. -type MockTransactionState struct { - ctrl *gomock.Controller - recorder *MockTransactionStateMockRecorder -} - -// MockTransactionStateMockRecorder is the mock recorder for MockTransactionState. -type MockTransactionStateMockRecorder struct { - mock *MockTransactionState -} - -// NewMockTransactionState creates a new mock instance. -func NewMockTransactionState(ctrl *gomock.Controller) *MockTransactionState { - mock := &MockTransactionState{ctrl: ctrl} - mock.recorder = &MockTransactionStateMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockTransactionState) EXPECT() *MockTransactionStateMockRecorder { - return m.recorder -} - -// AddToPool mocks base method. -func (m *MockTransactionState) AddToPool(vt *transaction.ValidTransaction) common.Hash { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddToPool", vt) - ret0, _ := ret[0].(common.Hash) - return ret0 -} - -// AddToPool indicates an expected call of AddToPool. -func (mr *MockTransactionStateMockRecorder) AddToPool(vt interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddToPool", reflect.TypeOf((*MockTransactionState)(nil).AddToPool), vt) -} - -// Exists mocks base method. -func (m *MockTransactionState) Exists(ext types.Extrinsic) bool { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Exists", ext) - ret0, _ := ret[0].(bool) - return ret0 -} - -// Exists indicates an expected call of Exists. -func (mr *MockTransactionStateMockRecorder) Exists(ext interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockTransactionState)(nil).Exists), ext) -} - -// PendingInPool mocks base method. -func (m *MockTransactionState) PendingInPool() []*transaction.ValidTransaction { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PendingInPool") - ret0, _ := ret[0].([]*transaction.ValidTransaction) - return ret0 -} - -// PendingInPool indicates an expected call of PendingInPool. -func (mr *MockTransactionStateMockRecorder) PendingInPool() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingInPool", reflect.TypeOf((*MockTransactionState)(nil).PendingInPool)) -} - -// Push mocks base method. -func (m *MockTransactionState) Push(vt *transaction.ValidTransaction) (common.Hash, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Push", vt) - ret0, _ := ret[0].(common.Hash) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Push indicates an expected call of Push. -func (mr *MockTransactionStateMockRecorder) Push(vt interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockTransactionState)(nil).Push), vt) -} - -// RemoveExtrinsic mocks base method. -func (m *MockTransactionState) RemoveExtrinsic(ext types.Extrinsic) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "RemoveExtrinsic", ext) -} - -// RemoveExtrinsic indicates an expected call of RemoveExtrinsic. -func (mr *MockTransactionStateMockRecorder) RemoveExtrinsic(ext interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveExtrinsic", reflect.TypeOf((*MockTransactionState)(nil).RemoveExtrinsic), ext) -} - -// RemoveExtrinsicFromPool mocks base method. -func (m *MockTransactionState) RemoveExtrinsicFromPool(ext types.Extrinsic) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "RemoveExtrinsicFromPool", ext) -} - -// RemoveExtrinsicFromPool indicates an expected call of RemoveExtrinsicFromPool. -func (mr *MockTransactionStateMockRecorder) RemoveExtrinsicFromPool(ext interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveExtrinsicFromPool", reflect.TypeOf((*MockTransactionState)(nil).RemoveExtrinsicFromPool), ext) -} - // MockNetwork is a mock of Network interface. type MockNetwork struct { ctrl *gomock.Controller @@ -1048,131 +63,13 @@ func (mr *MockNetworkMockRecorder) IsSynced() *gomock.Call { } // ReportPeer mocks base method. -func (m *MockNetwork) ReportPeer(change peerset.ReputationChange, p peer.ID) { +func (m *MockNetwork) ReportPeer(arg0 peerset.ReputationChange, arg1 peer.ID) { m.ctrl.T.Helper() - m.ctrl.Call(m, "ReportPeer", change, p) + m.ctrl.Call(m, "ReportPeer", arg0, arg1) } // ReportPeer indicates an expected call of ReportPeer. -func (mr *MockNetworkMockRecorder) ReportPeer(change, p interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), change, p) -} - -// MockEpochState is a mock of EpochState interface. -type MockEpochState struct { - ctrl *gomock.Controller - recorder *MockEpochStateMockRecorder -} - -// MockEpochStateMockRecorder is the mock recorder for MockEpochState. -type MockEpochStateMockRecorder struct { - mock *MockEpochState -} - -// NewMockEpochState creates a new mock instance. -func NewMockEpochState(ctrl *gomock.Controller) *MockEpochState { - mock := &MockEpochState{ctrl: ctrl} - mock.recorder = &MockEpochStateMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockEpochState) EXPECT() *MockEpochStateMockRecorder { - return m.recorder -} - -// GetCurrentEpoch mocks base method. -func (m *MockEpochState) GetCurrentEpoch() (uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCurrentEpoch") - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCurrentEpoch indicates an expected call of GetCurrentEpoch. -func (mr *MockEpochStateMockRecorder) GetCurrentEpoch() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentEpoch", reflect.TypeOf((*MockEpochState)(nil).GetCurrentEpoch)) -} - -// GetEpochForBlock mocks base method. -func (m *MockEpochState) GetEpochForBlock(header *types.Header) (uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEpochForBlock", header) - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetEpochForBlock indicates an expected call of GetEpochForBlock. -func (mr *MockEpochStateMockRecorder) GetEpochForBlock(header interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpochForBlock", reflect.TypeOf((*MockEpochState)(nil).GetEpochForBlock), header) -} - -// SetCurrentEpoch mocks base method. -func (m *MockEpochState) SetCurrentEpoch(epoch uint64) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetCurrentEpoch", epoch) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetCurrentEpoch indicates an expected call of SetCurrentEpoch. -func (mr *MockEpochStateMockRecorder) SetCurrentEpoch(epoch interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentEpoch", reflect.TypeOf((*MockEpochState)(nil).SetCurrentEpoch), epoch) -} - -// MockCodeSubstitutedState is a mock of CodeSubstitutedState interface. -type MockCodeSubstitutedState struct { - ctrl *gomock.Controller - recorder *MockCodeSubstitutedStateMockRecorder -} - -// MockCodeSubstitutedStateMockRecorder is the mock recorder for MockCodeSubstitutedState. -type MockCodeSubstitutedStateMockRecorder struct { - mock *MockCodeSubstitutedState -} - -// NewMockCodeSubstitutedState creates a new mock instance. -func NewMockCodeSubstitutedState(ctrl *gomock.Controller) *MockCodeSubstitutedState { - mock := &MockCodeSubstitutedState{ctrl: ctrl} - mock.recorder = &MockCodeSubstitutedStateMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockCodeSubstitutedState) EXPECT() *MockCodeSubstitutedStateMockRecorder { - return m.recorder -} - -// LoadCodeSubstitutedBlockHash mocks base method. -func (m *MockCodeSubstitutedState) LoadCodeSubstitutedBlockHash() common.Hash { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LoadCodeSubstitutedBlockHash") - ret0, _ := ret[0].(common.Hash) - return ret0 -} - -// LoadCodeSubstitutedBlockHash indicates an expected call of LoadCodeSubstitutedBlockHash. -func (mr *MockCodeSubstitutedStateMockRecorder) LoadCodeSubstitutedBlockHash() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadCodeSubstitutedBlockHash", reflect.TypeOf((*MockCodeSubstitutedState)(nil).LoadCodeSubstitutedBlockHash)) -} - -// StoreCodeSubstitutedBlockHash mocks base method. -func (m *MockCodeSubstitutedState) StoreCodeSubstitutedBlockHash(hash common.Hash) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StoreCodeSubstitutedBlockHash", hash) - ret0, _ := ret[0].(error) - return ret0 -} - -// StoreCodeSubstitutedBlockHash indicates an expected call of StoreCodeSubstitutedBlockHash. -func (mr *MockCodeSubstitutedStateMockRecorder) StoreCodeSubstitutedBlockHash(hash interface{}) *gomock.Call { +func (mr *MockNetworkMockRecorder) ReportPeer(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreCodeSubstitutedBlockHash", reflect.TypeOf((*MockCodeSubstitutedState)(nil).StoreCodeSubstitutedBlockHash), hash) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeer", reflect.TypeOf((*MockNetwork)(nil).ReportPeer), arg0, arg1) } diff --git a/lib/babe/mocks_generate_test.go b/lib/babe/mocks_generate_test.go index 706f2433cb..f392cf6f6f 100644 --- a/lib/babe/mocks_generate_test.go +++ b/lib/babe/mocks_generate_test.go @@ -3,4 +3,4 @@ package babe -//go:generate mockgen -destination=mocks/network.go -source=../../dot/core/interface.go -package mocks dot/core Network +//go:generate mockgen -destination=mocks/network.go -package=mocks github.com/ChainSafe/gossamer/dot/core Network