diff --git a/Makefile b/Makefile index 45687bc4f8..80514a0d11 100644 --- a/Makefile +++ b/Makefile @@ -88,11 +88,11 @@ build-retransmitter-windows: release-retransmitter: ver build-retransmitter-linux build-retransmitter-darwin build-retransmitter-windows build-node-linux: - @GOOS=linux GOARCH=amd64 go build -o build/bin/linux-amd64/node ./cmd/node + @GOOS=linux GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/linux-amd64/node ./cmd/node build-node-darwin: - @GOOS=darwin GOARCH=amd64 go build -o build/bin/darwin-amd64/node ./cmd/node + @GOOS=darwin GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/darwin-amd64/node ./cmd/node build-node-windows: - @GOOS=windows GOARCH=amd64 go build -o build/bin/windows-amd64/node.exe ./cmd/node + @GOOS=windows GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/windows-amd64/node.exe ./cmd/node release-node: ver build-node-linux build-node-darwin build-node-windows @@ -103,11 +103,11 @@ dist-node: release-node build-node-mainnet-deb-package build-node-testnet-deb-pa @cd ./build/bin/darwin-amd64/; tar pzcvf ../../dist/node_$(VERSION)_macOS-64bit.tar.gz ./node* build-custom-linux: - @CGO_ENABLE=0 GOOS=linux GOARCH=amd64 go build -o build/bin/linux-amd64/custom ./cmd/custom + @CGO_ENABLE=0 GOOS=linux GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/linux-amd64/custom ./cmd/custom build-custom-darwin: - @CGO_ENABLE=0 GOOS=darwin GOARCH=amd64 go build -o build/bin/darwin-amd64/custom ./cmd/custom + @CGO_ENABLE=0 GOOS=darwin GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/darwin-amd64/custom ./cmd/custom build-custom-windows: - @CGO_ENABLE=0 GOOS=windows GOARCH=amd64 go build -o build/bin/windows-amd64/custom.exe ./cmd/custom + @CGO_ENABLE=0 GOOS=windows GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/windows-amd64/custom.exe ./cmd/custom build-custom: ver build-custom-linux build-custom-darwin build-custom-windows diff --git a/cmd/custom/node.go b/cmd/custom/node.go index 4b2cbd7797..2adf9944fa 100644 --- a/cmd/custom/node.go +++ b/cmd/custom/node.go @@ -46,7 +46,7 @@ var ( apiAddr = flag.String("api-address", "", "Address for REST API") grpcAddr = flag.String("grpc-address", "127.0.0.1:7475", "Address for gRPC API") cfgPath = flag.String("cfg-path", "", "Path to configuration JSON file. No default value.") - enableGrpcApi = flag.Bool("enable-grpc-api", true, "Enables/disables gRPC API") + enableGrpcApi = flag.Bool("enable-grpc-api", false, "Enables/disables gRPC API") buildExtendedApi = flag.Bool("build-extended-api", false, "Builds extended API. Note that state must be re-imported in case it wasn't imported with similar flag set") serveExtendedApi = flag.Bool("serve-extended-api", false, "Serves extended API requests since the very beginning. The default behavior is to import until first block close to current time, and start serving at this point") buildStateHashes = flag.Bool("build-state-hashes", false, "Calculate and store state hashes for each block height.") @@ -60,6 +60,11 @@ var ( dropPeers = flag.Bool("drop-peers", false, "Drop peers storage before node start.") ) +// nickeskov: compile time constants with defaults +var ( + buildVersion = "(not specified)" +) + func init() { common.SetupLogger(*logLevel) } @@ -209,7 +214,7 @@ func main() { zap.S().Info("Successfully dropped peers storage") } - peerManager := peer_manager.NewPeerManager(peerSpawnerImpl, peerStorage, int(limitConnections), version) + peerManager := peer_manager.NewPeerManager(peerSpawnerImpl, peerStorage, int(limitConnections), version, conf.WavesNetwork) go peerManager.Run(ctx) scheduler := scheduler2.NewScheduler( @@ -267,8 +272,12 @@ func main() { } } + apiConfig := api.AppConfig{ + BlockchainType: "", + BuildVersion: buildVersion, + } // TODO hardcore - app, err := api.NewApp("integration-test-rest-api", scheduler, nodeServices) + app, err := api.NewApp("integration-test-rest-api", scheduler, nodeServices, apiConfig) if err != nil { zap.S().Error(err) cancel() diff --git a/cmd/node/node.go b/cmd/node/node.go index 9a0dd7e06b..ad491a4373 100644 --- a/cmd/node/node.go +++ b/cmd/node/node.go @@ -58,7 +58,7 @@ var ( apiAddr = flag.String("api-address", "", "Address for REST API") apiKey = flag.String("api-key", "", "Api key") grpcAddr = flag.String("grpc-address", "127.0.0.1:7475", "Address for gRPC API") - enableGrpcApi = flag.Bool("enable-grpc-api", true, "Enables/disables gRPC API") + enableGrpcApi = flag.Bool("enable-grpc-api", false, "Enables/disables gRPC API") buildExtendedApi = flag.Bool("build-extended-api", false, "Builds extended API. Note that state must be re-imported in case it wasn't imported with similar flag set") serveExtendedApi = flag.Bool("serve-extended-api", false, "Serves extended API requests since the very beginning. The default behavior is to import until first block close to current time, and start serving at this point") buildStateHashes = flag.Bool("build-state-hashes", false, "Calculate and store state hashes for each block height.") @@ -92,6 +92,11 @@ var defaultPeers = map[string]string{ "stagenet": "88.99.185.128:6868,49.12.15.166:6868,95.216.205.3:6868,88.198.179.16:6868", } +// nickeskov: compile time constants with defaults +var ( + buildVersion = "(not specified)" +) + type Scheduler interface { Mine() chan scheduler.Emit types.Scheduler @@ -319,6 +324,7 @@ func main() { peerStorage, int(limitConnections), version, + conf.WavesNetwork, ) go peerManager.Run(ctx) @@ -378,7 +384,12 @@ func main() { } } - app, err := api.NewApp(*apiKey, minerScheduler, svs) + apiConfig := api.AppConfig{ + BlockchainType: *blockchainType, + BuildVersion: buildVersion, + } + + app, err := api.NewApp(*apiKey, minerScheduler, svs, apiConfig) if err != nil { zap.S().Error(err) cancel() diff --git a/cmd/wmd/internal/state/accounts.go b/cmd/wmd/internal/state/accounts.go index 94fca51844..caf1c3ffed 100644 --- a/cmd/wmd/internal/state/accounts.go +++ b/cmd/wmd/internal/state/accounts.go @@ -394,7 +394,8 @@ func putAccounts(bs *blockState, batch *leveldb.Batch, height uint32, accountCha return errors.Wrapf(err, "failed to get the sponsorship for '%s'", u.Asset.String()) } if !ok { - return errors.Errorf("no asset info for an asset '%s'", u.Asset.String()) + zap.S().Warnf("Transaction sponsored with asset '%s' issued by Invoke", u.Asset.String()) + return nil //TODO: errors.Errorf("no asset info for an asset '%s'", u.Asset.String()) } if a.sponsored { err := updateBalanceAndHistory(bs, batch, height, a.issuer, u.Asset, u.In, u.Out) diff --git a/cmd/wmd/internal/state/meta.go b/cmd/wmd/internal/state/meta.go index a96d7aaa44..ddee95d367 100644 --- a/cmd/wmd/internal/state/meta.go +++ b/cmd/wmd/internal/state/meta.go @@ -2,11 +2,12 @@ package state import ( "encoding/binary" + "math" + "github.com/pkg/errors" "github.com/syndtr/goleveldb/leveldb" "github.com/syndtr/goleveldb/leveldb/util" "github.com/wavesplatform/gowaves/pkg/proto" - "math" ) var heightKeyBytes = []byte{heightKeyPrefix} @@ -62,7 +63,7 @@ func block(snapshot *leveldb.Snapshot, height uint32) (proto.BlockID, bool, erro } bid, err := proto.NewBlockIDFromBytes(b) if err != nil { - return proto.BlockID{}, false, nil + return proto.BlockID{}, false, wrapError(err) } return bid, true, nil } diff --git a/cmd/wmd/internal/synchronizer.go b/cmd/wmd/internal/synchronizer.go index 883d5353d5..682de9fe05 100644 --- a/cmd/wmd/internal/synchronizer.go +++ b/cmd/wmd/internal/synchronizer.go @@ -1,6 +1,7 @@ package internal import ( + "bytes" "context" "strings" "time" @@ -275,7 +276,7 @@ func (s *Synchronizer) equalIDs(height int) (bool, error) { if err != nil { return false, err } - return rbs == lbs, nil + return bytes.Equal(rbs.Bytes(), lbs.Bytes()), nil } func (s *Synchronizer) extractTransactions(txs []proto.Transaction, miner crypto.PublicKey) ([]data.Trade, []data.IssueChange, []data.AssetChange, []data.AccountChange, []data.AliasBind, error) { diff --git a/pkg/api/app.go b/pkg/api/app.go index c051b396f2..8f253327be 100644 --- a/pkg/api/app.go +++ b/pkg/api/app.go @@ -3,6 +3,7 @@ package api import ( "context" "encoding/json" + "github.com/mr-tron/base58" "time" "github.com/pkg/errors" @@ -34,9 +35,24 @@ type App struct { peers peer_manager.PeerManager sync types.StateSync services services.Services + config AppConfig } -func NewApp(apiKey string, scheduler SchedulerEmits, services services.Services) (*App, error) { +type AppConfig struct { + BlockchainType string + BuildVersion string +} + +func (ac *AppConfig) Validate() error { + // TODO(nickeskov): implement me + return nil +} + +func NewApp(apiKey string, scheduler SchedulerEmits, services services.Services, config AppConfig) (*App, error) { + if err := config.Validate(); err != nil { + return nil, err + } + digest, err := crypto.SecureHash([]byte(apiKey)) if err != nil { return nil, err @@ -50,9 +66,14 @@ func NewApp(apiKey string, scheduler SchedulerEmits, services services.Services) utx: services.UtxPool, peers: services.Peers, services: services, + config: config, }, nil } +func (a *App) Config() *AppConfig { + return &a.config +} + func (a *App) TransactionsBroadcast(ctx context.Context, b []byte) error { tt := proto.TransactionTypeVersion{} err := json.Unmarshal(b, &tt) @@ -96,6 +117,18 @@ func (a *App) LoadKeys(apiKey string, password []byte) error { return a.services.Wallet.Load(password) } +// WalletSeeds returns wallet seeds in base58 encoding. +func (a *App) WalletSeeds() []string { + seeds := a.services.Wallet.Seeds() + + seeds58 := make([]string, 0, len(seeds)) + for _, seed := range seeds { + seed58 := base58.Encode(seed) + seeds58 = append(seeds58, seed58) + } + return seeds58 +} + func (a *App) Accounts() ([]account, error) { seeds := a.services.Wallet.Seeds() diff --git a/pkg/api/app_alias.go b/pkg/api/app_alias.go new file mode 100644 index 0000000000..b93f6cfefe --- /dev/null +++ b/pkg/api/app_alias.go @@ -0,0 +1,23 @@ +package api + +import ( + "github.com/pkg/errors" + "github.com/wavesplatform/gowaves/pkg/proto" + "github.com/wavesplatform/gowaves/pkg/state" +) + +func (a *App) AddrByAlias(alias proto.Alias) (proto.Address, error) { + addr, err := a.state.AddrByAlias(alias) + if err != nil { + if state.IsNotFound(err) { + return proto.Address{}, err + } + return proto.Address{}, errors.Wrapf(err, "failed to find addr by alias %q", alias.String()) + } + return addr, nil +} + +func (a *App) AliasesOfAddr(addr proto.Address) ([]proto.Alias, error) { + // TODO(nickeskov): implement me + panic("AliasesOfAddr: NOT IMPLEMENTED") +} diff --git a/pkg/api/app_blocks_test.go b/pkg/api/app_blocks_test.go index 4ca7112e25..97cc6e3e8e 100644 --- a/pkg/api/app_blocks_test.go +++ b/pkg/api/app_blocks_test.go @@ -24,7 +24,7 @@ func TestApp_BlocksFirst(t *testing.T) { s := mock.NewMockState(ctrl) s.EXPECT().BlockByHeight(proto.Height(1)).Return(g, nil) - app, err := NewApp("api-key", nil, services.Services{State: s}) + app, err := NewApp("api-key", nil, services.Services{State: s}, AppConfig{}) require.NoError(t, err) first, err := app.BlocksFirst() require.NoError(t, err) @@ -40,7 +40,7 @@ func TestApp_BlocksLast(t *testing.T) { s.EXPECT().Height().Return(proto.Height(1), nil) s.EXPECT().BlockByHeight(proto.Height(1)).Return(g, nil) - app, err := NewApp("api-key", nil, services.Services{State: s}) + app, err := NewApp("api-key", nil, services.Services{State: s}, AppConfig{}) require.NoError(t, err) first, err := app.BlocksLast() require.NoError(t, err) diff --git a/pkg/api/app_peers_test.go b/pkg/api/app_peers_test.go index 3a883be022..00ea8e417c 100644 --- a/pkg/api/app_peers_test.go +++ b/pkg/api/app_peers_test.go @@ -22,7 +22,7 @@ func TestApp_PeersKnown(t *testing.T) { addr := proto.NewTCPAddr(net.ParseIP("127.0.0.1"), 6868).ToIpPort() peerManager.EXPECT().KnownPeers().Return([]storage.KnownPeer{storage.KnownPeer(addr)}) - app, err := NewApp("key", nil, services.Services{Peers: peerManager}) + app, err := NewApp("key", nil, services.Services{Peers: peerManager}, AppConfig{}) require.NoError(t, err) rs2, err := app.PeersKnown() @@ -56,7 +56,7 @@ func TestApp_PeersSuspended(t *testing.T) { peerManager.EXPECT().Suspended().Return(testData) - app, err := NewApp("key", nil, services.Services{Peers: peerManager}) + app, err := NewApp("key", nil, services.Services{Peers: peerManager}, AppConfig{}) require.NoError(t, err) suspended := app.PeersSuspended() diff --git a/pkg/api/app_test.go b/pkg/api/app_test.go index fdec4901b8..32198f5fa7 100644 --- a/pkg/api/app_test.go +++ b/pkg/api/app_test.go @@ -8,7 +8,7 @@ import ( ) func TestAppAuth(t *testing.T) { - app, _ := NewApp("apiKey", nil, services.Services{}) + app, _ := NewApp("apiKey", nil, services.Services{}, AppConfig{}) require.Error(t, app.checkAuth("bla")) require.NoError(t, app.checkAuth("apiKey")) } diff --git a/pkg/api/errors/validation.go b/pkg/api/errors/validation.go index dd3a59b6f4..ba6e993eff 100644 --- a/pkg/api/errors/validation.go +++ b/pkg/api/errors/validation.go @@ -2,6 +2,7 @@ package errors import ( "encoding/json" + "fmt" "github.com/pkg/errors" "net/http" ) @@ -152,3 +153,23 @@ var ( }, } ) + +func NewCustomValidationError(msg string) *CustomValidationError { + return &CustomValidationError{ + genericError: genericError{ + ID: CustomValidationErrorErrorID, + HttpCode: http.StatusBadRequest, + Message: msg, + }, + } +} + +func NewAliasDoesNotExistError(aliasFull string) *AliasDoesNotExistError { + return &AliasDoesNotExistError{ + genericError: genericError{ + ID: AliasDoesNotExistErrorID, + HttpCode: http.StatusNotFound, + Message: fmt.Sprintf("alias '%s' doesn't exist", aliasFull), + }, + } +} diff --git a/pkg/api/helpers.go b/pkg/api/helpers.go index 4d7a52d641..f76576fabc 100644 --- a/pkg/api/helpers.go +++ b/pkg/api/helpers.go @@ -1,7 +1,36 @@ package api -import "time" +import ( + "encoding/json" + "github.com/pkg/errors" + "io" + "time" +) func unixMillis(t time.Time) int64 { return t.UnixNano() / 1_000_000 } + +func fromUnixMillis(timestampMillis int64) time.Time { + sec := timestampMillis / 1_000 + nsec := (timestampMillis % 1_000) * 1_000_000 + return time.Unix(sec, nsec) +} + +// tryParseJson receives reader and out params. out MUST be a pointer +func tryParseJson(r io.Reader, out interface{}) error { + // TODO(nickeskov): check empty reader + err := json.NewDecoder(r).Decode(out) + if err != nil { + return errors.Wrapf(err, "Failed to unmarshal %T as JSON into %T", r, out) + } + return nil +} + +func trySendJson(w io.Writer, v interface{}) error { + err := json.NewEncoder(w).Encode(v) + if err != nil { + return errors.Wrapf(err, "Failed to marshal %T to JSON and write it to %T", v, w) + } + return nil +} diff --git a/pkg/api/helpers_test.go b/pkg/api/helpers_test.go new file mode 100644 index 0000000000..dc307d6066 --- /dev/null +++ b/pkg/api/helpers_test.go @@ -0,0 +1,26 @@ +package api + +import ( + "github.com/stretchr/testify/require" + "testing" + "time" +) + +func TestUnixMillis(t *testing.T) { + expected := time.Now() + ts := unixMillis(expected) + + require.Equal(t, expected.UnixNano()/1_000_000, ts) +} + +func TestFromUnixMillis(t *testing.T) { + now := time.Now() + + expected := now.Truncate(time.Millisecond) + millis := expected.UnixNano() / 1_000_000 + + actual := fromUnixMillis(millis) + + require.True(t, expected.Equal(actual)) + require.Equal(t, expected.String(), actual.String()) +} diff --git a/pkg/api/node_api.go b/pkg/api/node_api.go index d08b72b9f4..e5fd006041 100644 --- a/pkg/api/node_api.go +++ b/pkg/api/node_api.go @@ -4,10 +4,11 @@ import ( "context" "encoding/json" "fmt" - "io" "io/ioutil" "net/http" + "os" "strconv" + "time" "github.com/pkg/errors" @@ -433,6 +434,85 @@ func (a *NodeApi) Addresses(w http.ResponseWriter, _ *http.Request) error { return nil } +func (a *NodeApi) NodeStatus(w http.ResponseWriter, r *http.Request) error { + type resp struct { + BlockchainHeight uint64 `json:"blockchainHeight"` + StateHeight uint64 `json:"stateHeight"` + UpdatedTimestamp int64 `json:"updatedTimestamp"` + UpdatedDate string `json:"updatedDate"` + } + + stateHeight, err := a.app.state.Height() + if err != nil { + return errors.Wrap(err, "failed to get state height in NodeStatus HTTP endpoint") + } + + // TODO(nickeskov): create new method in state (like TopBlock, but for TopBlockHeader) + blockHeader, err := a.state.HeaderByHeight(stateHeight) + if err != nil { + return errors.Wrapf(err, "failed to get block header from state by height %d", stateHeight) + } + updatedTimestampMillis := int64(blockHeader.Timestamp) + + out := resp{ + BlockchainHeight: stateHeight, + StateHeight: stateHeight, + UpdatedTimestamp: updatedTimestampMillis, + UpdatedDate: fromUnixMillis(updatedTimestampMillis).Format(time.RFC3339Nano), + } + if err := trySendJson(w, out); err != nil { + return errors.Wrap(err, "NodeStatus") + } + return nil +} + +func (a *NodeApi) BuildVersion(w http.ResponseWriter, _ *http.Request) error { + type ver struct { + Version string `json:"version"` + } + + buildVersion := a.app.Config().BuildVersion + + out := ver{Version: fmt.Sprintf("GoWaves %s", buildVersion)} + if err := trySendJson(w, out); err != nil { + return errors.Wrap(err, "BuildVersion") + } + return nil +} + +func (a *NodeApi) AddrByAlias(w http.ResponseWriter, r *http.Request) error { + type addrResponse struct { + Address string `json:"address"` + } + + // nickeskov: alias as plain text without an 'alias' prefix and chain ID (scheme) + aliasShort := chi.URLParam(r, "alias") + + chainID := proto.SchemeFromString(a.app.Config().BlockchainType) + + alias := proto.NewAlias(chainID, aliasShort) + if _, err := alias.Valid(); err != nil { + // TODO(nickeskov): check that error msg looks like in scala + msg := err.Error() + return apiErrs.NewCustomValidationError(msg) + } + + addr, err := a.app.AddrByAlias(*alias) + if err != nil { + origErr := errors.Cause(err) + if state.IsNotFound(origErr) { + return apiErrs.NewAliasDoesNotExistError(alias.String()) + } + return errors.Wrapf(err, "failed to find addr by short alias %q", aliasShort) + } + + resp := addrResponse{Address: addr.String()} + if err := trySendJson(w, resp); err != nil { + return errors.Wrap(err, "AddrByAlias") + } + return nil +} + func (a *NodeApi) nodeProcesses(w http.ResponseWriter, _ *http.Request) error { rs := a.app.NodeProcesses() if err := trySendJson(w, rs); err != nil { @@ -459,20 +539,44 @@ func (a *NodeApi) stateHash(w http.ResponseWriter, r *http.Request) error { return nil } -// tryParseJson receives reader and out params. out MUST be a pointer -func tryParseJson(r io.Reader, out interface{}) error { - // TODO(nickeskov): check empty reader - err := json.NewDecoder(r).Decode(out) +func (a *NodeApi) sendSelfInterrupt(w http.ResponseWriter, _ *http.Request) error { + type resp struct { + Stopped bool `json:"stopped"` + } + + selfPid := os.Getpid() + p, err := os.FindProcess(selfPid) if err != nil { - return errors.Wrapf(err, "Failed to unmarshal %T as JSON into %T", r, out) + return errors.Wrapf(err, "failed to find process (self) with pid %d", selfPid) + } + interrupt := os.Interrupt + if err := p.Signal(interrupt); err != nil { + return errors.Wrapf(err, + "failed to send signal %q to self process with pid %d", interrupt, selfPid) + } + if err := trySendJson(w, resp{Stopped: true}); err != nil { + return errors.Wrap(err, "sendSelfInterrupt") } + zap.S().Infof("Sent by node HTTP API to self process %q signal", interrupt) return nil } -func trySendJson(w io.Writer, v interface{}) error { - err := json.NewEncoder(w).Encode(v) - if err != nil { - return errors.Wrapf(err, "Failed to marshal %T to JSON and write it to %T", v, w) +func (a *NodeApi) walletSeed(w http.ResponseWriter, _ *http.Request) error { + type seed struct { + Seed string `json:"seed"` + } + + // TODO(nickeskov): This works not like in scala node. + // Scala node don't have multiple wallets, it have only one wallet. + + seeds58 := a.app.WalletSeeds() + seeds := make([]seed, 0, len(seeds58)) + for _, seed58 := range seeds58 { + seeds = append(seeds, seed{Seed: seed58}) + } + + if err := trySendJson(w, seeds); err != nil { + return errors.Wrap(err, "walletSeed") } return nil } diff --git a/pkg/api/node_api_test.go b/pkg/api/node_api_test.go index 36e0d47b5d..b01a5f3f3a 100644 --- a/pkg/api/node_api_test.go +++ b/pkg/api/node_api_test.go @@ -1,6 +1,12 @@ package api import ( + "context" + "github.com/go-chi/chi" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/require" + "github.com/wavesplatform/gowaves/pkg/mock" + "net/http" "net/http/httptest" "strings" "testing" @@ -79,3 +85,32 @@ func TestNodeApi_FindFirstInvalidRuneInBase58String(t *testing.T) { actual := findFirstInvalidRuneInBase58String("42354") assert.Nil(t, actual) } + +func TestNodeApi_AddrByAlias(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + testAlias := "some_alias" + + req := httptest.NewRequest(http.MethodGet, "/", nil) + resp := httptest.NewRecorder() + + stateMock := mock.NewMockState(ctrl) + stateMock.EXPECT(). + AddrByAlias(*proto.NewAlias(proto.TestNetScheme, testAlias)). + Return(proto.Address{}, nil) + + api := NodeApi{ + app: &App{ + state: stateMock, + config: AppConfig{BlockchainType: "testnet"}, + }, + } + + rctx := chi.NewRouteContext() + rctx.URLParams.Add("alias", testAlias) + req = req.WithContext(context.WithValue(req.Context(), chi.RouteCtxKey, rctx)) + + err := api.AddrByAlias(resp, req) + require.NoError(t, err) +} diff --git a/pkg/api/routes.go b/pkg/api/routes.go index c8e425f377..03391ff0f8 100644 --- a/pkg/api/routes.go +++ b/pkg/api/routes.go @@ -105,6 +105,10 @@ func (a *NodeApi) routes(opts *RunOptions) (chi.Router, error) { r.Get("/", wrapper(a.Addresses)) }) + r.Route("/alias", func(r chi.Router) { + r.Get("/by-alias/{alias}", wrapper(a.AddrByAlias)) + }) + r.Route("/transactions", func(r chi.Router) { r.Get("/unconfirmed/size", wrapper(a.unconfirmedSize)) @@ -127,6 +131,21 @@ func (a *NodeApi) routes(opts *RunOptions) (chi.Router, error) { r.Get("/stateHash/{height:\\d+}", wrapper(a.stateHash)) }) + r.Route("/node", func(r chi.Router) { + r.Get("/status", wrapper(a.NodeStatus)) + r.Get("/version", wrapper(a.BuildVersion)) + + rAuth := r.With(checkAuthMiddleware) + + rAuth.Post("/stop", wrapper(a.sendSelfInterrupt)) + }) + + r.Route("/wallet", func(r chi.Router) { + rAuth := r.With(checkAuthMiddleware) + + rAuth.Get("/seed", wrapper(a.walletSeed)) + }) + // enable or disable history sync //r.Get("/debug/sync/{enabled:\\d+}", a.DebugSyncEnabled) }) diff --git a/pkg/mock/peer_manager.go b/pkg/mock/peer_manager.go index a2ba7dcb06..9843641a4f 100644 --- a/pkg/mock/peer_manager.go +++ b/pkg/mock/peer_manager.go @@ -6,232 +6,227 @@ package mock import ( context "context" - big "math/big" - net "net" - reflect "reflect" - time "time" - gomock "github.com/golang/mock/gomock" storage "github.com/wavesplatform/gowaves/pkg/node/peer_manager/storage" peer "github.com/wavesplatform/gowaves/pkg/p2p/peer" proto "github.com/wavesplatform/gowaves/pkg/proto" + net "net" + reflect "reflect" + time "time" ) -// MockPeerManager is a mock of PeerManager interface. +// MockPeerManager is a mock of PeerManager interface type MockPeerManager struct { ctrl *gomock.Controller recorder *MockPeerManagerMockRecorder } -// MockPeerManagerMockRecorder is the mock recorder for MockPeerManager. +// MockPeerManagerMockRecorder is the mock recorder for MockPeerManager type MockPeerManagerMockRecorder struct { mock *MockPeerManager } -// NewMockPeerManager creates a new mock instance. +// NewMockPeerManager creates a new mock instance func NewMockPeerManager(ctrl *gomock.Controller) *MockPeerManager { mock := &MockPeerManager{ctrl: ctrl} mock.recorder = &MockPeerManagerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockPeerManager) EXPECT() *MockPeerManagerMockRecorder { return m.recorder } -// AddConnected mocks base method. -func (m *MockPeerManager) AddConnected(arg0 peer.Peer) { +// Connected mocks base method +func (m *MockPeerManager) Connected(arg0 peer.Peer) (peer.Peer, bool) { m.ctrl.T.Helper() - m.ctrl.Call(m, "AddConnected", arg0) + ret := m.ctrl.Call(m, "Connected", arg0) + ret0, _ := ret[0].(peer.Peer) + ret1, _ := ret[1].(bool) + return ret0, ret1 } -// AddConnected indicates an expected call of AddConnected. -func (mr *MockPeerManagerMockRecorder) AddConnected(arg0 interface{}) *gomock.Call { +// Connected indicates an expected call of Connected +func (mr *MockPeerManagerMockRecorder) Connected(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConnected", reflect.TypeOf((*MockPeerManager)(nil).AddConnected), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockPeerManager)(nil).Connected), arg0) } -// AskPeers mocks base method. -func (m *MockPeerManager) AskPeers() { +// NewConnection mocks base method +func (m *MockPeerManager) NewConnection(arg0 peer.Peer) error { m.ctrl.T.Helper() - m.ctrl.Call(m, "AskPeers") + ret := m.ctrl.Call(m, "NewConnection", arg0) + ret0, _ := ret[0].(error) + return ret0 } -// AskPeers indicates an expected call of AskPeers. -func (mr *MockPeerManagerMockRecorder) AskPeers() *gomock.Call { +// NewConnection indicates an expected call of NewConnection +func (mr *MockPeerManagerMockRecorder) NewConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskPeers", reflect.TypeOf((*MockPeerManager)(nil).AskPeers)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnection", reflect.TypeOf((*MockPeerManager)(nil).NewConnection), arg0) } -// Close mocks base method. -func (m *MockPeerManager) Close() { +// ConnectedCount mocks base method +func (m *MockPeerManager) ConnectedCount() int { m.ctrl.T.Helper() - m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "ConnectedCount") + ret0, _ := ret[0].(int) + return ret0 } -// Close indicates an expected call of Close. -func (mr *MockPeerManagerMockRecorder) Close() *gomock.Call { +// ConnectedCount indicates an expected call of ConnectedCount +func (mr *MockPeerManagerMockRecorder) ConnectedCount() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPeerManager)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectedCount", reflect.TypeOf((*MockPeerManager)(nil).ConnectedCount)) } -// Connect mocks base method. -func (m *MockPeerManager) Connect(arg0 context.Context, arg1 proto.TCPAddr) error { +// InOutCount mocks base method +func (m *MockPeerManager) InOutCount() (int, int) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Connect", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "InOutCount") + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(int) + return ret0, ret1 } -// Connect indicates an expected call of Connect. -func (mr *MockPeerManagerMockRecorder) Connect(arg0, arg1 interface{}) *gomock.Call { +// InOutCount indicates an expected call of InOutCount +func (mr *MockPeerManagerMockRecorder) InOutCount() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockPeerManager)(nil).Connect), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InOutCount", reflect.TypeOf((*MockPeerManager)(nil).InOutCount)) } -// Connected mocks base method. -func (m *MockPeerManager) Connected(arg0 peer.Peer) (peer.Peer, bool) { +// EachConnected mocks base method +func (m *MockPeerManager) EachConnected(arg0 func(peer.Peer, *proto.Score)) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Connected", arg0) - ret0, _ := ret[0].(peer.Peer) - ret1, _ := ret[1].(bool) - return ret0, ret1 + m.ctrl.Call(m, "EachConnected", arg0) } -// Connected indicates an expected call of Connected. -func (mr *MockPeerManagerMockRecorder) Connected(arg0 interface{}) *gomock.Call { +// EachConnected indicates an expected call of EachConnected +func (mr *MockPeerManagerMockRecorder) EachConnected(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connected", reflect.TypeOf((*MockPeerManager)(nil).Connected), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EachConnected", reflect.TypeOf((*MockPeerManager)(nil).EachConnected), arg0) } -// ConnectedCount mocks base method. -func (m *MockPeerManager) ConnectedCount() int { +// IsSuspended mocks base method +func (m *MockPeerManager) IsSuspended(arg0 peer.Peer) bool { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConnectedCount") - ret0, _ := ret[0].(int) + ret := m.ctrl.Call(m, "IsSuspended", arg0) + ret0, _ := ret[0].(bool) return ret0 } -// ConnectedCount indicates an expected call of ConnectedCount. -func (mr *MockPeerManagerMockRecorder) ConnectedCount() *gomock.Call { +// IsSuspended indicates an expected call of IsSuspended +func (mr *MockPeerManagerMockRecorder) IsSuspended(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectedCount", reflect.TypeOf((*MockPeerManager)(nil).ConnectedCount)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSuspended", reflect.TypeOf((*MockPeerManager)(nil).IsSuspended), arg0) } -// Disconnect mocks base method. -func (m *MockPeerManager) Disconnect(arg0 peer.Peer) { +// Suspend mocks base method +func (m *MockPeerManager) Suspend(peer peer.Peer, suspendTime time.Time, reason string) { m.ctrl.T.Helper() - m.ctrl.Call(m, "Disconnect", arg0) + m.ctrl.Call(m, "Suspend", peer, suspendTime, reason) } -// Disconnect indicates an expected call of Disconnect. -func (mr *MockPeerManagerMockRecorder) Disconnect(arg0 interface{}) *gomock.Call { +// Suspend indicates an expected call of Suspend +func (mr *MockPeerManagerMockRecorder) Suspend(peer, suspendTime, reason interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disconnect", reflect.TypeOf((*MockPeerManager)(nil).Disconnect), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suspend", reflect.TypeOf((*MockPeerManager)(nil).Suspend), peer, suspendTime, reason) } -// EachConnected mocks base method. -func (m *MockPeerManager) EachConnected(arg0 func(peer.Peer, *proto.Score)) { +// Suspended mocks base method +func (m *MockPeerManager) Suspended() []storage.SuspendedPeer { m.ctrl.T.Helper() - m.ctrl.Call(m, "EachConnected", arg0) + ret := m.ctrl.Call(m, "Suspended") + ret0, _ := ret[0].([]storage.SuspendedPeer) + return ret0 } -// EachConnected indicates an expected call of EachConnected. -func (mr *MockPeerManagerMockRecorder) EachConnected(arg0 interface{}) *gomock.Call { +// Suspended indicates an expected call of Suspended +func (mr *MockPeerManagerMockRecorder) Suspended() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EachConnected", reflect.TypeOf((*MockPeerManager)(nil).EachConnected), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suspended", reflect.TypeOf((*MockPeerManager)(nil).Suspended)) } -// InOutCount mocks base method. -func (m *MockPeerManager) InOutCount() (int, int) { +// AddConnected mocks base method +func (m *MockPeerManager) AddConnected(arg0 peer.Peer) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "InOutCount") - ret0, _ := ret[0].(int) - ret1, _ := ret[1].(int) - return ret0, ret1 + m.ctrl.Call(m, "AddConnected", arg0) } -// InOutCount indicates an expected call of InOutCount. -func (mr *MockPeerManagerMockRecorder) InOutCount() *gomock.Call { +// AddConnected indicates an expected call of AddConnected +func (mr *MockPeerManagerMockRecorder) AddConnected(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InOutCount", reflect.TypeOf((*MockPeerManager)(nil).InOutCount)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConnected", reflect.TypeOf((*MockPeerManager)(nil).AddConnected), arg0) } -// IsSuspended mocks base method. -func (m *MockPeerManager) IsSuspended(arg0 peer.Peer) bool { +// UpdateScore mocks base method +func (m *MockPeerManager) UpdateScore(p peer.Peer, score *proto.Score) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsSuspended", arg0) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "UpdateScore", p, score) + ret0, _ := ret[0].(error) return ret0 } -// IsSuspended indicates an expected call of IsSuspended. -func (mr *MockPeerManagerMockRecorder) IsSuspended(arg0 interface{}) *gomock.Call { +// UpdateScore indicates an expected call of UpdateScore +func (mr *MockPeerManagerMockRecorder) UpdateScore(p, score interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSuspended", reflect.TypeOf((*MockPeerManager)(nil).IsSuspended), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScore", reflect.TypeOf((*MockPeerManager)(nil).UpdateScore), p, score) } -// KnownPeers mocks base method. -func (m *MockPeerManager) KnownPeers() []storage.KnownPeer { +// UpdateKnownPeers mocks base method +func (m *MockPeerManager) UpdateKnownPeers(arg0 []storage.KnownPeer) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "KnownPeers") - ret0, _ := ret[0].([]storage.KnownPeer) + ret := m.ctrl.Call(m, "UpdateKnownPeers", arg0) + ret0, _ := ret[0].(error) return ret0 } -// KnownPeers indicates an expected call of KnownPeers. -func (mr *MockPeerManagerMockRecorder) KnownPeers() *gomock.Call { +// UpdateKnownPeers indicates an expected call of UpdateKnownPeers +func (mr *MockPeerManagerMockRecorder) UpdateKnownPeers(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KnownPeers", reflect.TypeOf((*MockPeerManager)(nil).KnownPeers)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKnownPeers", reflect.TypeOf((*MockPeerManager)(nil).UpdateKnownPeers), arg0) } -// NewConnection mocks base method. -func (m *MockPeerManager) NewConnection(arg0 peer.Peer) error { +// KnownPeers mocks base method +func (m *MockPeerManager) KnownPeers() []storage.KnownPeer { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewConnection", arg0) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "KnownPeers") + ret0, _ := ret[0].([]storage.KnownPeer) return ret0 } -// NewConnection indicates an expected call of NewConnection. -func (mr *MockPeerManagerMockRecorder) NewConnection(arg0 interface{}) *gomock.Call { +// KnownPeers indicates an expected call of KnownPeers +func (mr *MockPeerManagerMockRecorder) KnownPeers() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConnection", reflect.TypeOf((*MockPeerManager)(nil).NewConnection), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KnownPeers", reflect.TypeOf((*MockPeerManager)(nil).KnownPeers)) } -// PeerWithHighestScore mocks base method. -func (m *MockPeerManager) PeerWithHighestScore() (peer.Peer, *big.Int, bool) { +// Close mocks base method +func (m *MockPeerManager) Close() { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PeerWithHighestScore") - ret0, _ := ret[0].(peer.Peer) - ret1, _ := ret[1].(*big.Int) - ret2, _ := ret[2].(bool) - return ret0, ret1, ret2 + m.ctrl.Call(m, "Close") } -// PeerWithHighestScore indicates an expected call of PeerWithHighestScore. -func (mr *MockPeerManagerMockRecorder) PeerWithHighestScore() *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockPeerManagerMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerWithHighestScore", reflect.TypeOf((*MockPeerManager)(nil).PeerWithHighestScore)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPeerManager)(nil).Close)) } -// Score mocks base method. -func (m *MockPeerManager) Score(p peer.Peer) (*proto.Score, error) { +// SpawnOutgoingConnections mocks base method +func (m *MockPeerManager) SpawnOutgoingConnections(arg0 context.Context) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Score", p) - ret0, _ := ret[0].(*proto.Score) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.Call(m, "SpawnOutgoingConnections", arg0) } -// Score indicates an expected call of Score. -func (mr *MockPeerManagerMockRecorder) Score(p interface{}) *gomock.Call { +// SpawnOutgoingConnections indicates an expected call of SpawnOutgoingConnections +func (mr *MockPeerManagerMockRecorder) SpawnOutgoingConnections(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Score", reflect.TypeOf((*MockPeerManager)(nil).Score), p) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpawnOutgoingConnections", reflect.TypeOf((*MockPeerManager)(nil).SpawnOutgoingConnections), arg0) } -// SpawnIncomingConnection mocks base method. +// SpawnIncomingConnection mocks base method func (m *MockPeerManager) SpawnIncomingConnection(ctx context.Context, conn net.Conn) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SpawnIncomingConnection", ctx, conn) @@ -239,25 +234,13 @@ func (m *MockPeerManager) SpawnIncomingConnection(ctx context.Context, conn net. return ret0 } -// SpawnIncomingConnection indicates an expected call of SpawnIncomingConnection. +// SpawnIncomingConnection indicates an expected call of SpawnIncomingConnection func (mr *MockPeerManagerMockRecorder) SpawnIncomingConnection(ctx, conn interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpawnIncomingConnection", reflect.TypeOf((*MockPeerManager)(nil).SpawnIncomingConnection), ctx, conn) } -// SpawnOutgoingConnections mocks base method. -func (m *MockPeerManager) SpawnOutgoingConnections(arg0 context.Context) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "SpawnOutgoingConnections", arg0) -} - -// SpawnOutgoingConnections indicates an expected call of SpawnOutgoingConnections. -func (mr *MockPeerManagerMockRecorder) SpawnOutgoingConnections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpawnOutgoingConnections", reflect.TypeOf((*MockPeerManager)(nil).SpawnOutgoingConnections), arg0) -} - -// Spawned mocks base method. +// Spawned mocks base method func (m *MockPeerManager) Spawned() []proto.IpPort { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Spawned") @@ -265,62 +248,61 @@ func (m *MockPeerManager) Spawned() []proto.IpPort { return ret0 } -// Spawned indicates an expected call of Spawned. +// Spawned indicates an expected call of Spawned func (mr *MockPeerManagerMockRecorder) Spawned() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Spawned", reflect.TypeOf((*MockPeerManager)(nil).Spawned)) } -// Suspend mocks base method. -func (m *MockPeerManager) Suspend(peer peer.Peer, suspendTime time.Time, reason string) { +// Connect mocks base method +func (m *MockPeerManager) Connect(arg0 context.Context, arg1 proto.TCPAddr) error { m.ctrl.T.Helper() - m.ctrl.Call(m, "Suspend", peer, suspendTime, reason) + ret := m.ctrl.Call(m, "Connect", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 } -// Suspend indicates an expected call of Suspend. -func (mr *MockPeerManagerMockRecorder) Suspend(peer, suspendTime, reason interface{}) *gomock.Call { +// Connect indicates an expected call of Connect +func (mr *MockPeerManagerMockRecorder) Connect(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suspend", reflect.TypeOf((*MockPeerManager)(nil).Suspend), peer, suspendTime, reason) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockPeerManager)(nil).Connect), arg0, arg1) } -// Suspended mocks base method. -func (m *MockPeerManager) Suspended() []storage.SuspendedPeer { +// Score mocks base method +func (m *MockPeerManager) Score(p peer.Peer) (*proto.Score, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Suspended") - ret0, _ := ret[0].([]storage.SuspendedPeer) - return ret0 + ret := m.ctrl.Call(m, "Score", p) + ret0, _ := ret[0].(*proto.Score) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// Suspended indicates an expected call of Suspended. -func (mr *MockPeerManagerMockRecorder) Suspended() *gomock.Call { +// Score indicates an expected call of Score +func (mr *MockPeerManagerMockRecorder) Score(p interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suspended", reflect.TypeOf((*MockPeerManager)(nil).Suspended)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Score", reflect.TypeOf((*MockPeerManager)(nil).Score), p) } -// UpdateKnownPeers mocks base method. -func (m *MockPeerManager) UpdateKnownPeers(arg0 []storage.KnownPeer) error { +// AskPeers mocks base method +func (m *MockPeerManager) AskPeers() { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateKnownPeers", arg0) - ret0, _ := ret[0].(error) - return ret0 + m.ctrl.Call(m, "AskPeers") } -// UpdateKnownPeers indicates an expected call of UpdateKnownPeers. -func (mr *MockPeerManagerMockRecorder) UpdateKnownPeers(arg0 interface{}) *gomock.Call { +// AskPeers indicates an expected call of AskPeers +func (mr *MockPeerManagerMockRecorder) AskPeers() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKnownPeers", reflect.TypeOf((*MockPeerManager)(nil).UpdateKnownPeers), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskPeers", reflect.TypeOf((*MockPeerManager)(nil).AskPeers)) } -// UpdateScore mocks base method. -func (m *MockPeerManager) UpdateScore(p peer.Peer, score *proto.Score) error { +// Disconnect mocks base method +func (m *MockPeerManager) Disconnect(arg0 peer.Peer) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateScore", p, score) - ret0, _ := ret[0].(error) - return ret0 + m.ctrl.Call(m, "Disconnect", arg0) } -// UpdateScore indicates an expected call of UpdateScore. -func (mr *MockPeerManagerMockRecorder) UpdateScore(p, score interface{}) *gomock.Call { +// Disconnect indicates an expected call of Disconnect +func (mr *MockPeerManagerMockRecorder) Disconnect(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScore", reflect.TypeOf((*MockPeerManager)(nil).UpdateScore), p, score) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disconnect", reflect.TypeOf((*MockPeerManager)(nil).Disconnect), arg0) } diff --git a/pkg/mock/state.go b/pkg/mock/state.go index 3c367d9369..910bfcf889 100644 --- a/pkg/mock/state.go +++ b/pkg/mock/state.go @@ -5,54 +5,55 @@ package mock import ( - big "math/big" - reflect "reflect" - gomock "github.com/golang/mock/gomock" crypto "github.com/wavesplatform/gowaves/pkg/crypto" proto "github.com/wavesplatform/gowaves/pkg/proto" settings "github.com/wavesplatform/gowaves/pkg/settings" state "github.com/wavesplatform/gowaves/pkg/state" + big "math/big" + reflect "reflect" ) -// MockTransactionIterator is a mock of TransactionIterator interface. +// MockTransactionIterator is a mock of TransactionIterator interface type MockTransactionIterator struct { ctrl *gomock.Controller recorder *MockTransactionIteratorMockRecorder } -// MockTransactionIteratorMockRecorder is the mock recorder for MockTransactionIterator. +// MockTransactionIteratorMockRecorder is the mock recorder for MockTransactionIterator type MockTransactionIteratorMockRecorder struct { mock *MockTransactionIterator } -// NewMockTransactionIterator creates a new mock instance. +// NewMockTransactionIterator creates a new mock instance func NewMockTransactionIterator(ctrl *gomock.Controller) *MockTransactionIterator { mock := &MockTransactionIterator{ctrl: ctrl} mock.recorder = &MockTransactionIteratorMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockTransactionIterator) EXPECT() *MockTransactionIteratorMockRecorder { return m.recorder } -// Error mocks base method. -func (m *MockTransactionIterator) Error() error { +// Transaction mocks base method +func (m *MockTransactionIterator) Transaction() (proto.Transaction, bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Error") - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "Transaction") + ret0, _ := ret[0].(proto.Transaction) + ret1, _ := ret[1].(bool) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 } -// Error indicates an expected call of Error. -func (mr *MockTransactionIteratorMockRecorder) Error() *gomock.Call { +// Transaction indicates an expected call of Transaction +func (mr *MockTransactionIteratorMockRecorder) Transaction() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockTransactionIterator)(nil).Error)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transaction", reflect.TypeOf((*MockTransactionIterator)(nil).Transaction)) } -// Next mocks base method. +// Next mocks base method func (m *MockTransactionIterator) Next() bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Next") @@ -60,649 +61,662 @@ func (m *MockTransactionIterator) Next() bool { return ret0 } -// Next indicates an expected call of Next. +// Next indicates an expected call of Next func (mr *MockTransactionIteratorMockRecorder) Next() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockTransactionIterator)(nil).Next)) } -// Release mocks base method. +// Release mocks base method func (m *MockTransactionIterator) Release() { m.ctrl.T.Helper() m.ctrl.Call(m, "Release") } -// Release indicates an expected call of Release. +// Release indicates an expected call of Release func (mr *MockTransactionIteratorMockRecorder) Release() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Release", reflect.TypeOf((*MockTransactionIterator)(nil).Release)) } -// Transaction mocks base method. -func (m *MockTransactionIterator) Transaction() (proto.Transaction, bool, error) { +// Error mocks base method +func (m *MockTransactionIterator) Error() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Transaction") - ret0, _ := ret[0].(proto.Transaction) - ret1, _ := ret[1].(bool) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret := m.ctrl.Call(m, "Error") + ret0, _ := ret[0].(error) + return ret0 } -// Transaction indicates an expected call of Transaction. -func (mr *MockTransactionIteratorMockRecorder) Transaction() *gomock.Call { +// Error indicates an expected call of Error +func (mr *MockTransactionIteratorMockRecorder) Error() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transaction", reflect.TypeOf((*MockTransactionIterator)(nil).Transaction)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockTransactionIterator)(nil).Error)) } -// MockStateInfo is a mock of StateInfo interface. +// MockStateInfo is a mock of StateInfo interface type MockStateInfo struct { ctrl *gomock.Controller recorder *MockStateInfoMockRecorder } -// MockStateInfoMockRecorder is the mock recorder for MockStateInfo. +// MockStateInfoMockRecorder is the mock recorder for MockStateInfo type MockStateInfoMockRecorder struct { mock *MockStateInfo } -// NewMockStateInfo creates a new mock instance. +// NewMockStateInfo creates a new mock instance func NewMockStateInfo(ctrl *gomock.Controller) *MockStateInfo { mock := &MockStateInfo{ctrl: ctrl} mock.recorder = &MockStateInfoMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockStateInfo) EXPECT() *MockStateInfoMockRecorder { return m.recorder } -// AccountBalance mocks base method. -func (m *MockStateInfo) AccountBalance(account proto.Recipient, asset []byte) (uint64, error) { +// TopBlock mocks base method +func (m *MockStateInfo) TopBlock() *proto.Block { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AccountBalance", account, asset) - ret0, _ := ret[0].(uint64) + ret := m.ctrl.Call(m, "TopBlock") + ret0, _ := ret[0].(*proto.Block) + return ret0 +} + +// TopBlock indicates an expected call of TopBlock +func (mr *MockStateInfoMockRecorder) TopBlock() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopBlock", reflect.TypeOf((*MockStateInfo)(nil).TopBlock)) +} + +// Block mocks base method +func (m *MockStateInfo) Block(blockID proto.BlockID) (*proto.Block, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Block", blockID) + ret0, _ := ret[0].(*proto.Block) ret1, _ := ret[1].(error) return ret0, ret1 } -// AccountBalance indicates an expected call of AccountBalance. -func (mr *MockStateInfoMockRecorder) AccountBalance(account, asset interface{}) *gomock.Call { +// Block indicates an expected call of Block +func (mr *MockStateInfoMockRecorder) Block(blockID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountBalance", reflect.TypeOf((*MockStateInfo)(nil).AccountBalance), account, asset) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Block", reflect.TypeOf((*MockStateInfo)(nil).Block), blockID) } -// ActivationHeight mocks base method. -func (m *MockStateInfo) ActivationHeight(featureID int16) (proto.Height, error) { +// BlockByHeight mocks base method +func (m *MockStateInfo) BlockByHeight(height proto.Height) (*proto.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ActivationHeight", featureID) - ret0, _ := ret[0].(proto.Height) + ret := m.ctrl.Call(m, "BlockByHeight", height) + ret0, _ := ret[0].(*proto.Block) ret1, _ := ret[1].(error) return ret0, ret1 } -// ActivationHeight indicates an expected call of ActivationHeight. -func (mr *MockStateInfoMockRecorder) ActivationHeight(featureID interface{}) *gomock.Call { +// BlockByHeight indicates an expected call of BlockByHeight +func (mr *MockStateInfoMockRecorder) BlockByHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivationHeight", reflect.TypeOf((*MockStateInfo)(nil).ActivationHeight), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHeight", reflect.TypeOf((*MockStateInfo)(nil).BlockByHeight), height) } -// AddrByAlias mocks base method. -func (m *MockStateInfo) AddrByAlias(alias proto.Alias) (proto.Address, error) { +// Header mocks base method +func (m *MockStateInfo) Header(blockID proto.BlockID) (*proto.BlockHeader, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddrByAlias", alias) - ret0, _ := ret[0].(proto.Address) + ret := m.ctrl.Call(m, "Header", blockID) + ret0, _ := ret[0].(*proto.BlockHeader) ret1, _ := ret[1].(error) return ret0, ret1 } -// AddrByAlias indicates an expected call of AddrByAlias. -func (mr *MockStateInfoMockRecorder) AddrByAlias(alias interface{}) *gomock.Call { +// Header indicates an expected call of Header +func (mr *MockStateInfoMockRecorder) Header(blockID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddrByAlias", reflect.TypeOf((*MockStateInfo)(nil).AddrByAlias), alias) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockStateInfo)(nil).Header), blockID) } -// AllFeatures mocks base method. -func (m *MockStateInfo) AllFeatures() ([]int16, error) { +// HeaderByHeight mocks base method +func (m *MockStateInfo) HeaderByHeight(height proto.Height) (*proto.BlockHeader, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AllFeatures") - ret0, _ := ret[0].([]int16) + ret := m.ctrl.Call(m, "HeaderByHeight", height) + ret0, _ := ret[0].(*proto.BlockHeader) ret1, _ := ret[1].(error) return ret0, ret1 } -// AllFeatures indicates an expected call of AllFeatures. -func (mr *MockStateInfoMockRecorder) AllFeatures() *gomock.Call { +// HeaderByHeight indicates an expected call of HeaderByHeight +func (mr *MockStateInfoMockRecorder) HeaderByHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllFeatures", reflect.TypeOf((*MockStateInfo)(nil).AllFeatures)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHeight", reflect.TypeOf((*MockStateInfo)(nil).HeaderByHeight), height) } -// ApprovalHeight mocks base method. -func (m *MockStateInfo) ApprovalHeight(featureID int16) (proto.Height, error) { +// Height mocks base method +func (m *MockStateInfo) Height() (proto.Height, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ApprovalHeight", featureID) + ret := m.ctrl.Call(m, "Height") ret0, _ := ret[0].(proto.Height) ret1, _ := ret[1].(error) return ret0, ret1 } -// ApprovalHeight indicates an expected call of ApprovalHeight. -func (mr *MockStateInfoMockRecorder) ApprovalHeight(featureID interface{}) *gomock.Call { +// Height indicates an expected call of Height +func (mr *MockStateInfoMockRecorder) Height() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApprovalHeight", reflect.TypeOf((*MockStateInfo)(nil).ApprovalHeight), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockStateInfo)(nil).Height)) } -// AssetInfo mocks base method. -func (m *MockStateInfo) AssetInfo(assetID crypto.Digest) (*proto.AssetInfo, error) { +// BlockIDToHeight mocks base method +func (m *MockStateInfo) BlockIDToHeight(blockID proto.BlockID) (proto.Height, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssetInfo", assetID) - ret0, _ := ret[0].(*proto.AssetInfo) + ret := m.ctrl.Call(m, "BlockIDToHeight", blockID) + ret0, _ := ret[0].(proto.Height) ret1, _ := ret[1].(error) return ret0, ret1 } -// AssetInfo indicates an expected call of AssetInfo. -func (mr *MockStateInfoMockRecorder) AssetInfo(assetID interface{}) *gomock.Call { +// BlockIDToHeight indicates an expected call of BlockIDToHeight +func (mr *MockStateInfoMockRecorder) BlockIDToHeight(blockID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetInfo", reflect.TypeOf((*MockStateInfo)(nil).AssetInfo), assetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockIDToHeight", reflect.TypeOf((*MockStateInfo)(nil).BlockIDToHeight), blockID) } -// AssetIsSponsored mocks base method. -func (m *MockStateInfo) AssetIsSponsored(assetID crypto.Digest) (bool, error) { +// HeightToBlockID mocks base method +func (m *MockStateInfo) HeightToBlockID(height proto.Height) (proto.BlockID, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssetIsSponsored", assetID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "HeightToBlockID", height) + ret0, _ := ret[0].(proto.BlockID) ret1, _ := ret[1].(error) return ret0, ret1 } -// AssetIsSponsored indicates an expected call of AssetIsSponsored. -func (mr *MockStateInfoMockRecorder) AssetIsSponsored(assetID interface{}) *gomock.Call { +// HeightToBlockID indicates an expected call of HeightToBlockID +func (mr *MockStateInfoMockRecorder) HeightToBlockID(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetIsSponsored", reflect.TypeOf((*MockStateInfo)(nil).AssetIsSponsored), assetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeightToBlockID", reflect.TypeOf((*MockStateInfo)(nil).HeightToBlockID), height) } -// Block mocks base method. -func (m *MockStateInfo) Block(blockID proto.BlockID) (*proto.Block, error) { +// FullWavesBalance mocks base method +func (m *MockStateInfo) FullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Block", blockID) - ret0, _ := ret[0].(*proto.Block) + ret := m.ctrl.Call(m, "FullWavesBalance", account) + ret0, _ := ret[0].(*proto.FullWavesBalance) ret1, _ := ret[1].(error) return ret0, ret1 } -// Block indicates an expected call of Block. -func (mr *MockStateInfoMockRecorder) Block(blockID interface{}) *gomock.Call { +// FullWavesBalance indicates an expected call of FullWavesBalance +func (mr *MockStateInfoMockRecorder) FullWavesBalance(account interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Block", reflect.TypeOf((*MockStateInfo)(nil).Block), blockID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullWavesBalance", reflect.TypeOf((*MockStateInfo)(nil).FullWavesBalance), account) } -// BlockByHeight mocks base method. -func (m *MockStateInfo) BlockByHeight(height proto.Height) (*proto.Block, error) { +// EffectiveBalance mocks base method +func (m *MockStateInfo) EffectiveBalance(account proto.Recipient, startHeight, endHeight proto.Height) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BlockByHeight", height) - ret0, _ := ret[0].(*proto.Block) + ret := m.ctrl.Call(m, "EffectiveBalance", account, startHeight, endHeight) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// BlockByHeight indicates an expected call of BlockByHeight. -func (mr *MockStateInfoMockRecorder) BlockByHeight(height interface{}) *gomock.Call { +// EffectiveBalance indicates an expected call of EffectiveBalance +func (mr *MockStateInfoMockRecorder) EffectiveBalance(account, startHeight, endHeight interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHeight", reflect.TypeOf((*MockStateInfo)(nil).BlockByHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EffectiveBalance", reflect.TypeOf((*MockStateInfo)(nil).EffectiveBalance), account, startHeight, endHeight) } -// BlockIDToHeight mocks base method. -func (m *MockStateInfo) BlockIDToHeight(blockID proto.BlockID) (proto.Height, error) { +// AccountBalance mocks base method +func (m *MockStateInfo) AccountBalance(account proto.Recipient, asset []byte) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BlockIDToHeight", blockID) - ret0, _ := ret[0].(proto.Height) + ret := m.ctrl.Call(m, "AccountBalance", account, asset) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// BlockIDToHeight indicates an expected call of BlockIDToHeight. -func (mr *MockStateInfoMockRecorder) BlockIDToHeight(blockID interface{}) *gomock.Call { +// AccountBalance indicates an expected call of AccountBalance +func (mr *MockStateInfoMockRecorder) AccountBalance(account, asset interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockIDToHeight", reflect.TypeOf((*MockStateInfo)(nil).BlockIDToHeight), blockID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountBalance", reflect.TypeOf((*MockStateInfo)(nil).AccountBalance), account, asset) } -// BlockchainSettings mocks base method. -func (m *MockStateInfo) BlockchainSettings() (*settings.BlockchainSettings, error) { +// WavesAddressesNumber mocks base method +func (m *MockStateInfo) WavesAddressesNumber() (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BlockchainSettings") - ret0, _ := ret[0].(*settings.BlockchainSettings) + ret := m.ctrl.Call(m, "WavesAddressesNumber") + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// BlockchainSettings indicates an expected call of BlockchainSettings. -func (mr *MockStateInfoMockRecorder) BlockchainSettings() *gomock.Call { +// WavesAddressesNumber indicates an expected call of WavesAddressesNumber +func (mr *MockStateInfoMockRecorder) WavesAddressesNumber() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockchainSettings", reflect.TypeOf((*MockStateInfo)(nil).BlockchainSettings)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WavesAddressesNumber", reflect.TypeOf((*MockStateInfo)(nil).WavesAddressesNumber)) } -// CurrentScore mocks base method. -func (m *MockStateInfo) CurrentScore() (*big.Int, error) { +// ScoreAtHeight mocks base method +func (m *MockStateInfo) ScoreAtHeight(height proto.Height) (*big.Int, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CurrentScore") + ret := m.ctrl.Call(m, "ScoreAtHeight", height) ret0, _ := ret[0].(*big.Int) ret1, _ := ret[1].(error) return ret0, ret1 } -// CurrentScore indicates an expected call of CurrentScore. -func (mr *MockStateInfoMockRecorder) CurrentScore() *gomock.Call { +// ScoreAtHeight indicates an expected call of ScoreAtHeight +func (mr *MockStateInfoMockRecorder) ScoreAtHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentScore", reflect.TypeOf((*MockStateInfo)(nil).CurrentScore)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScoreAtHeight", reflect.TypeOf((*MockStateInfo)(nil).ScoreAtHeight), height) } -// EffectiveBalance mocks base method. -func (m *MockStateInfo) EffectiveBalance(account proto.Recipient, startHeight, endHeight proto.Height) (uint64, error) { +// CurrentScore mocks base method +func (m *MockStateInfo) CurrentScore() (*big.Int, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EffectiveBalance", account, startHeight, endHeight) - ret0, _ := ret[0].(uint64) + ret := m.ctrl.Call(m, "CurrentScore") + ret0, _ := ret[0].(*big.Int) ret1, _ := ret[1].(error) return ret0, ret1 } -// EffectiveBalance indicates an expected call of EffectiveBalance. -func (mr *MockStateInfoMockRecorder) EffectiveBalance(account, startHeight, endHeight interface{}) *gomock.Call { +// CurrentScore indicates an expected call of CurrentScore +func (mr *MockStateInfoMockRecorder) CurrentScore() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EffectiveBalance", reflect.TypeOf((*MockStateInfo)(nil).EffectiveBalance), account, startHeight, endHeight) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentScore", reflect.TypeOf((*MockStateInfo)(nil).CurrentScore)) } -// EstimatorVersion mocks base method. -func (m *MockStateInfo) EstimatorVersion() (int, error) { +// BlockchainSettings mocks base method +func (m *MockStateInfo) BlockchainSettings() (*settings.BlockchainSettings, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EstimatorVersion") - ret0, _ := ret[0].(int) + ret := m.ctrl.Call(m, "BlockchainSettings") + ret0, _ := ret[0].(*settings.BlockchainSettings) ret1, _ := ret[1].(error) return ret0, ret1 } -// EstimatorVersion indicates an expected call of EstimatorVersion. -func (mr *MockStateInfoMockRecorder) EstimatorVersion() *gomock.Call { +// BlockchainSettings indicates an expected call of BlockchainSettings +func (mr *MockStateInfoMockRecorder) BlockchainSettings() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimatorVersion", reflect.TypeOf((*MockStateInfo)(nil).EstimatorVersion)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockchainSettings", reflect.TypeOf((*MockStateInfo)(nil).BlockchainSettings)) } -// FullAssetInfo mocks base method. -func (m *MockStateInfo) FullAssetInfo(assetID crypto.Digest) (*proto.FullAssetInfo, error) { +// VotesNum mocks base method +func (m *MockStateInfo) VotesNum(featureID int16) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FullAssetInfo", assetID) - ret0, _ := ret[0].(*proto.FullAssetInfo) + ret := m.ctrl.Call(m, "VotesNum", featureID) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// FullAssetInfo indicates an expected call of FullAssetInfo. -func (mr *MockStateInfoMockRecorder) FullAssetInfo(assetID interface{}) *gomock.Call { +// VotesNum indicates an expected call of VotesNum +func (mr *MockStateInfoMockRecorder) VotesNum(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullAssetInfo", reflect.TypeOf((*MockStateInfo)(nil).FullAssetInfo), assetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VotesNum", reflect.TypeOf((*MockStateInfo)(nil).VotesNum), featureID) } -// FullWavesBalance mocks base method. -func (m *MockStateInfo) FullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error) { +// VotesNumAtHeight mocks base method +func (m *MockStateInfo) VotesNumAtHeight(featureID int16, height proto.Height) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FullWavesBalance", account) - ret0, _ := ret[0].(*proto.FullWavesBalance) + ret := m.ctrl.Call(m, "VotesNumAtHeight", featureID, height) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// FullWavesBalance indicates an expected call of FullWavesBalance. -func (mr *MockStateInfoMockRecorder) FullWavesBalance(account interface{}) *gomock.Call { +// VotesNumAtHeight indicates an expected call of VotesNumAtHeight +func (mr *MockStateInfoMockRecorder) VotesNumAtHeight(featureID, height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullWavesBalance", reflect.TypeOf((*MockStateInfo)(nil).FullWavesBalance), account) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VotesNumAtHeight", reflect.TypeOf((*MockStateInfo)(nil).VotesNumAtHeight), featureID, height) } -// Header mocks base method. -func (m *MockStateInfo) Header(blockID proto.BlockID) (*proto.BlockHeader, error) { +// IsActivated mocks base method +func (m *MockStateInfo) IsActivated(featureID int16) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Header", blockID) - ret0, _ := ret[0].(*proto.BlockHeader) + ret := m.ctrl.Call(m, "IsActivated", featureID) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// Header indicates an expected call of Header. -func (mr *MockStateInfoMockRecorder) Header(blockID interface{}) *gomock.Call { +// IsActivated indicates an expected call of IsActivated +func (mr *MockStateInfoMockRecorder) IsActivated(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockStateInfo)(nil).Header), blockID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActivated", reflect.TypeOf((*MockStateInfo)(nil).IsActivated), featureID) } -// HeaderByHeight mocks base method. -func (m *MockStateInfo) HeaderByHeight(height proto.Height) (*proto.BlockHeader, error) { +// IsActiveAtHeight mocks base method +func (m *MockStateInfo) IsActiveAtHeight(featureID int16, height proto.Height) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HeaderByHeight", height) - ret0, _ := ret[0].(*proto.BlockHeader) + ret := m.ctrl.Call(m, "IsActiveAtHeight", featureID, height) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// HeaderByHeight indicates an expected call of HeaderByHeight. -func (mr *MockStateInfoMockRecorder) HeaderByHeight(height interface{}) *gomock.Call { +// IsActiveAtHeight indicates an expected call of IsActiveAtHeight +func (mr *MockStateInfoMockRecorder) IsActiveAtHeight(featureID, height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHeight", reflect.TypeOf((*MockStateInfo)(nil).HeaderByHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActiveAtHeight", reflect.TypeOf((*MockStateInfo)(nil).IsActiveAtHeight), featureID, height) } -// Height mocks base method. -func (m *MockStateInfo) Height() (proto.Height, error) { +// ActivationHeight mocks base method +func (m *MockStateInfo) ActivationHeight(featureID int16) (proto.Height, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Height") + ret := m.ctrl.Call(m, "ActivationHeight", featureID) ret0, _ := ret[0].(proto.Height) ret1, _ := ret[1].(error) return ret0, ret1 } -// Height indicates an expected call of Height. -func (mr *MockStateInfoMockRecorder) Height() *gomock.Call { +// ActivationHeight indicates an expected call of ActivationHeight +func (mr *MockStateInfoMockRecorder) ActivationHeight(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockStateInfo)(nil).Height)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivationHeight", reflect.TypeOf((*MockStateInfo)(nil).ActivationHeight), featureID) } -// HeightToBlockID mocks base method. -func (m *MockStateInfo) HeightToBlockID(height proto.Height) (proto.BlockID, error) { +// IsApproved mocks base method +func (m *MockStateInfo) IsApproved(featureID int16) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HeightToBlockID", height) - ret0, _ := ret[0].(proto.BlockID) + ret := m.ctrl.Call(m, "IsApproved", featureID) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// HeightToBlockID indicates an expected call of HeightToBlockID. -func (mr *MockStateInfoMockRecorder) HeightToBlockID(height interface{}) *gomock.Call { +// IsApproved indicates an expected call of IsApproved +func (mr *MockStateInfoMockRecorder) IsApproved(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeightToBlockID", reflect.TypeOf((*MockStateInfo)(nil).HeightToBlockID), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApproved", reflect.TypeOf((*MockStateInfo)(nil).IsApproved), featureID) } -// HitSourceAtHeight mocks base method. -func (m *MockStateInfo) HitSourceAtHeight(height proto.Height) ([]byte, error) { +// IsApprovedAtHeight mocks base method +func (m *MockStateInfo) IsApprovedAtHeight(featureID int16, height proto.Height) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HitSourceAtHeight", height) - ret0, _ := ret[0].([]byte) + ret := m.ctrl.Call(m, "IsApprovedAtHeight", featureID, height) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// HitSourceAtHeight indicates an expected call of HitSourceAtHeight. -func (mr *MockStateInfoMockRecorder) HitSourceAtHeight(height interface{}) *gomock.Call { +// IsApprovedAtHeight indicates an expected call of IsApprovedAtHeight +func (mr *MockStateInfoMockRecorder) IsApprovedAtHeight(featureID, height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HitSourceAtHeight", reflect.TypeOf((*MockStateInfo)(nil).HitSourceAtHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApprovedAtHeight", reflect.TypeOf((*MockStateInfo)(nil).IsApprovedAtHeight), featureID, height) } -// InvokeResultByID mocks base method. -func (m *MockStateInfo) InvokeResultByID(invokeID crypto.Digest) (*proto.ScriptResult, error) { +// ApprovalHeight mocks base method +func (m *MockStateInfo) ApprovalHeight(featureID int16) (proto.Height, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "InvokeResultByID", invokeID) - ret0, _ := ret[0].(*proto.ScriptResult) + ret := m.ctrl.Call(m, "ApprovalHeight", featureID) + ret0, _ := ret[0].(proto.Height) ret1, _ := ret[1].(error) return ret0, ret1 } -// InvokeResultByID indicates an expected call of InvokeResultByID. -func (mr *MockStateInfoMockRecorder) InvokeResultByID(invokeID interface{}) *gomock.Call { +// ApprovalHeight indicates an expected call of ApprovalHeight +func (mr *MockStateInfoMockRecorder) ApprovalHeight(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeResultByID", reflect.TypeOf((*MockStateInfo)(nil).InvokeResultByID), invokeID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApprovalHeight", reflect.TypeOf((*MockStateInfo)(nil).ApprovalHeight), featureID) } -// IsActivated mocks base method. -func (m *MockStateInfo) IsActivated(featureID int16) (bool, error) { +// AllFeatures mocks base method +func (m *MockStateInfo) AllFeatures() ([]int16, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsActivated", featureID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "AllFeatures") + ret0, _ := ret[0].([]int16) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsActivated indicates an expected call of IsActivated. -func (mr *MockStateInfoMockRecorder) IsActivated(featureID interface{}) *gomock.Call { +// AllFeatures indicates an expected call of AllFeatures +func (mr *MockStateInfoMockRecorder) AllFeatures() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActivated", reflect.TypeOf((*MockStateInfo)(nil).IsActivated), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllFeatures", reflect.TypeOf((*MockStateInfo)(nil).AllFeatures)) } -// IsActiveAtHeight mocks base method. -func (m *MockStateInfo) IsActiveAtHeight(featureID int16, height proto.Height) (bool, error) { +// EstimatorVersion mocks base method +func (m *MockStateInfo) EstimatorVersion() (int, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsActiveAtHeight", featureID, height) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "EstimatorVersion") + ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsActiveAtHeight indicates an expected call of IsActiveAtHeight. -func (mr *MockStateInfoMockRecorder) IsActiveAtHeight(featureID, height interface{}) *gomock.Call { +// EstimatorVersion indicates an expected call of EstimatorVersion +func (mr *MockStateInfoMockRecorder) EstimatorVersion() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActiveAtHeight", reflect.TypeOf((*MockStateInfo)(nil).IsActiveAtHeight), featureID, height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimatorVersion", reflect.TypeOf((*MockStateInfo)(nil).EstimatorVersion)) } -// IsActiveLeasing mocks base method. -func (m *MockStateInfo) IsActiveLeasing(leaseID crypto.Digest) (bool, error) { +// AddrByAlias mocks base method +func (m *MockStateInfo) AddrByAlias(alias proto.Alias) (proto.Address, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsActiveLeasing", leaseID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "AddrByAlias", alias) + ret0, _ := ret[0].(proto.Address) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsActiveLeasing indicates an expected call of IsActiveLeasing. -func (mr *MockStateInfoMockRecorder) IsActiveLeasing(leaseID interface{}) *gomock.Call { +// AddrByAlias indicates an expected call of AddrByAlias +func (mr *MockStateInfoMockRecorder) AddrByAlias(alias interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActiveLeasing", reflect.TypeOf((*MockStateInfo)(nil).IsActiveLeasing), leaseID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddrByAlias", reflect.TypeOf((*MockStateInfo)(nil).AddrByAlias), alias) } -// IsApproved mocks base method. -func (m *MockStateInfo) IsApproved(featureID int16) (bool, error) { +// RetrieveEntries mocks base method +func (m *MockStateInfo) RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsApproved", featureID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "RetrieveEntries", account) + ret0, _ := ret[0].([]proto.DataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsApproved indicates an expected call of IsApproved. -func (mr *MockStateInfoMockRecorder) IsApproved(featureID interface{}) *gomock.Call { +// RetrieveEntries indicates an expected call of RetrieveEntries +func (mr *MockStateInfoMockRecorder) RetrieveEntries(account interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApproved", reflect.TypeOf((*MockStateInfo)(nil).IsApproved), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveEntries", reflect.TypeOf((*MockStateInfo)(nil).RetrieveEntries), account) } -// IsApprovedAtHeight mocks base method. -func (m *MockStateInfo) IsApprovedAtHeight(featureID int16, height proto.Height) (bool, error) { +// RetrieveEntry mocks base method +func (m *MockStateInfo) RetrieveEntry(account proto.Recipient, key string) (proto.DataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsApprovedAtHeight", featureID, height) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "RetrieveEntry", account, key) + ret0, _ := ret[0].(proto.DataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsApprovedAtHeight indicates an expected call of IsApprovedAtHeight. -func (mr *MockStateInfoMockRecorder) IsApprovedAtHeight(featureID, height interface{}) *gomock.Call { +// RetrieveEntry indicates an expected call of RetrieveEntry +func (mr *MockStateInfoMockRecorder) RetrieveEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApprovedAtHeight", reflect.TypeOf((*MockStateInfo)(nil).IsApprovedAtHeight), featureID, height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveEntry), account, key) } -// MapR mocks base method. -func (m *MockStateInfo) MapR(arg0 func(state.StateInfo) (interface{}, error)) (interface{}, error) { +// RetrieveIntegerEntry mocks base method +func (m *MockStateInfo) RetrieveIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MapR", arg0) - ret0, _ := ret[0].(interface{}) + ret := m.ctrl.Call(m, "RetrieveIntegerEntry", account, key) + ret0, _ := ret[0].(*proto.IntegerDataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// MapR indicates an expected call of MapR. -func (mr *MockStateInfoMockRecorder) MapR(arg0 interface{}) *gomock.Call { +// RetrieveIntegerEntry indicates an expected call of RetrieveIntegerEntry +func (mr *MockStateInfoMockRecorder) RetrieveIntegerEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MapR", reflect.TypeOf((*MockStateInfo)(nil).MapR), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveIntegerEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveIntegerEntry), account, key) } -// NFTList mocks base method. -func (m *MockStateInfo) NFTList(account proto.Recipient, limit uint64, afterAssetID []byte) ([]*proto.FullAssetInfo, error) { +// RetrieveBooleanEntry mocks base method +func (m *MockStateInfo) RetrieveBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NFTList", account, limit, afterAssetID) - ret0, _ := ret[0].([]*proto.FullAssetInfo) + ret := m.ctrl.Call(m, "RetrieveBooleanEntry", account, key) + ret0, _ := ret[0].(*proto.BooleanDataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// NFTList indicates an expected call of NFTList. -func (mr *MockStateInfoMockRecorder) NFTList(account, limit, afterAssetID interface{}) *gomock.Call { +// RetrieveBooleanEntry indicates an expected call of RetrieveBooleanEntry +func (mr *MockStateInfoMockRecorder) RetrieveBooleanEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NFTList", reflect.TypeOf((*MockStateInfo)(nil).NFTList), account, limit, afterAssetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveBooleanEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveBooleanEntry), account, key) } -// NewAddrTransactionsIterator mocks base method. -func (m *MockStateInfo) NewAddrTransactionsIterator(addr proto.Address) (state.TransactionIterator, error) { +// RetrieveStringEntry mocks base method +func (m *MockStateInfo) RetrieveStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewAddrTransactionsIterator", addr) - ret0, _ := ret[0].(state.TransactionIterator) + ret := m.ctrl.Call(m, "RetrieveStringEntry", account, key) + ret0, _ := ret[0].(*proto.StringDataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// NewAddrTransactionsIterator indicates an expected call of NewAddrTransactionsIterator. -func (mr *MockStateInfoMockRecorder) NewAddrTransactionsIterator(addr interface{}) *gomock.Call { +// RetrieveStringEntry indicates an expected call of RetrieveStringEntry +func (mr *MockStateInfoMockRecorder) RetrieveStringEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddrTransactionsIterator", reflect.TypeOf((*MockStateInfo)(nil).NewAddrTransactionsIterator), addr) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveStringEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveStringEntry), account, key) } -// ProvidesExtendedApi mocks base method. -func (m *MockStateInfo) ProvidesExtendedApi() (bool, error) { +// RetrieveBinaryEntry mocks base method +func (m *MockStateInfo) RetrieveBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvidesExtendedApi") - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "RetrieveBinaryEntry", account, key) + ret0, _ := ret[0].(*proto.BinaryDataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// ProvidesExtendedApi indicates an expected call of ProvidesExtendedApi. -func (mr *MockStateInfoMockRecorder) ProvidesExtendedApi() *gomock.Call { +// RetrieveBinaryEntry indicates an expected call of RetrieveBinaryEntry +func (mr *MockStateInfoMockRecorder) RetrieveBinaryEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidesExtendedApi", reflect.TypeOf((*MockStateInfo)(nil).ProvidesExtendedApi)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveBinaryEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveBinaryEntry), account, key) } -// ProvidesStateHashes mocks base method. -func (m *MockStateInfo) ProvidesStateHashes() (bool, error) { +// TransactionByID mocks base method +func (m *MockStateInfo) TransactionByID(id []byte) (proto.Transaction, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvidesStateHashes") - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "TransactionByID", id) + ret0, _ := ret[0].(proto.Transaction) ret1, _ := ret[1].(error) return ret0, ret1 } -// ProvidesStateHashes indicates an expected call of ProvidesStateHashes. -func (mr *MockStateInfoMockRecorder) ProvidesStateHashes() *gomock.Call { +// TransactionByID indicates an expected call of TransactionByID +func (mr *MockStateInfoMockRecorder) TransactionByID(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidesStateHashes", reflect.TypeOf((*MockStateInfo)(nil).ProvidesStateHashes)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByID", reflect.TypeOf((*MockStateInfo)(nil).TransactionByID), id) } -// RetrieveBinaryEntry mocks base method. -func (m *MockStateInfo) RetrieveBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error) { +// TransactionByIDWithStatus mocks base method +func (m *MockStateInfo) TransactionByIDWithStatus(id []byte) (proto.Transaction, bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveBinaryEntry", account, key) - ret0, _ := ret[0].(*proto.BinaryDataEntry) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "TransactionByIDWithStatus", id) + ret0, _ := ret[0].(proto.Transaction) + ret1, _ := ret[1].(bool) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 } -// RetrieveBinaryEntry indicates an expected call of RetrieveBinaryEntry. -func (mr *MockStateInfoMockRecorder) RetrieveBinaryEntry(account, key interface{}) *gomock.Call { +// TransactionByIDWithStatus indicates an expected call of TransactionByIDWithStatus +func (mr *MockStateInfoMockRecorder) TransactionByIDWithStatus(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveBinaryEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveBinaryEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByIDWithStatus", reflect.TypeOf((*MockStateInfo)(nil).TransactionByIDWithStatus), id) } -// RetrieveBooleanEntry mocks base method. -func (m *MockStateInfo) RetrieveBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error) { +// TransactionHeightByID mocks base method +func (m *MockStateInfo) TransactionHeightByID(id []byte) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveBooleanEntry", account, key) - ret0, _ := ret[0].(*proto.BooleanDataEntry) + ret := m.ctrl.Call(m, "TransactionHeightByID", id) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveBooleanEntry indicates an expected call of RetrieveBooleanEntry. -func (mr *MockStateInfoMockRecorder) RetrieveBooleanEntry(account, key interface{}) *gomock.Call { +// TransactionHeightByID indicates an expected call of TransactionHeightByID +func (mr *MockStateInfoMockRecorder) TransactionHeightByID(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveBooleanEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveBooleanEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionHeightByID", reflect.TypeOf((*MockStateInfo)(nil).TransactionHeightByID), id) } -// RetrieveEntries mocks base method. -func (m *MockStateInfo) RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error) { +// NewAddrTransactionsIterator mocks base method +func (m *MockStateInfo) NewAddrTransactionsIterator(addr proto.Address) (state.TransactionIterator, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveEntries", account) - ret0, _ := ret[0].([]proto.DataEntry) + ret := m.ctrl.Call(m, "NewAddrTransactionsIterator", addr) + ret0, _ := ret[0].(state.TransactionIterator) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveEntries indicates an expected call of RetrieveEntries. -func (mr *MockStateInfoMockRecorder) RetrieveEntries(account interface{}) *gomock.Call { +// NewAddrTransactionsIterator indicates an expected call of NewAddrTransactionsIterator +func (mr *MockStateInfoMockRecorder) NewAddrTransactionsIterator(addr interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveEntries", reflect.TypeOf((*MockStateInfo)(nil).RetrieveEntries), account) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddrTransactionsIterator", reflect.TypeOf((*MockStateInfo)(nil).NewAddrTransactionsIterator), addr) } -// RetrieveEntry mocks base method. -func (m *MockStateInfo) RetrieveEntry(account proto.Recipient, key string) (proto.DataEntry, error) { +// AssetIsSponsored mocks base method +func (m *MockStateInfo) AssetIsSponsored(assetID crypto.Digest) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveEntry", account, key) - ret0, _ := ret[0].(proto.DataEntry) + ret := m.ctrl.Call(m, "AssetIsSponsored", assetID) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveEntry indicates an expected call of RetrieveEntry. -func (mr *MockStateInfoMockRecorder) RetrieveEntry(account, key interface{}) *gomock.Call { +// AssetIsSponsored indicates an expected call of AssetIsSponsored +func (mr *MockStateInfoMockRecorder) AssetIsSponsored(assetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetIsSponsored", reflect.TypeOf((*MockStateInfo)(nil).AssetIsSponsored), assetID) } -// RetrieveIntegerEntry mocks base method. -func (m *MockStateInfo) RetrieveIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error) { +// AssetInfo mocks base method +func (m *MockStateInfo) AssetInfo(assetID crypto.Digest) (*proto.AssetInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveIntegerEntry", account, key) - ret0, _ := ret[0].(*proto.IntegerDataEntry) + ret := m.ctrl.Call(m, "AssetInfo", assetID) + ret0, _ := ret[0].(*proto.AssetInfo) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveIntegerEntry indicates an expected call of RetrieveIntegerEntry. -func (mr *MockStateInfoMockRecorder) RetrieveIntegerEntry(account, key interface{}) *gomock.Call { +// AssetInfo indicates an expected call of AssetInfo +func (mr *MockStateInfoMockRecorder) AssetInfo(assetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveIntegerEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveIntegerEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetInfo", reflect.TypeOf((*MockStateInfo)(nil).AssetInfo), assetID) } -// RetrieveStringEntry mocks base method. -func (m *MockStateInfo) RetrieveStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error) { +// FullAssetInfo mocks base method +func (m *MockStateInfo) FullAssetInfo(assetID crypto.Digest) (*proto.FullAssetInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveStringEntry", account, key) - ret0, _ := ret[0].(*proto.StringDataEntry) + ret := m.ctrl.Call(m, "FullAssetInfo", assetID) + ret0, _ := ret[0].(*proto.FullAssetInfo) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveStringEntry indicates an expected call of RetrieveStringEntry. -func (mr *MockStateInfoMockRecorder) RetrieveStringEntry(account, key interface{}) *gomock.Call { +// FullAssetInfo indicates an expected call of FullAssetInfo +func (mr *MockStateInfoMockRecorder) FullAssetInfo(assetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveStringEntry", reflect.TypeOf((*MockStateInfo)(nil).RetrieveStringEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullAssetInfo", reflect.TypeOf((*MockStateInfo)(nil).FullAssetInfo), assetID) } -// ScoreAtHeight mocks base method. -func (m *MockStateInfo) ScoreAtHeight(height proto.Height) (*big.Int, error) { +// NFTList mocks base method +func (m *MockStateInfo) NFTList(account proto.Recipient, limit uint64, afterAssetID []byte) ([]*proto.FullAssetInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScoreAtHeight", height) - ret0, _ := ret[0].(*big.Int) + ret := m.ctrl.Call(m, "NFTList", account, limit, afterAssetID) + ret0, _ := ret[0].([]*proto.FullAssetInfo) ret1, _ := ret[1].(error) return ret0, ret1 } -// ScoreAtHeight indicates an expected call of ScoreAtHeight. -func (mr *MockStateInfoMockRecorder) ScoreAtHeight(height interface{}) *gomock.Call { +// NFTList indicates an expected call of NFTList +func (mr *MockStateInfoMockRecorder) NFTList(account, limit, afterAssetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScoreAtHeight", reflect.TypeOf((*MockStateInfo)(nil).ScoreAtHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NFTList", reflect.TypeOf((*MockStateInfo)(nil).NFTList), account, limit, afterAssetID) } -// ScriptInfoByAccount mocks base method. +// ScriptInfoByAccount mocks base method func (m *MockStateInfo) ScriptInfoByAccount(account proto.Recipient) (*proto.ScriptInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ScriptInfoByAccount", account) @@ -711,13 +725,13 @@ func (m *MockStateInfo) ScriptInfoByAccount(account proto.Recipient) (*proto.Scr return ret0, ret1 } -// ScriptInfoByAccount indicates an expected call of ScriptInfoByAccount. +// ScriptInfoByAccount indicates an expected call of ScriptInfoByAccount func (mr *MockStateInfoMockRecorder) ScriptInfoByAccount(account interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptInfoByAccount", reflect.TypeOf((*MockStateInfo)(nil).ScriptInfoByAccount), account) } -// ScriptInfoByAsset mocks base method. +// ScriptInfoByAsset mocks base method func (m *MockStateInfo) ScriptInfoByAsset(assetID crypto.Digest) (*proto.ScriptInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ScriptInfoByAsset", assetID) @@ -726,171 +740,156 @@ func (m *MockStateInfo) ScriptInfoByAsset(assetID crypto.Digest) (*proto.ScriptI return ret0, ret1 } -// ScriptInfoByAsset indicates an expected call of ScriptInfoByAsset. +// ScriptInfoByAsset indicates an expected call of ScriptInfoByAsset func (mr *MockStateInfoMockRecorder) ScriptInfoByAsset(assetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptInfoByAsset", reflect.TypeOf((*MockStateInfo)(nil).ScriptInfoByAsset), assetID) } -// ShouldPersistAddressTransactions mocks base method. -func (m *MockStateInfo) ShouldPersistAddressTransactions() (bool, error) { +// IsActiveLeasing mocks base method +func (m *MockStateInfo) IsActiveLeasing(leaseID crypto.Digest) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ShouldPersistAddressTransactions") + ret := m.ctrl.Call(m, "IsActiveLeasing", leaseID) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// ShouldPersistAddressTransactions indicates an expected call of ShouldPersistAddressTransactions. -func (mr *MockStateInfoMockRecorder) ShouldPersistAddressTransactions() *gomock.Call { +// IsActiveLeasing indicates an expected call of IsActiveLeasing +func (mr *MockStateInfoMockRecorder) IsActiveLeasing(leaseID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldPersistAddressTransactions", reflect.TypeOf((*MockStateInfo)(nil).ShouldPersistAddressTransactions)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActiveLeasing", reflect.TypeOf((*MockStateInfo)(nil).IsActiveLeasing), leaseID) } -// StateHashAtHeight mocks base method. -func (m *MockStateInfo) StateHashAtHeight(height uint64) (*proto.StateHash, error) { +// InvokeResultByID mocks base method +func (m *MockStateInfo) InvokeResultByID(invokeID crypto.Digest) (*proto.ScriptResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StateHashAtHeight", height) - ret0, _ := ret[0].(*proto.StateHash) + ret := m.ctrl.Call(m, "InvokeResultByID", invokeID) + ret0, _ := ret[0].(*proto.ScriptResult) ret1, _ := ret[1].(error) return ret0, ret1 } -// StateHashAtHeight indicates an expected call of StateHashAtHeight. -func (mr *MockStateInfoMockRecorder) StateHashAtHeight(height interface{}) *gomock.Call { +// InvokeResultByID indicates an expected call of InvokeResultByID +func (mr *MockStateInfoMockRecorder) InvokeResultByID(invokeID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateHashAtHeight", reflect.TypeOf((*MockStateInfo)(nil).StateHashAtHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeResultByID", reflect.TypeOf((*MockStateInfo)(nil).InvokeResultByID), invokeID) } -// TopBlock mocks base method. -func (m *MockStateInfo) TopBlock() *proto.Block { +// ProvidesExtendedApi mocks base method +func (m *MockStateInfo) ProvidesExtendedApi() (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopBlock") - ret0, _ := ret[0].(*proto.Block) - return ret0 + ret := m.ctrl.Call(m, "ProvidesExtendedApi") + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// TopBlock indicates an expected call of TopBlock. -func (mr *MockStateInfoMockRecorder) TopBlock() *gomock.Call { +// ProvidesExtendedApi indicates an expected call of ProvidesExtendedApi +func (mr *MockStateInfoMockRecorder) ProvidesExtendedApi() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopBlock", reflect.TypeOf((*MockStateInfo)(nil).TopBlock)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidesExtendedApi", reflect.TypeOf((*MockStateInfo)(nil).ProvidesExtendedApi)) } -// TransactionByID mocks base method. -func (m *MockStateInfo) TransactionByID(id []byte) (proto.Transaction, error) { +// ProvidesStateHashes mocks base method +func (m *MockStateInfo) ProvidesStateHashes() (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransactionByID", id) - ret0, _ := ret[0].(proto.Transaction) + ret := m.ctrl.Call(m, "ProvidesStateHashes") + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// TransactionByID indicates an expected call of TransactionByID. -func (mr *MockStateInfoMockRecorder) TransactionByID(id interface{}) *gomock.Call { +// ProvidesStateHashes indicates an expected call of ProvidesStateHashes +func (mr *MockStateInfoMockRecorder) ProvidesStateHashes() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByID", reflect.TypeOf((*MockStateInfo)(nil).TransactionByID), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidesStateHashes", reflect.TypeOf((*MockStateInfo)(nil).ProvidesStateHashes)) } -// TransactionByIDWithStatus mocks base method. -func (m *MockStateInfo) TransactionByIDWithStatus(id []byte) (proto.Transaction, bool, error) { +// StateHashAtHeight mocks base method +func (m *MockStateInfo) StateHashAtHeight(height uint64) (*proto.StateHash, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransactionByIDWithStatus", id) - ret0, _ := ret[0].(proto.Transaction) - ret1, _ := ret[1].(bool) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret := m.ctrl.Call(m, "StateHashAtHeight", height) + ret0, _ := ret[0].(*proto.StateHash) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// TransactionByIDWithStatus indicates an expected call of TransactionByIDWithStatus. -func (mr *MockStateInfoMockRecorder) TransactionByIDWithStatus(id interface{}) *gomock.Call { +// StateHashAtHeight indicates an expected call of StateHashAtHeight +func (mr *MockStateInfoMockRecorder) StateHashAtHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByIDWithStatus", reflect.TypeOf((*MockStateInfo)(nil).TransactionByIDWithStatus), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateHashAtHeight", reflect.TypeOf((*MockStateInfo)(nil).StateHashAtHeight), height) } -// TransactionHeightByID mocks base method. -func (m *MockStateInfo) TransactionHeightByID(id []byte) (uint64, error) { +// MapR mocks base method +func (m *MockStateInfo) MapR(arg0 func(state.StateInfo) (interface{}, error)) (interface{}, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransactionHeightByID", id) - ret0, _ := ret[0].(uint64) + ret := m.ctrl.Call(m, "MapR", arg0) + ret0, _ := ret[0].(interface{}) ret1, _ := ret[1].(error) return ret0, ret1 } -// TransactionHeightByID indicates an expected call of TransactionHeightByID. -func (mr *MockStateInfoMockRecorder) TransactionHeightByID(id interface{}) *gomock.Call { +// MapR indicates an expected call of MapR +func (mr *MockStateInfoMockRecorder) MapR(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionHeightByID", reflect.TypeOf((*MockStateInfo)(nil).TransactionHeightByID), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MapR", reflect.TypeOf((*MockStateInfo)(nil).MapR), arg0) } -// VotesNum mocks base method. -func (m *MockStateInfo) VotesNum(featureID int16) (uint64, error) { +// HitSourceAtHeight mocks base method +func (m *MockStateInfo) HitSourceAtHeight(height proto.Height) ([]byte, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "VotesNum", featureID) - ret0, _ := ret[0].(uint64) + ret := m.ctrl.Call(m, "HitSourceAtHeight", height) + ret0, _ := ret[0].([]byte) ret1, _ := ret[1].(error) return ret0, ret1 } -// VotesNum indicates an expected call of VotesNum. -func (mr *MockStateInfoMockRecorder) VotesNum(featureID interface{}) *gomock.Call { +// HitSourceAtHeight indicates an expected call of HitSourceAtHeight +func (mr *MockStateInfoMockRecorder) HitSourceAtHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VotesNum", reflect.TypeOf((*MockStateInfo)(nil).VotesNum), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HitSourceAtHeight", reflect.TypeOf((*MockStateInfo)(nil).HitSourceAtHeight), height) } -// VotesNumAtHeight mocks base method. -func (m *MockStateInfo) VotesNumAtHeight(featureID int16, height proto.Height) (uint64, error) { +// ShouldPersistAddressTransactions mocks base method +func (m *MockStateInfo) ShouldPersistAddressTransactions() (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "VotesNumAtHeight", featureID, height) - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// VotesNumAtHeight indicates an expected call of VotesNumAtHeight. -func (mr *MockStateInfoMockRecorder) VotesNumAtHeight(featureID, height interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VotesNumAtHeight", reflect.TypeOf((*MockStateInfo)(nil).VotesNumAtHeight), featureID, height) -} - -// WavesAddressesNumber mocks base method. -func (m *MockStateInfo) WavesAddressesNumber() (uint64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WavesAddressesNumber") - ret0, _ := ret[0].(uint64) + ret := m.ctrl.Call(m, "ShouldPersistAddressTransactions") + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// WavesAddressesNumber indicates an expected call of WavesAddressesNumber. -func (mr *MockStateInfoMockRecorder) WavesAddressesNumber() *gomock.Call { +// ShouldPersistAddressTransactions indicates an expected call of ShouldPersistAddressTransactions +func (mr *MockStateInfoMockRecorder) ShouldPersistAddressTransactions() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WavesAddressesNumber", reflect.TypeOf((*MockStateInfo)(nil).WavesAddressesNumber)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldPersistAddressTransactions", reflect.TypeOf((*MockStateInfo)(nil).ShouldPersistAddressTransactions)) } -// MockStateModifier is a mock of StateModifier interface. +// MockStateModifier is a mock of StateModifier interface type MockStateModifier struct { ctrl *gomock.Controller recorder *MockStateModifierMockRecorder } -// MockStateModifierMockRecorder is the mock recorder for MockStateModifier. +// MockStateModifierMockRecorder is the mock recorder for MockStateModifier type MockStateModifierMockRecorder struct { mock *MockStateModifier } -// NewMockStateModifier creates a new mock instance. +// NewMockStateModifier creates a new mock instance func NewMockStateModifier(ctrl *gomock.Controller) *MockStateModifier { mock := &MockStateModifier{ctrl: ctrl} mock.recorder = &MockStateModifierMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockStateModifier) EXPECT() *MockStateModifierMockRecorder { return m.recorder } -// AddBlock mocks base method. +// AddBlock mocks base method func (m *MockStateModifier) AddBlock(block []byte) (*proto.Block, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddBlock", block) @@ -899,13 +898,13 @@ func (m *MockStateModifier) AddBlock(block []byte) (*proto.Block, error) { return ret0, ret1 } -// AddBlock indicates an expected call of AddBlock. +// AddBlock indicates an expected call of AddBlock func (mr *MockStateModifierMockRecorder) AddBlock(block interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlock", reflect.TypeOf((*MockStateModifier)(nil).AddBlock), block) } -// AddDeserializedBlock mocks base method. +// AddDeserializedBlock mocks base method func (m *MockStateModifier) AddDeserializedBlock(block *proto.Block) (*proto.Block, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddDeserializedBlock", block) @@ -914,13 +913,13 @@ func (m *MockStateModifier) AddDeserializedBlock(block *proto.Block) (*proto.Blo return ret0, ret1 } -// AddDeserializedBlock indicates an expected call of AddDeserializedBlock. +// AddDeserializedBlock indicates an expected call of AddDeserializedBlock func (mr *MockStateModifierMockRecorder) AddDeserializedBlock(block interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDeserializedBlock", reflect.TypeOf((*MockStateModifier)(nil).AddDeserializedBlock), block) } -// AddNewBlocks mocks base method. +// AddNewBlocks mocks base method func (m *MockStateModifier) AddNewBlocks(blocks [][]byte) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddNewBlocks", blocks) @@ -928,13 +927,13 @@ func (m *MockStateModifier) AddNewBlocks(blocks [][]byte) error { return ret0 } -// AddNewBlocks indicates an expected call of AddNewBlocks. +// AddNewBlocks indicates an expected call of AddNewBlocks func (mr *MockStateModifierMockRecorder) AddNewBlocks(blocks interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNewBlocks", reflect.TypeOf((*MockStateModifier)(nil).AddNewBlocks), blocks) } -// AddNewDeserializedBlocks mocks base method. +// AddNewDeserializedBlocks mocks base method func (m *MockStateModifier) AddNewDeserializedBlocks(blocks []*proto.Block) (*proto.Block, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddNewDeserializedBlocks", blocks) @@ -943,13 +942,13 @@ func (m *MockStateModifier) AddNewDeserializedBlocks(blocks []*proto.Block) (*pr return ret0, ret1 } -// AddNewDeserializedBlocks indicates an expected call of AddNewDeserializedBlocks. +// AddNewDeserializedBlocks indicates an expected call of AddNewDeserializedBlocks func (mr *MockStateModifierMockRecorder) AddNewDeserializedBlocks(blocks interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNewDeserializedBlocks", reflect.TypeOf((*MockStateModifier)(nil).AddNewDeserializedBlocks), blocks) } -// AddOldBlocks mocks base method. +// AddOldBlocks mocks base method func (m *MockStateModifier) AddOldBlocks(blocks [][]byte) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddOldBlocks", blocks) @@ -957,13 +956,13 @@ func (m *MockStateModifier) AddOldBlocks(blocks [][]byte) error { return ret0 } -// AddOldBlocks indicates an expected call of AddOldBlocks. +// AddOldBlocks indicates an expected call of AddOldBlocks func (mr *MockStateModifierMockRecorder) AddOldBlocks(blocks interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOldBlocks", reflect.TypeOf((*MockStateModifier)(nil).AddOldBlocks), blocks) } -// AddOldDeserializedBlocks mocks base method. +// AddOldDeserializedBlocks mocks base method func (m *MockStateModifier) AddOldDeserializedBlocks(blocks []*proto.Block) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddOldDeserializedBlocks", blocks) @@ -971,95 +970,95 @@ func (m *MockStateModifier) AddOldDeserializedBlocks(blocks []*proto.Block) erro return ret0 } -// AddOldDeserializedBlocks indicates an expected call of AddOldDeserializedBlocks. +// AddOldDeserializedBlocks indicates an expected call of AddOldDeserializedBlocks func (mr *MockStateModifierMockRecorder) AddOldDeserializedBlocks(blocks interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOldDeserializedBlocks", reflect.TypeOf((*MockStateModifier)(nil).AddOldDeserializedBlocks), blocks) } -// Close mocks base method. -func (m *MockStateModifier) Close() error { +// RollbackToHeight mocks base method +func (m *MockStateModifier) RollbackToHeight(height proto.Height) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "RollbackToHeight", height) ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockStateModifierMockRecorder) Close() *gomock.Call { +// RollbackToHeight indicates an expected call of RollbackToHeight +func (mr *MockStateModifierMockRecorder) RollbackToHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStateModifier)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackToHeight", reflect.TypeOf((*MockStateModifier)(nil).RollbackToHeight), height) } -// Map mocks base method. -func (m *MockStateModifier) Map(arg0 func(state.NonThreadSafeState) error) error { +// RollbackTo mocks base method +func (m *MockStateModifier) RollbackTo(removalEdge proto.BlockID) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Map", arg0) + ret := m.ctrl.Call(m, "RollbackTo", removalEdge) ret0, _ := ret[0].(error) return ret0 } -// Map indicates an expected call of Map. -func (mr *MockStateModifierMockRecorder) Map(arg0 interface{}) *gomock.Call { +// RollbackTo indicates an expected call of RollbackTo +func (mr *MockStateModifierMockRecorder) RollbackTo(removalEdge interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Map", reflect.TypeOf((*MockStateModifier)(nil).Map), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackTo", reflect.TypeOf((*MockStateModifier)(nil).RollbackTo), removalEdge) } -// PersistAddressTransactions mocks base method. -func (m *MockStateModifier) PersistAddressTransactions() error { +// ValidateNextTx mocks base method +func (m *MockStateModifier) ValidateNextTx(tx proto.Transaction, currentTimestamp, parentTimestamp uint64, blockVersion proto.BlockVersion, acceptFailed bool) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PersistAddressTransactions") + ret := m.ctrl.Call(m, "ValidateNextTx", tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) ret0, _ := ret[0].(error) return ret0 } -// PersistAddressTransactions indicates an expected call of PersistAddressTransactions. -func (mr *MockStateModifierMockRecorder) PersistAddressTransactions() *gomock.Call { +// ValidateNextTx indicates an expected call of ValidateNextTx +func (mr *MockStateModifierMockRecorder) ValidateNextTx(tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PersistAddressTransactions", reflect.TypeOf((*MockStateModifier)(nil).PersistAddressTransactions)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateNextTx", reflect.TypeOf((*MockStateModifier)(nil).ValidateNextTx), tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) } -// ResetValidationList mocks base method. +// ResetValidationList mocks base method func (m *MockStateModifier) ResetValidationList() { m.ctrl.T.Helper() m.ctrl.Call(m, "ResetValidationList") } -// ResetValidationList indicates an expected call of ResetValidationList. +// ResetValidationList indicates an expected call of ResetValidationList func (mr *MockStateModifierMockRecorder) ResetValidationList() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetValidationList", reflect.TypeOf((*MockStateModifier)(nil).ResetValidationList)) } -// RollbackTo mocks base method. -func (m *MockStateModifier) RollbackTo(removalEdge proto.BlockID) error { +// TxValidation mocks base method +func (m *MockStateModifier) TxValidation(arg0 func(state.TxValidation) error) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RollbackTo", removalEdge) + ret := m.ctrl.Call(m, "TxValidation", arg0) ret0, _ := ret[0].(error) return ret0 } -// RollbackTo indicates an expected call of RollbackTo. -func (mr *MockStateModifierMockRecorder) RollbackTo(removalEdge interface{}) *gomock.Call { +// TxValidation indicates an expected call of TxValidation +func (mr *MockStateModifierMockRecorder) TxValidation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackTo", reflect.TypeOf((*MockStateModifier)(nil).RollbackTo), removalEdge) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxValidation", reflect.TypeOf((*MockStateModifier)(nil).TxValidation), arg0) } -// RollbackToHeight mocks base method. -func (m *MockStateModifier) RollbackToHeight(height proto.Height) error { +// Map mocks base method +func (m *MockStateModifier) Map(arg0 func(state.NonThreadSafeState) error) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RollbackToHeight", height) + ret := m.ctrl.Call(m, "Map", arg0) ret0, _ := ret[0].(error) return ret0 } -// RollbackToHeight indicates an expected call of RollbackToHeight. -func (mr *MockStateModifierMockRecorder) RollbackToHeight(height interface{}) *gomock.Call { +// Map indicates an expected call of Map +func (mr *MockStateModifierMockRecorder) Map(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackToHeight", reflect.TypeOf((*MockStateModifier)(nil).RollbackToHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Map", reflect.TypeOf((*MockStateModifier)(nil).Map), arg0) } -// StartProvidingExtendedApi mocks base method. +// StartProvidingExtendedApi mocks base method func (m *MockStateModifier) StartProvidingExtendedApi() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StartProvidingExtendedApi") @@ -1067,64 +1066,64 @@ func (m *MockStateModifier) StartProvidingExtendedApi() error { return ret0 } -// StartProvidingExtendedApi indicates an expected call of StartProvidingExtendedApi. +// StartProvidingExtendedApi indicates an expected call of StartProvidingExtendedApi func (mr *MockStateModifierMockRecorder) StartProvidingExtendedApi() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartProvidingExtendedApi", reflect.TypeOf((*MockStateModifier)(nil).StartProvidingExtendedApi)) } -// TxValidation mocks base method. -func (m *MockStateModifier) TxValidation(arg0 func(state.TxValidation) error) error { +// PersistAddressTransactions mocks base method +func (m *MockStateModifier) PersistAddressTransactions() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TxValidation", arg0) + ret := m.ctrl.Call(m, "PersistAddressTransactions") ret0, _ := ret[0].(error) return ret0 } -// TxValidation indicates an expected call of TxValidation. -func (mr *MockStateModifierMockRecorder) TxValidation(arg0 interface{}) *gomock.Call { +// PersistAddressTransactions indicates an expected call of PersistAddressTransactions +func (mr *MockStateModifierMockRecorder) PersistAddressTransactions() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxValidation", reflect.TypeOf((*MockStateModifier)(nil).TxValidation), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PersistAddressTransactions", reflect.TypeOf((*MockStateModifier)(nil).PersistAddressTransactions)) } -// ValidateNextTx mocks base method. -func (m *MockStateModifier) ValidateNextTx(tx proto.Transaction, currentTimestamp, parentTimestamp uint64, blockVersion proto.BlockVersion, acceptFailed bool) error { +// Close mocks base method +func (m *MockStateModifier) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ValidateNextTx", tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -// ValidateNextTx indicates an expected call of ValidateNextTx. -func (mr *MockStateModifierMockRecorder) ValidateNextTx(tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockStateModifierMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateNextTx", reflect.TypeOf((*MockStateModifier)(nil).ValidateNextTx), tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStateModifier)(nil).Close)) } -// MockTxValidation is a mock of TxValidation interface. +// MockTxValidation is a mock of TxValidation interface type MockTxValidation struct { ctrl *gomock.Controller recorder *MockTxValidationMockRecorder } -// MockTxValidationMockRecorder is the mock recorder for MockTxValidation. +// MockTxValidationMockRecorder is the mock recorder for MockTxValidation type MockTxValidationMockRecorder struct { mock *MockTxValidation } -// NewMockTxValidation creates a new mock instance. +// NewMockTxValidation creates a new mock instance func NewMockTxValidation(ctrl *gomock.Controller) *MockTxValidation { mock := &MockTxValidation{ctrl: ctrl} mock.recorder = &MockTxValidationMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockTxValidation) EXPECT() *MockTxValidationMockRecorder { return m.recorder } -// ValidateNextTx mocks base method. +// ValidateNextTx mocks base method func (m *MockTxValidation) ValidateNextTx(tx proto.Transaction, currentTimestamp, parentTimestamp uint64, blockVersion proto.BlockVersion, acceptFailed bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ValidateNextTx", tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) @@ -1132,924 +1131,927 @@ func (m *MockTxValidation) ValidateNextTx(tx proto.Transaction, currentTimestamp return ret0 } -// ValidateNextTx indicates an expected call of ValidateNextTx. +// ValidateNextTx indicates an expected call of ValidateNextTx func (mr *MockTxValidationMockRecorder) ValidateNextTx(tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateNextTx", reflect.TypeOf((*MockTxValidation)(nil).ValidateNextTx), tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) } -// MockState is a mock of State interface. +// MockState is a mock of State interface type MockState struct { ctrl *gomock.Controller recorder *MockStateMockRecorder } -// MockStateMockRecorder is the mock recorder for MockState. +// MockStateMockRecorder is the mock recorder for MockState type MockStateMockRecorder struct { mock *MockState } -// NewMockState creates a new mock instance. +// NewMockState creates a new mock instance func NewMockState(ctrl *gomock.Controller) *MockState { mock := &MockState{ctrl: ctrl} mock.recorder = &MockStateMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockState) EXPECT() *MockStateMockRecorder { return m.recorder } -// AccountBalance mocks base method. -func (m *MockState) AccountBalance(account proto.Recipient, asset []byte) (uint64, error) { +// TopBlock mocks base method +func (m *MockState) TopBlock() *proto.Block { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AccountBalance", account, asset) - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "TopBlock") + ret0, _ := ret[0].(*proto.Block) + return ret0 } -// AccountBalance indicates an expected call of AccountBalance. -func (mr *MockStateMockRecorder) AccountBalance(account, asset interface{}) *gomock.Call { +// TopBlock indicates an expected call of TopBlock +func (mr *MockStateMockRecorder) TopBlock() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountBalance", reflect.TypeOf((*MockState)(nil).AccountBalance), account, asset) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopBlock", reflect.TypeOf((*MockState)(nil).TopBlock)) } -// ActivationHeight mocks base method. -func (m *MockState) ActivationHeight(featureID int16) (proto.Height, error) { +// Block mocks base method +func (m *MockState) Block(blockID proto.BlockID) (*proto.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ActivationHeight", featureID) - ret0, _ := ret[0].(proto.Height) + ret := m.ctrl.Call(m, "Block", blockID) + ret0, _ := ret[0].(*proto.Block) ret1, _ := ret[1].(error) return ret0, ret1 } -// ActivationHeight indicates an expected call of ActivationHeight. -func (mr *MockStateMockRecorder) ActivationHeight(featureID interface{}) *gomock.Call { +// Block indicates an expected call of Block +func (mr *MockStateMockRecorder) Block(blockID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivationHeight", reflect.TypeOf((*MockState)(nil).ActivationHeight), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Block", reflect.TypeOf((*MockState)(nil).Block), blockID) } -// AddBlock mocks base method. -func (m *MockState) AddBlock(block []byte) (*proto.Block, error) { +// BlockByHeight mocks base method +func (m *MockState) BlockByHeight(height proto.Height) (*proto.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddBlock", block) + ret := m.ctrl.Call(m, "BlockByHeight", height) ret0, _ := ret[0].(*proto.Block) ret1, _ := ret[1].(error) return ret0, ret1 } -// AddBlock indicates an expected call of AddBlock. -func (mr *MockStateMockRecorder) AddBlock(block interface{}) *gomock.Call { +// BlockByHeight indicates an expected call of BlockByHeight +func (mr *MockStateMockRecorder) BlockByHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlock", reflect.TypeOf((*MockState)(nil).AddBlock), block) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHeight", reflect.TypeOf((*MockState)(nil).BlockByHeight), height) } -// AddDeserializedBlock mocks base method. -func (m *MockState) AddDeserializedBlock(block *proto.Block) (*proto.Block, error) { +// Header mocks base method +func (m *MockState) Header(blockID proto.BlockID) (*proto.BlockHeader, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddDeserializedBlock", block) - ret0, _ := ret[0].(*proto.Block) + ret := m.ctrl.Call(m, "Header", blockID) + ret0, _ := ret[0].(*proto.BlockHeader) ret1, _ := ret[1].(error) return ret0, ret1 } -// AddDeserializedBlock indicates an expected call of AddDeserializedBlock. -func (mr *MockStateMockRecorder) AddDeserializedBlock(block interface{}) *gomock.Call { +// Header indicates an expected call of Header +func (mr *MockStateMockRecorder) Header(blockID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDeserializedBlock", reflect.TypeOf((*MockState)(nil).AddDeserializedBlock), block) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockState)(nil).Header), blockID) } -// AddNewBlocks mocks base method. -func (m *MockState) AddNewBlocks(blocks [][]byte) error { +// HeaderByHeight mocks base method +func (m *MockState) HeaderByHeight(height proto.Height) (*proto.BlockHeader, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddNewBlocks", blocks) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "HeaderByHeight", height) + ret0, _ := ret[0].(*proto.BlockHeader) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// AddNewBlocks indicates an expected call of AddNewBlocks. -func (mr *MockStateMockRecorder) AddNewBlocks(blocks interface{}) *gomock.Call { +// HeaderByHeight indicates an expected call of HeaderByHeight +func (mr *MockStateMockRecorder) HeaderByHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNewBlocks", reflect.TypeOf((*MockState)(nil).AddNewBlocks), blocks) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHeight", reflect.TypeOf((*MockState)(nil).HeaderByHeight), height) } -// AddNewDeserializedBlocks mocks base method. -func (m *MockState) AddNewDeserializedBlocks(blocks []*proto.Block) (*proto.Block, error) { +// Height mocks base method +func (m *MockState) Height() (proto.Height, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddNewDeserializedBlocks", blocks) - ret0, _ := ret[0].(*proto.Block) + ret := m.ctrl.Call(m, "Height") + ret0, _ := ret[0].(proto.Height) ret1, _ := ret[1].(error) return ret0, ret1 } -// AddNewDeserializedBlocks indicates an expected call of AddNewDeserializedBlocks. -func (mr *MockStateMockRecorder) AddNewDeserializedBlocks(blocks interface{}) *gomock.Call { +// Height indicates an expected call of Height +func (mr *MockStateMockRecorder) Height() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNewDeserializedBlocks", reflect.TypeOf((*MockState)(nil).AddNewDeserializedBlocks), blocks) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockState)(nil).Height)) } -// AddOldBlocks mocks base method. -func (m *MockState) AddOldBlocks(blocks [][]byte) error { +// BlockIDToHeight mocks base method +func (m *MockState) BlockIDToHeight(blockID proto.BlockID) (proto.Height, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddOldBlocks", blocks) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "BlockIDToHeight", blockID) + ret0, _ := ret[0].(proto.Height) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// AddOldBlocks indicates an expected call of AddOldBlocks. -func (mr *MockStateMockRecorder) AddOldBlocks(blocks interface{}) *gomock.Call { +// BlockIDToHeight indicates an expected call of BlockIDToHeight +func (mr *MockStateMockRecorder) BlockIDToHeight(blockID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOldBlocks", reflect.TypeOf((*MockState)(nil).AddOldBlocks), blocks) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockIDToHeight", reflect.TypeOf((*MockState)(nil).BlockIDToHeight), blockID) } -// AddOldDeserializedBlocks mocks base method. -func (m *MockState) AddOldDeserializedBlocks(blocks []*proto.Block) error { +// HeightToBlockID mocks base method +func (m *MockState) HeightToBlockID(height proto.Height) (proto.BlockID, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddOldDeserializedBlocks", blocks) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "HeightToBlockID", height) + ret0, _ := ret[0].(proto.BlockID) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// AddOldDeserializedBlocks indicates an expected call of AddOldDeserializedBlocks. -func (mr *MockStateMockRecorder) AddOldDeserializedBlocks(blocks interface{}) *gomock.Call { +// HeightToBlockID indicates an expected call of HeightToBlockID +func (mr *MockStateMockRecorder) HeightToBlockID(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOldDeserializedBlocks", reflect.TypeOf((*MockState)(nil).AddOldDeserializedBlocks), blocks) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeightToBlockID", reflect.TypeOf((*MockState)(nil).HeightToBlockID), height) } -// AddrByAlias mocks base method. -func (m *MockState) AddrByAlias(alias proto.Alias) (proto.Address, error) { +// FullWavesBalance mocks base method +func (m *MockState) FullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddrByAlias", alias) - ret0, _ := ret[0].(proto.Address) + ret := m.ctrl.Call(m, "FullWavesBalance", account) + ret0, _ := ret[0].(*proto.FullWavesBalance) ret1, _ := ret[1].(error) return ret0, ret1 } -// AddrByAlias indicates an expected call of AddrByAlias. -func (mr *MockStateMockRecorder) AddrByAlias(alias interface{}) *gomock.Call { +// FullWavesBalance indicates an expected call of FullWavesBalance +func (mr *MockStateMockRecorder) FullWavesBalance(account interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddrByAlias", reflect.TypeOf((*MockState)(nil).AddrByAlias), alias) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullWavesBalance", reflect.TypeOf((*MockState)(nil).FullWavesBalance), account) } -// AllFeatures mocks base method. -func (m *MockState) AllFeatures() ([]int16, error) { +// EffectiveBalance mocks base method +func (m *MockState) EffectiveBalance(account proto.Recipient, startHeight, endHeight proto.Height) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AllFeatures") - ret0, _ := ret[0].([]int16) + ret := m.ctrl.Call(m, "EffectiveBalance", account, startHeight, endHeight) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// AllFeatures indicates an expected call of AllFeatures. -func (mr *MockStateMockRecorder) AllFeatures() *gomock.Call { +// EffectiveBalance indicates an expected call of EffectiveBalance +func (mr *MockStateMockRecorder) EffectiveBalance(account, startHeight, endHeight interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllFeatures", reflect.TypeOf((*MockState)(nil).AllFeatures)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EffectiveBalance", reflect.TypeOf((*MockState)(nil).EffectiveBalance), account, startHeight, endHeight) } -// ApprovalHeight mocks base method. -func (m *MockState) ApprovalHeight(featureID int16) (proto.Height, error) { +// AccountBalance mocks base method +func (m *MockState) AccountBalance(account proto.Recipient, asset []byte) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ApprovalHeight", featureID) - ret0, _ := ret[0].(proto.Height) + ret := m.ctrl.Call(m, "AccountBalance", account, asset) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// ApprovalHeight indicates an expected call of ApprovalHeight. -func (mr *MockStateMockRecorder) ApprovalHeight(featureID interface{}) *gomock.Call { +// AccountBalance indicates an expected call of AccountBalance +func (mr *MockStateMockRecorder) AccountBalance(account, asset interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApprovalHeight", reflect.TypeOf((*MockState)(nil).ApprovalHeight), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountBalance", reflect.TypeOf((*MockState)(nil).AccountBalance), account, asset) } -// AssetInfo mocks base method. -func (m *MockState) AssetInfo(assetID crypto.Digest) (*proto.AssetInfo, error) { +// WavesAddressesNumber mocks base method +func (m *MockState) WavesAddressesNumber() (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssetInfo", assetID) - ret0, _ := ret[0].(*proto.AssetInfo) + ret := m.ctrl.Call(m, "WavesAddressesNumber") + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// AssetInfo indicates an expected call of AssetInfo. -func (mr *MockStateMockRecorder) AssetInfo(assetID interface{}) *gomock.Call { +// WavesAddressesNumber indicates an expected call of WavesAddressesNumber +func (mr *MockStateMockRecorder) WavesAddressesNumber() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetInfo", reflect.TypeOf((*MockState)(nil).AssetInfo), assetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WavesAddressesNumber", reflect.TypeOf((*MockState)(nil).WavesAddressesNumber)) } -// AssetIsSponsored mocks base method. -func (m *MockState) AssetIsSponsored(assetID crypto.Digest) (bool, error) { +// ScoreAtHeight mocks base method +func (m *MockState) ScoreAtHeight(height proto.Height) (*big.Int, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssetIsSponsored", assetID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "ScoreAtHeight", height) + ret0, _ := ret[0].(*big.Int) ret1, _ := ret[1].(error) return ret0, ret1 } -// AssetIsSponsored indicates an expected call of AssetIsSponsored. -func (mr *MockStateMockRecorder) AssetIsSponsored(assetID interface{}) *gomock.Call { +// ScoreAtHeight indicates an expected call of ScoreAtHeight +func (mr *MockStateMockRecorder) ScoreAtHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetIsSponsored", reflect.TypeOf((*MockState)(nil).AssetIsSponsored), assetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScoreAtHeight", reflect.TypeOf((*MockState)(nil).ScoreAtHeight), height) } -// Block mocks base method. -func (m *MockState) Block(blockID proto.BlockID) (*proto.Block, error) { +// CurrentScore mocks base method +func (m *MockState) CurrentScore() (*big.Int, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Block", blockID) - ret0, _ := ret[0].(*proto.Block) + ret := m.ctrl.Call(m, "CurrentScore") + ret0, _ := ret[0].(*big.Int) ret1, _ := ret[1].(error) return ret0, ret1 } -// Block indicates an expected call of Block. -func (mr *MockStateMockRecorder) Block(blockID interface{}) *gomock.Call { +// CurrentScore indicates an expected call of CurrentScore +func (mr *MockStateMockRecorder) CurrentScore() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Block", reflect.TypeOf((*MockState)(nil).Block), blockID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentScore", reflect.TypeOf((*MockState)(nil).CurrentScore)) } -// BlockByHeight mocks base method. -func (m *MockState) BlockByHeight(height proto.Height) (*proto.Block, error) { +// BlockchainSettings mocks base method +func (m *MockState) BlockchainSettings() (*settings.BlockchainSettings, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BlockByHeight", height) - ret0, _ := ret[0].(*proto.Block) + ret := m.ctrl.Call(m, "BlockchainSettings") + ret0, _ := ret[0].(*settings.BlockchainSettings) ret1, _ := ret[1].(error) return ret0, ret1 } -// BlockByHeight indicates an expected call of BlockByHeight. -func (mr *MockStateMockRecorder) BlockByHeight(height interface{}) *gomock.Call { +// BlockchainSettings indicates an expected call of BlockchainSettings +func (mr *MockStateMockRecorder) BlockchainSettings() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHeight", reflect.TypeOf((*MockState)(nil).BlockByHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockchainSettings", reflect.TypeOf((*MockState)(nil).BlockchainSettings)) } -// BlockIDToHeight mocks base method. -func (m *MockState) BlockIDToHeight(blockID proto.BlockID) (proto.Height, error) { +// VotesNum mocks base method +func (m *MockState) VotesNum(featureID int16) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BlockIDToHeight", blockID) - ret0, _ := ret[0].(proto.Height) + ret := m.ctrl.Call(m, "VotesNum", featureID) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// BlockIDToHeight indicates an expected call of BlockIDToHeight. -func (mr *MockStateMockRecorder) BlockIDToHeight(blockID interface{}) *gomock.Call { +// VotesNum indicates an expected call of VotesNum +func (mr *MockStateMockRecorder) VotesNum(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockIDToHeight", reflect.TypeOf((*MockState)(nil).BlockIDToHeight), blockID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VotesNum", reflect.TypeOf((*MockState)(nil).VotesNum), featureID) } -// BlockchainSettings mocks base method. -func (m *MockState) BlockchainSettings() (*settings.BlockchainSettings, error) { +// VotesNumAtHeight mocks base method +func (m *MockState) VotesNumAtHeight(featureID int16, height proto.Height) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BlockchainSettings") - ret0, _ := ret[0].(*settings.BlockchainSettings) + ret := m.ctrl.Call(m, "VotesNumAtHeight", featureID, height) + ret0, _ := ret[0].(uint64) ret1, _ := ret[1].(error) return ret0, ret1 } -// BlockchainSettings indicates an expected call of BlockchainSettings. -func (mr *MockStateMockRecorder) BlockchainSettings() *gomock.Call { +// VotesNumAtHeight indicates an expected call of VotesNumAtHeight +func (mr *MockStateMockRecorder) VotesNumAtHeight(featureID, height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockchainSettings", reflect.TypeOf((*MockState)(nil).BlockchainSettings)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VotesNumAtHeight", reflect.TypeOf((*MockState)(nil).VotesNumAtHeight), featureID, height) } -// Close mocks base method. -func (m *MockState) Close() error { +// IsActivated mocks base method +func (m *MockState) IsActivated(featureID int16) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "IsActivated", featureID) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// Close indicates an expected call of Close. -func (mr *MockStateMockRecorder) Close() *gomock.Call { +// IsActivated indicates an expected call of IsActivated +func (mr *MockStateMockRecorder) IsActivated(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockState)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActivated", reflect.TypeOf((*MockState)(nil).IsActivated), featureID) } -// CurrentScore mocks base method. -func (m *MockState) CurrentScore() (*big.Int, error) { +// IsActiveAtHeight mocks base method +func (m *MockState) IsActiveAtHeight(featureID int16, height proto.Height) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CurrentScore") - ret0, _ := ret[0].(*big.Int) + ret := m.ctrl.Call(m, "IsActiveAtHeight", featureID, height) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// CurrentScore indicates an expected call of CurrentScore. -func (mr *MockStateMockRecorder) CurrentScore() *gomock.Call { +// IsActiveAtHeight indicates an expected call of IsActiveAtHeight +func (mr *MockStateMockRecorder) IsActiveAtHeight(featureID, height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentScore", reflect.TypeOf((*MockState)(nil).CurrentScore)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActiveAtHeight", reflect.TypeOf((*MockState)(nil).IsActiveAtHeight), featureID, height) } -// EffectiveBalance mocks base method. -func (m *MockState) EffectiveBalance(account proto.Recipient, startHeight, endHeight proto.Height) (uint64, error) { +// ActivationHeight mocks base method +func (m *MockState) ActivationHeight(featureID int16) (proto.Height, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EffectiveBalance", account, startHeight, endHeight) - ret0, _ := ret[0].(uint64) + ret := m.ctrl.Call(m, "ActivationHeight", featureID) + ret0, _ := ret[0].(proto.Height) ret1, _ := ret[1].(error) return ret0, ret1 } -// EffectiveBalance indicates an expected call of EffectiveBalance. -func (mr *MockStateMockRecorder) EffectiveBalance(account, startHeight, endHeight interface{}) *gomock.Call { +// ActivationHeight indicates an expected call of ActivationHeight +func (mr *MockStateMockRecorder) ActivationHeight(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EffectiveBalance", reflect.TypeOf((*MockState)(nil).EffectiveBalance), account, startHeight, endHeight) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivationHeight", reflect.TypeOf((*MockState)(nil).ActivationHeight), featureID) } -// EstimatorVersion mocks base method. -func (m *MockState) EstimatorVersion() (int, error) { +// IsApproved mocks base method +func (m *MockState) IsApproved(featureID int16) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EstimatorVersion") - ret0, _ := ret[0].(int) + ret := m.ctrl.Call(m, "IsApproved", featureID) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// EstimatorVersion indicates an expected call of EstimatorVersion. -func (mr *MockStateMockRecorder) EstimatorVersion() *gomock.Call { +// IsApproved indicates an expected call of IsApproved +func (mr *MockStateMockRecorder) IsApproved(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimatorVersion", reflect.TypeOf((*MockState)(nil).EstimatorVersion)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApproved", reflect.TypeOf((*MockState)(nil).IsApproved), featureID) } -// FullAssetInfo mocks base method. -func (m *MockState) FullAssetInfo(assetID crypto.Digest) (*proto.FullAssetInfo, error) { +// IsApprovedAtHeight mocks base method +func (m *MockState) IsApprovedAtHeight(featureID int16, height proto.Height) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FullAssetInfo", assetID) - ret0, _ := ret[0].(*proto.FullAssetInfo) + ret := m.ctrl.Call(m, "IsApprovedAtHeight", featureID, height) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// FullAssetInfo indicates an expected call of FullAssetInfo. -func (mr *MockStateMockRecorder) FullAssetInfo(assetID interface{}) *gomock.Call { +// IsApprovedAtHeight indicates an expected call of IsApprovedAtHeight +func (mr *MockStateMockRecorder) IsApprovedAtHeight(featureID, height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullAssetInfo", reflect.TypeOf((*MockState)(nil).FullAssetInfo), assetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApprovedAtHeight", reflect.TypeOf((*MockState)(nil).IsApprovedAtHeight), featureID, height) } -// FullWavesBalance mocks base method. -func (m *MockState) FullWavesBalance(account proto.Recipient) (*proto.FullWavesBalance, error) { +// ApprovalHeight mocks base method +func (m *MockState) ApprovalHeight(featureID int16) (proto.Height, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FullWavesBalance", account) - ret0, _ := ret[0].(*proto.FullWavesBalance) + ret := m.ctrl.Call(m, "ApprovalHeight", featureID) + ret0, _ := ret[0].(proto.Height) ret1, _ := ret[1].(error) return ret0, ret1 } -// FullWavesBalance indicates an expected call of FullWavesBalance. -func (mr *MockStateMockRecorder) FullWavesBalance(account interface{}) *gomock.Call { +// ApprovalHeight indicates an expected call of ApprovalHeight +func (mr *MockStateMockRecorder) ApprovalHeight(featureID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullWavesBalance", reflect.TypeOf((*MockState)(nil).FullWavesBalance), account) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApprovalHeight", reflect.TypeOf((*MockState)(nil).ApprovalHeight), featureID) } -// Header mocks base method. -func (m *MockState) Header(blockID proto.BlockID) (*proto.BlockHeader, error) { +// AllFeatures mocks base method +func (m *MockState) AllFeatures() ([]int16, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Header", blockID) - ret0, _ := ret[0].(*proto.BlockHeader) + ret := m.ctrl.Call(m, "AllFeatures") + ret0, _ := ret[0].([]int16) ret1, _ := ret[1].(error) return ret0, ret1 } -// Header indicates an expected call of Header. -func (mr *MockStateMockRecorder) Header(blockID interface{}) *gomock.Call { +// AllFeatures indicates an expected call of AllFeatures +func (mr *MockStateMockRecorder) AllFeatures() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockState)(nil).Header), blockID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllFeatures", reflect.TypeOf((*MockState)(nil).AllFeatures)) } -// HeaderByHeight mocks base method. -func (m *MockState) HeaderByHeight(height proto.Height) (*proto.BlockHeader, error) { +// EstimatorVersion mocks base method +func (m *MockState) EstimatorVersion() (int, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HeaderByHeight", height) - ret0, _ := ret[0].(*proto.BlockHeader) + ret := m.ctrl.Call(m, "EstimatorVersion") + ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) return ret0, ret1 } -// HeaderByHeight indicates an expected call of HeaderByHeight. -func (mr *MockStateMockRecorder) HeaderByHeight(height interface{}) *gomock.Call { +// EstimatorVersion indicates an expected call of EstimatorVersion +func (mr *MockStateMockRecorder) EstimatorVersion() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHeight", reflect.TypeOf((*MockState)(nil).HeaderByHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimatorVersion", reflect.TypeOf((*MockState)(nil).EstimatorVersion)) } -// Height mocks base method. -func (m *MockState) Height() (proto.Height, error) { +// AddrByAlias mocks base method +func (m *MockState) AddrByAlias(alias proto.Alias) (proto.Address, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Height") - ret0, _ := ret[0].(proto.Height) + ret := m.ctrl.Call(m, "AddrByAlias", alias) + ret0, _ := ret[0].(proto.Address) ret1, _ := ret[1].(error) return ret0, ret1 } -// Height indicates an expected call of Height. -func (mr *MockStateMockRecorder) Height() *gomock.Call { +// AddrByAlias indicates an expected call of AddrByAlias +func (mr *MockStateMockRecorder) AddrByAlias(alias interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Height", reflect.TypeOf((*MockState)(nil).Height)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddrByAlias", reflect.TypeOf((*MockState)(nil).AddrByAlias), alias) } -// HeightToBlockID mocks base method. -func (m *MockState) HeightToBlockID(height proto.Height) (proto.BlockID, error) { +// RetrieveEntries mocks base method +func (m *MockState) RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HeightToBlockID", height) - ret0, _ := ret[0].(proto.BlockID) + ret := m.ctrl.Call(m, "RetrieveEntries", account) + ret0, _ := ret[0].([]proto.DataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// HeightToBlockID indicates an expected call of HeightToBlockID. -func (mr *MockStateMockRecorder) HeightToBlockID(height interface{}) *gomock.Call { +// RetrieveEntries indicates an expected call of RetrieveEntries +func (mr *MockStateMockRecorder) RetrieveEntries(account interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeightToBlockID", reflect.TypeOf((*MockState)(nil).HeightToBlockID), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveEntries", reflect.TypeOf((*MockState)(nil).RetrieveEntries), account) } -// HitSourceAtHeight mocks base method. -func (m *MockState) HitSourceAtHeight(height proto.Height) ([]byte, error) { +// RetrieveEntry mocks base method +func (m *MockState) RetrieveEntry(account proto.Recipient, key string) (proto.DataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HitSourceAtHeight", height) - ret0, _ := ret[0].([]byte) + ret := m.ctrl.Call(m, "RetrieveEntry", account, key) + ret0, _ := ret[0].(proto.DataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// HitSourceAtHeight indicates an expected call of HitSourceAtHeight. -func (mr *MockStateMockRecorder) HitSourceAtHeight(height interface{}) *gomock.Call { +// RetrieveEntry indicates an expected call of RetrieveEntry +func (mr *MockStateMockRecorder) RetrieveEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HitSourceAtHeight", reflect.TypeOf((*MockState)(nil).HitSourceAtHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveEntry", reflect.TypeOf((*MockState)(nil).RetrieveEntry), account, key) } -// InvokeResultByID mocks base method. -func (m *MockState) InvokeResultByID(invokeID crypto.Digest) (*proto.ScriptResult, error) { +// RetrieveIntegerEntry mocks base method +func (m *MockState) RetrieveIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "InvokeResultByID", invokeID) - ret0, _ := ret[0].(*proto.ScriptResult) + ret := m.ctrl.Call(m, "RetrieveIntegerEntry", account, key) + ret0, _ := ret[0].(*proto.IntegerDataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// InvokeResultByID indicates an expected call of InvokeResultByID. -func (mr *MockStateMockRecorder) InvokeResultByID(invokeID interface{}) *gomock.Call { +// RetrieveIntegerEntry indicates an expected call of RetrieveIntegerEntry +func (mr *MockStateMockRecorder) RetrieveIntegerEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeResultByID", reflect.TypeOf((*MockState)(nil).InvokeResultByID), invokeID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveIntegerEntry", reflect.TypeOf((*MockState)(nil).RetrieveIntegerEntry), account, key) } -// IsActivated mocks base method. -func (m *MockState) IsActivated(featureID int16) (bool, error) { +// RetrieveBooleanEntry mocks base method +func (m *MockState) RetrieveBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsActivated", featureID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "RetrieveBooleanEntry", account, key) + ret0, _ := ret[0].(*proto.BooleanDataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsActivated indicates an expected call of IsActivated. -func (mr *MockStateMockRecorder) IsActivated(featureID interface{}) *gomock.Call { +// RetrieveBooleanEntry indicates an expected call of RetrieveBooleanEntry +func (mr *MockStateMockRecorder) RetrieveBooleanEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActivated", reflect.TypeOf((*MockState)(nil).IsActivated), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveBooleanEntry", reflect.TypeOf((*MockState)(nil).RetrieveBooleanEntry), account, key) } -// IsActiveAtHeight mocks base method. -func (m *MockState) IsActiveAtHeight(featureID int16, height proto.Height) (bool, error) { +// RetrieveStringEntry mocks base method +func (m *MockState) RetrieveStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsActiveAtHeight", featureID, height) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "RetrieveStringEntry", account, key) + ret0, _ := ret[0].(*proto.StringDataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsActiveAtHeight indicates an expected call of IsActiveAtHeight. -func (mr *MockStateMockRecorder) IsActiveAtHeight(featureID, height interface{}) *gomock.Call { +// RetrieveStringEntry indicates an expected call of RetrieveStringEntry +func (mr *MockStateMockRecorder) RetrieveStringEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActiveAtHeight", reflect.TypeOf((*MockState)(nil).IsActiveAtHeight), featureID, height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveStringEntry", reflect.TypeOf((*MockState)(nil).RetrieveStringEntry), account, key) } -// IsActiveLeasing mocks base method. -func (m *MockState) IsActiveLeasing(leaseID crypto.Digest) (bool, error) { +// RetrieveBinaryEntry mocks base method +func (m *MockState) RetrieveBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsActiveLeasing", leaseID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "RetrieveBinaryEntry", account, key) + ret0, _ := ret[0].(*proto.BinaryDataEntry) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsActiveLeasing indicates an expected call of IsActiveLeasing. -func (mr *MockStateMockRecorder) IsActiveLeasing(leaseID interface{}) *gomock.Call { +// RetrieveBinaryEntry indicates an expected call of RetrieveBinaryEntry +func (mr *MockStateMockRecorder) RetrieveBinaryEntry(account, key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActiveLeasing", reflect.TypeOf((*MockState)(nil).IsActiveLeasing), leaseID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveBinaryEntry", reflect.TypeOf((*MockState)(nil).RetrieveBinaryEntry), account, key) } -// IsApproved mocks base method. -func (m *MockState) IsApproved(featureID int16) (bool, error) { +// TransactionByID mocks base method +func (m *MockState) TransactionByID(id []byte) (proto.Transaction, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsApproved", featureID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "TransactionByID", id) + ret0, _ := ret[0].(proto.Transaction) ret1, _ := ret[1].(error) return ret0, ret1 } -// IsApproved indicates an expected call of IsApproved. -func (mr *MockStateMockRecorder) IsApproved(featureID interface{}) *gomock.Call { +// TransactionByID indicates an expected call of TransactionByID +func (mr *MockStateMockRecorder) TransactionByID(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApproved", reflect.TypeOf((*MockState)(nil).IsApproved), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByID", reflect.TypeOf((*MockState)(nil).TransactionByID), id) } -// IsApprovedAtHeight mocks base method. -func (m *MockState) IsApprovedAtHeight(featureID int16, height proto.Height) (bool, error) { +// TransactionByIDWithStatus mocks base method +func (m *MockState) TransactionByIDWithStatus(id []byte) (proto.Transaction, bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsApprovedAtHeight", featureID, height) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "TransactionByIDWithStatus", id) + ret0, _ := ret[0].(proto.Transaction) + ret1, _ := ret[1].(bool) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 } -// IsApprovedAtHeight indicates an expected call of IsApprovedAtHeight. -func (mr *MockStateMockRecorder) IsApprovedAtHeight(featureID, height interface{}) *gomock.Call { +// TransactionByIDWithStatus indicates an expected call of TransactionByIDWithStatus +func (mr *MockStateMockRecorder) TransactionByIDWithStatus(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApprovedAtHeight", reflect.TypeOf((*MockState)(nil).IsApprovedAtHeight), featureID, height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByIDWithStatus", reflect.TypeOf((*MockState)(nil).TransactionByIDWithStatus), id) } -// Map mocks base method. -func (m *MockState) Map(arg0 func(state.NonThreadSafeState) error) error { +// TransactionHeightByID mocks base method +func (m *MockState) TransactionHeightByID(id []byte) (uint64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Map", arg0) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "TransactionHeightByID", id) + ret0, _ := ret[0].(uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// Map indicates an expected call of Map. -func (mr *MockStateMockRecorder) Map(arg0 interface{}) *gomock.Call { +// TransactionHeightByID indicates an expected call of TransactionHeightByID +func (mr *MockStateMockRecorder) TransactionHeightByID(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Map", reflect.TypeOf((*MockState)(nil).Map), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionHeightByID", reflect.TypeOf((*MockState)(nil).TransactionHeightByID), id) } -// MapR mocks base method. -func (m *MockState) MapR(arg0 func(state.StateInfo) (interface{}, error)) (interface{}, error) { +// NewAddrTransactionsIterator mocks base method +func (m *MockState) NewAddrTransactionsIterator(addr proto.Address) (state.TransactionIterator, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MapR", arg0) - ret0, _ := ret[0].(interface{}) + ret := m.ctrl.Call(m, "NewAddrTransactionsIterator", addr) + ret0, _ := ret[0].(state.TransactionIterator) ret1, _ := ret[1].(error) return ret0, ret1 } -// MapR indicates an expected call of MapR. -func (mr *MockStateMockRecorder) MapR(arg0 interface{}) *gomock.Call { +// NewAddrTransactionsIterator indicates an expected call of NewAddrTransactionsIterator +func (mr *MockStateMockRecorder) NewAddrTransactionsIterator(addr interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MapR", reflect.TypeOf((*MockState)(nil).MapR), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddrTransactionsIterator", reflect.TypeOf((*MockState)(nil).NewAddrTransactionsIterator), addr) } -// NFTList mocks base method. -func (m *MockState) NFTList(account proto.Recipient, limit uint64, afterAssetID []byte) ([]*proto.FullAssetInfo, error) { +// AssetIsSponsored mocks base method +func (m *MockState) AssetIsSponsored(assetID crypto.Digest) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NFTList", account, limit, afterAssetID) - ret0, _ := ret[0].([]*proto.FullAssetInfo) + ret := m.ctrl.Call(m, "AssetIsSponsored", assetID) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// NFTList indicates an expected call of NFTList. -func (mr *MockStateMockRecorder) NFTList(account, limit, afterAssetID interface{}) *gomock.Call { +// AssetIsSponsored indicates an expected call of AssetIsSponsored +func (mr *MockStateMockRecorder) AssetIsSponsored(assetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NFTList", reflect.TypeOf((*MockState)(nil).NFTList), account, limit, afterAssetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetIsSponsored", reflect.TypeOf((*MockState)(nil).AssetIsSponsored), assetID) } -// NewAddrTransactionsIterator mocks base method. -func (m *MockState) NewAddrTransactionsIterator(addr proto.Address) (state.TransactionIterator, error) { +// AssetInfo mocks base method +func (m *MockState) AssetInfo(assetID crypto.Digest) (*proto.AssetInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewAddrTransactionsIterator", addr) - ret0, _ := ret[0].(state.TransactionIterator) + ret := m.ctrl.Call(m, "AssetInfo", assetID) + ret0, _ := ret[0].(*proto.AssetInfo) ret1, _ := ret[1].(error) return ret0, ret1 } -// NewAddrTransactionsIterator indicates an expected call of NewAddrTransactionsIterator. -func (mr *MockStateMockRecorder) NewAddrTransactionsIterator(addr interface{}) *gomock.Call { +// AssetInfo indicates an expected call of AssetInfo +func (mr *MockStateMockRecorder) AssetInfo(assetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddrTransactionsIterator", reflect.TypeOf((*MockState)(nil).NewAddrTransactionsIterator), addr) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssetInfo", reflect.TypeOf((*MockState)(nil).AssetInfo), assetID) } -// PersistAddressTransactions mocks base method. -func (m *MockState) PersistAddressTransactions() error { +// FullAssetInfo mocks base method +func (m *MockState) FullAssetInfo(assetID crypto.Digest) (*proto.FullAssetInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PersistAddressTransactions") - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "FullAssetInfo", assetID) + ret0, _ := ret[0].(*proto.FullAssetInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// PersistAddressTransactions indicates an expected call of PersistAddressTransactions. -func (mr *MockStateMockRecorder) PersistAddressTransactions() *gomock.Call { +// FullAssetInfo indicates an expected call of FullAssetInfo +func (mr *MockStateMockRecorder) FullAssetInfo(assetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PersistAddressTransactions", reflect.TypeOf((*MockState)(nil).PersistAddressTransactions)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullAssetInfo", reflect.TypeOf((*MockState)(nil).FullAssetInfo), assetID) } -// ProvidesExtendedApi mocks base method. -func (m *MockState) ProvidesExtendedApi() (bool, error) { +// NFTList mocks base method +func (m *MockState) NFTList(account proto.Recipient, limit uint64, afterAssetID []byte) ([]*proto.FullAssetInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvidesExtendedApi") - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "NFTList", account, limit, afterAssetID) + ret0, _ := ret[0].([]*proto.FullAssetInfo) ret1, _ := ret[1].(error) return ret0, ret1 } -// ProvidesExtendedApi indicates an expected call of ProvidesExtendedApi. -func (mr *MockStateMockRecorder) ProvidesExtendedApi() *gomock.Call { +// NFTList indicates an expected call of NFTList +func (mr *MockStateMockRecorder) NFTList(account, limit, afterAssetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidesExtendedApi", reflect.TypeOf((*MockState)(nil).ProvidesExtendedApi)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NFTList", reflect.TypeOf((*MockState)(nil).NFTList), account, limit, afterAssetID) } -// ProvidesStateHashes mocks base method. -func (m *MockState) ProvidesStateHashes() (bool, error) { +// ScriptInfoByAccount mocks base method +func (m *MockState) ScriptInfoByAccount(account proto.Recipient) (*proto.ScriptInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvidesStateHashes") - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "ScriptInfoByAccount", account) + ret0, _ := ret[0].(*proto.ScriptInfo) ret1, _ := ret[1].(error) return ret0, ret1 } -// ProvidesStateHashes indicates an expected call of ProvidesStateHashes. -func (mr *MockStateMockRecorder) ProvidesStateHashes() *gomock.Call { +// ScriptInfoByAccount indicates an expected call of ScriptInfoByAccount +func (mr *MockStateMockRecorder) ScriptInfoByAccount(account interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidesStateHashes", reflect.TypeOf((*MockState)(nil).ProvidesStateHashes)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptInfoByAccount", reflect.TypeOf((*MockState)(nil).ScriptInfoByAccount), account) } -// ResetValidationList mocks base method. -func (m *MockState) ResetValidationList() { +// ScriptInfoByAsset mocks base method +func (m *MockState) ScriptInfoByAsset(assetID crypto.Digest) (*proto.ScriptInfo, error) { m.ctrl.T.Helper() - m.ctrl.Call(m, "ResetValidationList") + ret := m.ctrl.Call(m, "ScriptInfoByAsset", assetID) + ret0, _ := ret[0].(*proto.ScriptInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// ResetValidationList indicates an expected call of ResetValidationList. -func (mr *MockStateMockRecorder) ResetValidationList() *gomock.Call { +// ScriptInfoByAsset indicates an expected call of ScriptInfoByAsset +func (mr *MockStateMockRecorder) ScriptInfoByAsset(assetID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetValidationList", reflect.TypeOf((*MockState)(nil).ResetValidationList)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptInfoByAsset", reflect.TypeOf((*MockState)(nil).ScriptInfoByAsset), assetID) } -// RetrieveBinaryEntry mocks base method. -func (m *MockState) RetrieveBinaryEntry(account proto.Recipient, key string) (*proto.BinaryDataEntry, error) { +// IsActiveLeasing mocks base method +func (m *MockState) IsActiveLeasing(leaseID crypto.Digest) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveBinaryEntry", account, key) - ret0, _ := ret[0].(*proto.BinaryDataEntry) + ret := m.ctrl.Call(m, "IsActiveLeasing", leaseID) + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveBinaryEntry indicates an expected call of RetrieveBinaryEntry. -func (mr *MockStateMockRecorder) RetrieveBinaryEntry(account, key interface{}) *gomock.Call { +// IsActiveLeasing indicates an expected call of IsActiveLeasing +func (mr *MockStateMockRecorder) IsActiveLeasing(leaseID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveBinaryEntry", reflect.TypeOf((*MockState)(nil).RetrieveBinaryEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActiveLeasing", reflect.TypeOf((*MockState)(nil).IsActiveLeasing), leaseID) } -// RetrieveBooleanEntry mocks base method. -func (m *MockState) RetrieveBooleanEntry(account proto.Recipient, key string) (*proto.BooleanDataEntry, error) { +// InvokeResultByID mocks base method +func (m *MockState) InvokeResultByID(invokeID crypto.Digest) (*proto.ScriptResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveBooleanEntry", account, key) - ret0, _ := ret[0].(*proto.BooleanDataEntry) + ret := m.ctrl.Call(m, "InvokeResultByID", invokeID) + ret0, _ := ret[0].(*proto.ScriptResult) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveBooleanEntry indicates an expected call of RetrieveBooleanEntry. -func (mr *MockStateMockRecorder) RetrieveBooleanEntry(account, key interface{}) *gomock.Call { +// InvokeResultByID indicates an expected call of InvokeResultByID +func (mr *MockStateMockRecorder) InvokeResultByID(invokeID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveBooleanEntry", reflect.TypeOf((*MockState)(nil).RetrieveBooleanEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeResultByID", reflect.TypeOf((*MockState)(nil).InvokeResultByID), invokeID) } -// RetrieveEntries mocks base method. -func (m *MockState) RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error) { +// ProvidesExtendedApi mocks base method +func (m *MockState) ProvidesExtendedApi() (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveEntries", account) - ret0, _ := ret[0].([]proto.DataEntry) + ret := m.ctrl.Call(m, "ProvidesExtendedApi") + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveEntries indicates an expected call of RetrieveEntries. -func (mr *MockStateMockRecorder) RetrieveEntries(account interface{}) *gomock.Call { +// ProvidesExtendedApi indicates an expected call of ProvidesExtendedApi +func (mr *MockStateMockRecorder) ProvidesExtendedApi() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveEntries", reflect.TypeOf((*MockState)(nil).RetrieveEntries), account) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidesExtendedApi", reflect.TypeOf((*MockState)(nil).ProvidesExtendedApi)) } -// RetrieveEntry mocks base method. -func (m *MockState) RetrieveEntry(account proto.Recipient, key string) (proto.DataEntry, error) { +// ProvidesStateHashes mocks base method +func (m *MockState) ProvidesStateHashes() (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveEntry", account, key) - ret0, _ := ret[0].(proto.DataEntry) + ret := m.ctrl.Call(m, "ProvidesStateHashes") + ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveEntry indicates an expected call of RetrieveEntry. -func (mr *MockStateMockRecorder) RetrieveEntry(account, key interface{}) *gomock.Call { +// ProvidesStateHashes indicates an expected call of ProvidesStateHashes +func (mr *MockStateMockRecorder) ProvidesStateHashes() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveEntry", reflect.TypeOf((*MockState)(nil).RetrieveEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidesStateHashes", reflect.TypeOf((*MockState)(nil).ProvidesStateHashes)) } -// RetrieveIntegerEntry mocks base method. -func (m *MockState) RetrieveIntegerEntry(account proto.Recipient, key string) (*proto.IntegerDataEntry, error) { +// StateHashAtHeight mocks base method +func (m *MockState) StateHashAtHeight(height uint64) (*proto.StateHash, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveIntegerEntry", account, key) - ret0, _ := ret[0].(*proto.IntegerDataEntry) + ret := m.ctrl.Call(m, "StateHashAtHeight", height) + ret0, _ := ret[0].(*proto.StateHash) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveIntegerEntry indicates an expected call of RetrieveIntegerEntry. -func (mr *MockStateMockRecorder) RetrieveIntegerEntry(account, key interface{}) *gomock.Call { +// StateHashAtHeight indicates an expected call of StateHashAtHeight +func (mr *MockStateMockRecorder) StateHashAtHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveIntegerEntry", reflect.TypeOf((*MockState)(nil).RetrieveIntegerEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateHashAtHeight", reflect.TypeOf((*MockState)(nil).StateHashAtHeight), height) } -// RetrieveStringEntry mocks base method. -func (m *MockState) RetrieveStringEntry(account proto.Recipient, key string) (*proto.StringDataEntry, error) { +// MapR mocks base method +func (m *MockState) MapR(arg0 func(state.StateInfo) (interface{}, error)) (interface{}, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveStringEntry", account, key) - ret0, _ := ret[0].(*proto.StringDataEntry) + ret := m.ctrl.Call(m, "MapR", arg0) + ret0, _ := ret[0].(interface{}) ret1, _ := ret[1].(error) return ret0, ret1 } -// RetrieveStringEntry indicates an expected call of RetrieveStringEntry. -func (mr *MockStateMockRecorder) RetrieveStringEntry(account, key interface{}) *gomock.Call { +// MapR indicates an expected call of MapR +func (mr *MockStateMockRecorder) MapR(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveStringEntry", reflect.TypeOf((*MockState)(nil).RetrieveStringEntry), account, key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MapR", reflect.TypeOf((*MockState)(nil).MapR), arg0) } -// RollbackTo mocks base method. -func (m *MockState) RollbackTo(removalEdge proto.BlockID) error { +// HitSourceAtHeight mocks base method +func (m *MockState) HitSourceAtHeight(height proto.Height) ([]byte, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RollbackTo", removalEdge) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "HitSourceAtHeight", height) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// RollbackTo indicates an expected call of RollbackTo. -func (mr *MockStateMockRecorder) RollbackTo(removalEdge interface{}) *gomock.Call { +// HitSourceAtHeight indicates an expected call of HitSourceAtHeight +func (mr *MockStateMockRecorder) HitSourceAtHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackTo", reflect.TypeOf((*MockState)(nil).RollbackTo), removalEdge) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HitSourceAtHeight", reflect.TypeOf((*MockState)(nil).HitSourceAtHeight), height) } -// RollbackToHeight mocks base method. -func (m *MockState) RollbackToHeight(height proto.Height) error { +// ShouldPersistAddressTransactions mocks base method +func (m *MockState) ShouldPersistAddressTransactions() (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RollbackToHeight", height) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "ShouldPersistAddressTransactions") + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 } -// RollbackToHeight indicates an expected call of RollbackToHeight. -func (mr *MockStateMockRecorder) RollbackToHeight(height interface{}) *gomock.Call { +// ShouldPersistAddressTransactions indicates an expected call of ShouldPersistAddressTransactions +func (mr *MockStateMockRecorder) ShouldPersistAddressTransactions() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackToHeight", reflect.TypeOf((*MockState)(nil).RollbackToHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldPersistAddressTransactions", reflect.TypeOf((*MockState)(nil).ShouldPersistAddressTransactions)) } -// ScoreAtHeight mocks base method. -func (m *MockState) ScoreAtHeight(height proto.Height) (*big.Int, error) { +// AddBlock mocks base method +func (m *MockState) AddBlock(block []byte) (*proto.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScoreAtHeight", height) - ret0, _ := ret[0].(*big.Int) + ret := m.ctrl.Call(m, "AddBlock", block) + ret0, _ := ret[0].(*proto.Block) ret1, _ := ret[1].(error) return ret0, ret1 } -// ScoreAtHeight indicates an expected call of ScoreAtHeight. -func (mr *MockStateMockRecorder) ScoreAtHeight(height interface{}) *gomock.Call { +// AddBlock indicates an expected call of AddBlock +func (mr *MockStateMockRecorder) AddBlock(block interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScoreAtHeight", reflect.TypeOf((*MockState)(nil).ScoreAtHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlock", reflect.TypeOf((*MockState)(nil).AddBlock), block) } -// ScriptInfoByAccount mocks base method. -func (m *MockState) ScriptInfoByAccount(account proto.Recipient) (*proto.ScriptInfo, error) { +// AddDeserializedBlock mocks base method +func (m *MockState) AddDeserializedBlock(block *proto.Block) (*proto.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScriptInfoByAccount", account) - ret0, _ := ret[0].(*proto.ScriptInfo) + ret := m.ctrl.Call(m, "AddDeserializedBlock", block) + ret0, _ := ret[0].(*proto.Block) ret1, _ := ret[1].(error) return ret0, ret1 } -// ScriptInfoByAccount indicates an expected call of ScriptInfoByAccount. -func (mr *MockStateMockRecorder) ScriptInfoByAccount(account interface{}) *gomock.Call { +// AddDeserializedBlock indicates an expected call of AddDeserializedBlock +func (mr *MockStateMockRecorder) AddDeserializedBlock(block interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptInfoByAccount", reflect.TypeOf((*MockState)(nil).ScriptInfoByAccount), account) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDeserializedBlock", reflect.TypeOf((*MockState)(nil).AddDeserializedBlock), block) } -// ScriptInfoByAsset mocks base method. -func (m *MockState) ScriptInfoByAsset(assetID crypto.Digest) (*proto.ScriptInfo, error) { +// AddNewBlocks mocks base method +func (m *MockState) AddNewBlocks(blocks [][]byte) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScriptInfoByAsset", assetID) - ret0, _ := ret[0].(*proto.ScriptInfo) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "AddNewBlocks", blocks) + ret0, _ := ret[0].(error) + return ret0 } -// ScriptInfoByAsset indicates an expected call of ScriptInfoByAsset. -func (mr *MockStateMockRecorder) ScriptInfoByAsset(assetID interface{}) *gomock.Call { +// AddNewBlocks indicates an expected call of AddNewBlocks +func (mr *MockStateMockRecorder) AddNewBlocks(blocks interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptInfoByAsset", reflect.TypeOf((*MockState)(nil).ScriptInfoByAsset), assetID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNewBlocks", reflect.TypeOf((*MockState)(nil).AddNewBlocks), blocks) } -// ShouldPersistAddressTransactions mocks base method. -func (m *MockState) ShouldPersistAddressTransactions() (bool, error) { +// AddNewDeserializedBlocks mocks base method +func (m *MockState) AddNewDeserializedBlocks(blocks []*proto.Block) (*proto.Block, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ShouldPersistAddressTransactions") - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "AddNewDeserializedBlocks", blocks) + ret0, _ := ret[0].(*proto.Block) ret1, _ := ret[1].(error) return ret0, ret1 } -// ShouldPersistAddressTransactions indicates an expected call of ShouldPersistAddressTransactions. -func (mr *MockStateMockRecorder) ShouldPersistAddressTransactions() *gomock.Call { +// AddNewDeserializedBlocks indicates an expected call of AddNewDeserializedBlocks +func (mr *MockStateMockRecorder) AddNewDeserializedBlocks(blocks interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldPersistAddressTransactions", reflect.TypeOf((*MockState)(nil).ShouldPersistAddressTransactions)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNewDeserializedBlocks", reflect.TypeOf((*MockState)(nil).AddNewDeserializedBlocks), blocks) } -// StartProvidingExtendedApi mocks base method. -func (m *MockState) StartProvidingExtendedApi() error { +// AddOldBlocks mocks base method +func (m *MockState) AddOldBlocks(blocks [][]byte) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartProvidingExtendedApi") + ret := m.ctrl.Call(m, "AddOldBlocks", blocks) ret0, _ := ret[0].(error) return ret0 } -// StartProvidingExtendedApi indicates an expected call of StartProvidingExtendedApi. -func (mr *MockStateMockRecorder) StartProvidingExtendedApi() *gomock.Call { +// AddOldBlocks indicates an expected call of AddOldBlocks +func (mr *MockStateMockRecorder) AddOldBlocks(blocks interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartProvidingExtendedApi", reflect.TypeOf((*MockState)(nil).StartProvidingExtendedApi)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOldBlocks", reflect.TypeOf((*MockState)(nil).AddOldBlocks), blocks) } -// StateHashAtHeight mocks base method. -func (m *MockState) StateHashAtHeight(height uint64) (*proto.StateHash, error) { +// AddOldDeserializedBlocks mocks base method +func (m *MockState) AddOldDeserializedBlocks(blocks []*proto.Block) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StateHashAtHeight", height) - ret0, _ := ret[0].(*proto.StateHash) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "AddOldDeserializedBlocks", blocks) + ret0, _ := ret[0].(error) + return ret0 } -// StateHashAtHeight indicates an expected call of StateHashAtHeight. -func (mr *MockStateMockRecorder) StateHashAtHeight(height interface{}) *gomock.Call { +// AddOldDeserializedBlocks indicates an expected call of AddOldDeserializedBlocks +func (mr *MockStateMockRecorder) AddOldDeserializedBlocks(blocks interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateHashAtHeight", reflect.TypeOf((*MockState)(nil).StateHashAtHeight), height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOldDeserializedBlocks", reflect.TypeOf((*MockState)(nil).AddOldDeserializedBlocks), blocks) } -// TopBlock mocks base method. -func (m *MockState) TopBlock() *proto.Block { +// RollbackToHeight mocks base method +func (m *MockState) RollbackToHeight(height proto.Height) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TopBlock") - ret0, _ := ret[0].(*proto.Block) + ret := m.ctrl.Call(m, "RollbackToHeight", height) + ret0, _ := ret[0].(error) return ret0 } -// TopBlock indicates an expected call of TopBlock. -func (mr *MockStateMockRecorder) TopBlock() *gomock.Call { +// RollbackToHeight indicates an expected call of RollbackToHeight +func (mr *MockStateMockRecorder) RollbackToHeight(height interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopBlock", reflect.TypeOf((*MockState)(nil).TopBlock)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackToHeight", reflect.TypeOf((*MockState)(nil).RollbackToHeight), height) } -// TransactionByID mocks base method. -func (m *MockState) TransactionByID(id []byte) (proto.Transaction, error) { +// RollbackTo mocks base method +func (m *MockState) RollbackTo(removalEdge proto.BlockID) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransactionByID", id) - ret0, _ := ret[0].(proto.Transaction) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "RollbackTo", removalEdge) + ret0, _ := ret[0].(error) + return ret0 } -// TransactionByID indicates an expected call of TransactionByID. -func (mr *MockStateMockRecorder) TransactionByID(id interface{}) *gomock.Call { +// RollbackTo indicates an expected call of RollbackTo +func (mr *MockStateMockRecorder) RollbackTo(removalEdge interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByID", reflect.TypeOf((*MockState)(nil).TransactionByID), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackTo", reflect.TypeOf((*MockState)(nil).RollbackTo), removalEdge) } -// TransactionByIDWithStatus mocks base method. -func (m *MockState) TransactionByIDWithStatus(id []byte) (proto.Transaction, bool, error) { +// ValidateNextTx mocks base method +func (m *MockState) ValidateNextTx(tx proto.Transaction, currentTimestamp, parentTimestamp uint64, blockVersion proto.BlockVersion, acceptFailed bool) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransactionByIDWithStatus", id) - ret0, _ := ret[0].(proto.Transaction) - ret1, _ := ret[1].(bool) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret := m.ctrl.Call(m, "ValidateNextTx", tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) + ret0, _ := ret[0].(error) + return ret0 } -// TransactionByIDWithStatus indicates an expected call of TransactionByIDWithStatus. -func (mr *MockStateMockRecorder) TransactionByIDWithStatus(id interface{}) *gomock.Call { +// ValidateNextTx indicates an expected call of ValidateNextTx +func (mr *MockStateMockRecorder) ValidateNextTx(tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByIDWithStatus", reflect.TypeOf((*MockState)(nil).TransactionByIDWithStatus), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateNextTx", reflect.TypeOf((*MockState)(nil).ValidateNextTx), tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) } -// TransactionHeightByID mocks base method. -func (m *MockState) TransactionHeightByID(id []byte) (uint64, error) { +// ResetValidationList mocks base method +func (m *MockState) ResetValidationList() { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransactionHeightByID", id) - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 + m.ctrl.Call(m, "ResetValidationList") } -// TransactionHeightByID indicates an expected call of TransactionHeightByID. -func (mr *MockStateMockRecorder) TransactionHeightByID(id interface{}) *gomock.Call { +// ResetValidationList indicates an expected call of ResetValidationList +func (mr *MockStateMockRecorder) ResetValidationList() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionHeightByID", reflect.TypeOf((*MockState)(nil).TransactionHeightByID), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetValidationList", reflect.TypeOf((*MockState)(nil).ResetValidationList)) } -// TxValidation mocks base method. +// TxValidation mocks base method func (m *MockState) TxValidation(arg0 func(state.TxValidation) error) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "TxValidation", arg0) @@ -2057,67 +2059,64 @@ func (m *MockState) TxValidation(arg0 func(state.TxValidation) error) error { return ret0 } -// TxValidation indicates an expected call of TxValidation. +// TxValidation indicates an expected call of TxValidation func (mr *MockStateMockRecorder) TxValidation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxValidation", reflect.TypeOf((*MockState)(nil).TxValidation), arg0) } -// ValidateNextTx mocks base method. -func (m *MockState) ValidateNextTx(tx proto.Transaction, currentTimestamp, parentTimestamp uint64, blockVersion proto.BlockVersion, acceptFailed bool) error { +// Map mocks base method +func (m *MockState) Map(arg0 func(state.NonThreadSafeState) error) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ValidateNextTx", tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) + ret := m.ctrl.Call(m, "Map", arg0) ret0, _ := ret[0].(error) return ret0 } -// ValidateNextTx indicates an expected call of ValidateNextTx. -func (mr *MockStateMockRecorder) ValidateNextTx(tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed interface{}) *gomock.Call { +// Map indicates an expected call of Map +func (mr *MockStateMockRecorder) Map(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateNextTx", reflect.TypeOf((*MockState)(nil).ValidateNextTx), tx, currentTimestamp, parentTimestamp, blockVersion, acceptFailed) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Map", reflect.TypeOf((*MockState)(nil).Map), arg0) } -// VotesNum mocks base method. -func (m *MockState) VotesNum(featureID int16) (uint64, error) { +// StartProvidingExtendedApi mocks base method +func (m *MockState) StartProvidingExtendedApi() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "VotesNum", featureID) - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "StartProvidingExtendedApi") + ret0, _ := ret[0].(error) + return ret0 } -// VotesNum indicates an expected call of VotesNum. -func (mr *MockStateMockRecorder) VotesNum(featureID interface{}) *gomock.Call { +// StartProvidingExtendedApi indicates an expected call of StartProvidingExtendedApi +func (mr *MockStateMockRecorder) StartProvidingExtendedApi() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VotesNum", reflect.TypeOf((*MockState)(nil).VotesNum), featureID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartProvidingExtendedApi", reflect.TypeOf((*MockState)(nil).StartProvidingExtendedApi)) } -// VotesNumAtHeight mocks base method. -func (m *MockState) VotesNumAtHeight(featureID int16, height proto.Height) (uint64, error) { +// PersistAddressTransactions mocks base method +func (m *MockState) PersistAddressTransactions() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "VotesNumAtHeight", featureID, height) - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "PersistAddressTransactions") + ret0, _ := ret[0].(error) + return ret0 } -// VotesNumAtHeight indicates an expected call of VotesNumAtHeight. -func (mr *MockStateMockRecorder) VotesNumAtHeight(featureID, height interface{}) *gomock.Call { +// PersistAddressTransactions indicates an expected call of PersistAddressTransactions +func (mr *MockStateMockRecorder) PersistAddressTransactions() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VotesNumAtHeight", reflect.TypeOf((*MockState)(nil).VotesNumAtHeight), featureID, height) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PersistAddressTransactions", reflect.TypeOf((*MockState)(nil).PersistAddressTransactions)) } -// WavesAddressesNumber mocks base method. -func (m *MockState) WavesAddressesNumber() (uint64, error) { +// Close mocks base method +func (m *MockState) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WavesAddressesNumber") - ret0, _ := ret[0].(uint64) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 } -// WavesAddressesNumber indicates an expected call of WavesAddressesNumber. -func (mr *MockStateMockRecorder) WavesAddressesNumber() *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockStateMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WavesAddressesNumber", reflect.TypeOf((*MockState)(nil).WavesAddressesNumber)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockState)(nil).Close)) } diff --git a/pkg/node/node.go b/pkg/node/node.go index 42e973b2b7..8ec22dc0d6 100644 --- a/pkg/node/node.go +++ b/pkg/node/node.go @@ -101,12 +101,12 @@ func (a *Node) Serve(ctx context.Context) error { } } -func (a *Node) logErrors(err error) { +func (a *Node) logErrors(fsm state_fsm.FSM, err error) { switch e := err.(type) { case *proto.InfoMsg: - zap.S().Debug(e.Error()) + zap.S().Debugf("[%s] %s", fsm.String(), e.Error()) default: - zap.S().Error(e.Error()) + zap.S().Errorf("[%s] %s", fsm.String(), e.Error()) } } @@ -165,7 +165,7 @@ func (a *Node) Run(ctx context.Context, p peer.Parent, InternalMessageCh chan me default: } default: - zap.S().Errorf("unknown internalMess %T", t) + zap.S().Errorf("[%s] Unknown internal message '%T'", fsm.String(), t) continue } case task := <-tasksCh: @@ -178,19 +178,18 @@ func (a *Node) Run(ctx context.Context, p peer.Parent, InternalMessageCh chan me fsm, async, err = fsm.PeerError(m.Peer, t) } case mess := <-p.MessageCh: - zap.S().Debugf("received proto Message %T", mess.Message) + zap.S().Debugf("[%s] Network message '%T' received", fsm.String(), mess.Message) action, ok := actions[reflect.TypeOf(mess.Message)] if !ok { - zap.S().Errorf("unknown proto Message %T", mess.Message) + zap.S().Errorf("[%s] Unknown network message '%T'", fsm.String(), mess.Message) continue } fsm, async, err = action(a.services, mess, fsm) } if err != nil { - a.logErrors(err) + a.logErrors(fsm, err) } spawnAsync(ctx, tasksCh, a.services.LoggableRunner, async) - zap.S().Debugf("FSM %T", fsm) } } diff --git a/pkg/node/peer_manager/peer_manager.go b/pkg/node/peer_manager/peer_manager.go index 5688f401ad..0008db7667 100644 --- a/pkg/node/peer_manager/peer_manager.go +++ b/pkg/node/peer_manager/peer_manager.go @@ -2,13 +2,13 @@ package peer_manager import ( "context" - "github.com/wavesplatform/gowaves/pkg/node/peer_manager/storage" "math/big" "net" - "sort" "sync" "time" + "github.com/wavesplatform/gowaves/pkg/node/peer_manager/storage" + "github.com/pkg/errors" "github.com/wavesplatform/gowaves/pkg/p2p/peer" "github.com/wavesplatform/gowaves/pkg/proto" @@ -29,12 +29,6 @@ func newPeerInfo(peer peer.Peer) peerInfo { } } -type byScore []peerInfo - -func (a byScore) Len() int { return len(a) } -func (a byScore) Less(i, j int) bool { return a[i].score.Cmp(a[j].score) < 0 } -func (a byScore) Swap(i, j int) { a[i], a[j] = a[j], a[i] } - type PeerManager interface { Connected(peer.Peer) (peer.Peer, bool) NewConnection(peer.Peer) error @@ -45,7 +39,6 @@ type PeerManager interface { Suspend(peer peer.Peer, suspendTime time.Time, reason string) Suspended() []storage.SuspendedPeer AddConnected(peer.Peer) - PeerWithHighestScore() (peer.Peer, *big.Int, bool) UpdateScore(p peer.Peer, score *proto.Score) error UpdateKnownPeers([]storage.KnownPeer) error KnownPeers() []storage.KnownPeer @@ -71,10 +64,11 @@ type PeerManagerImpl struct { connectPeers bool // spawn outgoing limitConnections int version proto.Version + networkName string } func NewPeerManager(spawner PeerSpawner, storage PeerStorage, - limitConnections int, version proto.Version) *PeerManagerImpl { + limitConnections int, version proto.Version, networkName string) *PeerManagerImpl { return &PeerManagerImpl{ spawner: spawner, @@ -84,6 +78,7 @@ func NewPeerManager(spawner PeerSpawner, storage PeerStorage, connectPeers: true, limitConnections: limitConnections, version: version, + networkName: networkName, } } @@ -130,7 +125,7 @@ func (a *PeerManagerImpl) NewConnection(p peer.Peer) error { } if a.IsSuspended(p) { _ = p.Close() - return errors.New("peer is suspended") + return errors.Errorf("peer '%s' is suspended", p.ID()) } if p.Handshake().Version.CmpMinor(a.version) >= 2 { err := errors.Errorf( @@ -142,7 +137,13 @@ func (a *PeerManagerImpl) NewConnection(p peer.Peer) error { _ = p.Close() return proto.NewInfoMsg(err) } - + if p.Handshake().AppName != a.networkName { + err := errors.Errorf("peer '%s' has the invalid network name '%s', required '%s'", + p.ID(), p.Handshake().AppName, a.networkName) + a.Suspend(p, time.Now(), err.Error()) + _ = p.Close() + return proto.NewInfoMsg(err) + } in, out := a.InOutCount() switch p.Direction() { case peer.Incoming: @@ -194,33 +195,15 @@ func (a *PeerManagerImpl) AddConnected(peer peer.Peer) { a.active[peer] = newPeerInfo(peer) } -func (a *PeerManagerImpl) PeerWithHighestScore() (peer.Peer, *big.Int, bool) { - a.mu.RLock() - defer a.mu.RUnlock() - - if len(a.active) == 0 { - return nil, nil, false - } - - peers := make([]peerInfo, 0) - for _, p := range a.active { - peers = append(peers, p) - } - - sort.Sort(byScore(peers)) - - highest := peers[len(peers)-1] - return highest.peer, highest.score, true -} - func (a *PeerManagerImpl) UpdateScore(p peer.Peer, score *big.Int) error { a.mu.Lock() defer a.mu.Unlock() if row, ok := a.active[p]; ok { row.score = score a.active[p] = row + return nil } - return nil + return errors.Errorf("peer '%s' is not active", p.ID()) } func (a *PeerManagerImpl) IsSuspended(p peer.Peer) bool { diff --git a/pkg/node/state_fsm/fsm.go b/pkg/node/state_fsm/fsm.go index 63ec1b7d0a..2015213534 100644 --- a/pkg/node/state_fsm/fsm.go +++ b/pkg/node/state_fsm/fsm.go @@ -95,6 +95,8 @@ type FSM interface { Transaction(p peer.Peer, t proto.Transaction) (FSM, Async, error) Halt() (FSM, Async, error) + + String() string } func NewFsm( diff --git a/pkg/node/state_fsm/fsm_common.go b/pkg/node/state_fsm/fsm_common.go index c8d1b8fbd6..a8e4338a86 100644 --- a/pkg/node/state_fsm/fsm_common.go +++ b/pkg/node/state_fsm/fsm_common.go @@ -2,13 +2,13 @@ package state_fsm import ( "github.com/wavesplatform/gowaves/pkg/node/peer_manager" - . "github.com/wavesplatform/gowaves/pkg/p2p/peer" + "github.com/wavesplatform/gowaves/pkg/p2p/peer" "github.com/wavesplatform/gowaves/pkg/proto" "github.com/wavesplatform/gowaves/pkg/state" "go.uber.org/zap" ) -func newPeer(fsm FSM, p Peer, peers peer_manager.PeerManager) (FSM, Async, error) { +func newPeer(fsm FSM, p peer.Peer, peers peer_manager.PeerManager) (FSM, Async, error) { err := peers.NewConnection(p) if err != nil { return fsm, nil, proto.NewInfoMsg(err) @@ -17,7 +17,7 @@ func newPeer(fsm FSM, p Peer, peers peer_manager.PeerManager) (FSM, Async, error } // TODO handle no peers -func peerError(fsm FSM, p Peer, peers peer_manager.PeerManager, _ error) (FSM, Async, error) { +func peerError(fsm FSM, p peer.Peer, peers peer_manager.PeerManager, _ error) (FSM, Async, error) { peers.Disconnect(p) return fsm, nil, nil } @@ -26,24 +26,7 @@ func noop(fsm FSM) (FSM, Async, error) { return fsm, nil, nil } -func handleScore(fsm FSM, info BaseInfo, p Peer, score *proto.Score) (FSM, Async, error) { - err := info.peers.UpdateScore(p, score) - if err != nil { - return fsm, nil, err - } - - myScore, err := info.storage.CurrentScore() - if err != nil { - return NewIdleFsm(info), nil, err - } - - if score.Cmp(myScore) == 1 { // remote score > my score - return NewIdleToSyncTransition(info, p) - } - return fsm, nil, nil -} - -func sendScore(p Peer, storage state.State) { +func sendScore(p peer.Peer, storage state.State) { curScore, err := storage.CurrentScore() if err != nil { zap.S().Error(err) @@ -53,13 +36,3 @@ func sendScore(p Peer, storage state.State) { bts := curScore.Bytes() p.SendMessage(&proto.ScoreMessage{Score: bts}) } - -// TODO send micro block -//func handleMineMicro(a FromBaseInfo, base BaseInfo, minedBlock *proto.Block, rest miner.MiningLimits, blocks ng.Blocks, keyPair proto.KeyPair) (FSM, Async, error) { -// block, micro, rest, err := base.microMiner.Micro(rest, minedBlock, blocks, keyPair) -// if err != nil { -// return a, nil, err -// } -// base. -// return a.FromBaseInfo() -//} diff --git a/pkg/node/state_fsm/fsm_halt.go b/pkg/node/state_fsm/fsm_halt.go index f7a2b33b3d..dd0777f1d6 100644 --- a/pkg/node/state_fsm/fsm_halt.go +++ b/pkg/node/state_fsm/fsm_halt.go @@ -54,6 +54,10 @@ func (a HaltFSM) MicroBlockInv(p peer.Peer, inv *proto.MicroBlockInv) (FSM, Asyn return noop(a) } +func (a HaltFSM) String() string { + return "Halt" +} + func HaltTransition(info BaseInfo) (FSM, Async, error) { zap.S().Debugf("started HaltTransition ") info.peers.Close() diff --git a/pkg/node/state_fsm/fsm_idle.go b/pkg/node/state_fsm/fsm_idle.go index 835451b2e9..11c86f8948 100644 --- a/pkg/node/state_fsm/fsm_idle.go +++ b/pkg/node/state_fsm/fsm_idle.go @@ -1,10 +1,15 @@ package state_fsm import ( + "time" + "github.com/pkg/errors" + "github.com/wavesplatform/gowaves/pkg/libs/signatures" "github.com/wavesplatform/gowaves/pkg/metrics" - . "github.com/wavesplatform/gowaves/pkg/node/state_fsm/tasks" + "github.com/wavesplatform/gowaves/pkg/node/state_fsm/sync_internal" + "github.com/wavesplatform/gowaves/pkg/node/state_fsm/tasks" "github.com/wavesplatform/gowaves/pkg/p2p/peer" + "github.com/wavesplatform/gowaves/pkg/p2p/peer/extension" "github.com/wavesplatform/gowaves/pkg/proto" "github.com/wavesplatform/gowaves/pkg/types" "go.uber.org/zap" @@ -43,18 +48,18 @@ func (a *IdleFsm) MicroBlockInv(_ peer.Peer, _ *proto.MicroBlockInv) (FSM, Async return a.baseInfo.d.Noop(a) } -func (a *IdleFsm) Task(task AsyncTask) (FSM, Async, error) { - zap.S().Debugf("IdleFsm Task: got task type %d, data %+v", task.TaskType, task.Data) +func (a *IdleFsm) Task(task tasks.AsyncTask) (FSM, Async, error) { switch task.TaskType { - case Ping: + case tasks.Ping: return noop(a) - case AskPeers: + case tasks.AskPeers: + zap.S().Debug("[Idle] Requesting peers") a.baseInfo.peers.AskPeers() return a, nil, nil - case MineMicro: // Do nothing + case tasks.MineMicro: // Do nothing return a, nil, nil default: - return a, nil, errors.Errorf("IdleFsm Task: unknown task type %d, data %+v", task.TaskType, task.Data) + return a, nil, errors.Errorf("unexpected internal task '%d' with data '%+v' received by %s FSM", task.TaskType, task.Data, a.String()) } } @@ -66,12 +71,6 @@ func (a *IdleFsm) BlockIDs(_ peer.Peer, _ []proto.BlockID) (FSM, Async, error) { return a.baseInfo.d.Noop(a) } -func NewIdleFsm(info BaseInfo) *IdleFsm { - return &IdleFsm{ - baseInfo: info, - } -} - func (a *IdleFsm) NewPeer(p peer.Peer) (FSM, Async, error) { fsm, as, err := newPeer(a, p, a.baseInfo.peers) if a.baseInfo.peers.ConnectedCount() == a.baseInfo.minPeersMining { @@ -83,9 +82,39 @@ func (a *IdleFsm) NewPeer(p peer.Peer) (FSM, Async, error) { func (a *IdleFsm) Score(p peer.Peer, score *proto.Score) (FSM, Async, error) { metrics.FSMScore("idle", score, p.Handshake().NodeName) - return handleScore(a, a.baseInfo, p, score) + if err := a.baseInfo.peers.UpdateScore(p, score); err != nil { + return a, nil, err + } + nodeScore, err := a.baseInfo.storage.CurrentScore() + if err != nil { + return a, nil, err + } + if score.Cmp(nodeScore) == 1 { + lastSignatures, err := signatures.LastSignaturesImpl{}.LastBlockIDs(a.baseInfo.storage) + if err != nil { + return a, nil, err + } + internal := sync_internal.InternalFromLastSignatures(extension.NewPeerExtension(p, a.baseInfo.scheme), lastSignatures) + c := conf{ + peerSyncWith: p, + timeout: 30 * time.Second, + } + zap.S().Debugf("[Idle] Starting synchronisation with peer '%s'", p.ID()) + return NewSyncFsm(a.baseInfo, c.Now(a.baseInfo.tm), internal) + } + return noop(a) } func (a *IdleFsm) Block(_ peer.Peer, _ *proto.Block) (FSM, Async, error) { return noop(a) } + +func (a *IdleFsm) String() string { + return "Idle" +} + +func NewIdleFsm(info BaseInfo) *IdleFsm { + return &IdleFsm{ + baseInfo: info, + } +} diff --git a/pkg/node/state_fsm/fsm_ng.go b/pkg/node/state_fsm/fsm_ng.go index 46f4b3ae79..d3e8c91b53 100644 --- a/pkg/node/state_fsm/fsm_ng.go +++ b/pkg/node/state_fsm/fsm_ng.go @@ -4,26 +4,29 @@ import ( "time" "github.com/pkg/errors" + "github.com/wavesplatform/gowaves/pkg/libs/signatures" "github.com/wavesplatform/gowaves/pkg/metrics" "github.com/wavesplatform/gowaves/pkg/miner" + "github.com/wavesplatform/gowaves/pkg/node/state_fsm/sync_internal" . "github.com/wavesplatform/gowaves/pkg/node/state_fsm/tasks" "github.com/wavesplatform/gowaves/pkg/p2p/peer" + "github.com/wavesplatform/gowaves/pkg/p2p/peer/extension" "github.com/wavesplatform/gowaves/pkg/proto" "github.com/wavesplatform/gowaves/pkg/state" "go.uber.org/zap" ) type NGFsm struct { - BaseInfo + baseInfo BaseInfo blocksCache blockStatesCache } func (a *NGFsm) Transaction(p peer.Peer, t proto.Transaction) (FSM, Async, error) { - err := a.utx.Add(t) + err := a.baseInfo.utx.Add(t) if err != nil { return a, nil, proto.NewInfoMsg(err) } - a.BroadcastTransaction(t, p) + a.baseInfo.BroadcastTransaction(t, p) return a, nil, nil } @@ -32,53 +35,75 @@ func (a *NGFsm) Task(task AsyncTask) (FSM, Async, error) { case Ping: return noop(a) case AskPeers: - a.peers.AskPeers() + zap.S().Debug("[NG] Requesting peers") + a.baseInfo.peers.AskPeers() return a, nil, nil case MineMicro: + zap.S().Debug("[NG] Generating micro-block") t := task.Data.(MineMicroTaskData) return a.mineMicro(t.Block, t.Limits, t.KeyPair, t.Vrf) default: - return a, nil, errors.Errorf("NGFsm Task: unknown task type %d, data %+v", task.TaskType, task.Data) + return a, nil, errors.Errorf("unexpected internal task '%d' with data '%+v' received by %s FSM", task.TaskType, task.Data, a.String()) } } func (a *NGFsm) Halt() (FSM, Async, error) { - return HaltTransition(a.BaseInfo) + return HaltTransition(a.baseInfo) } func NewNGFsm12(info BaseInfo) *NGFsm { return &NGFsm{ - BaseInfo: info, + baseInfo: info, blocksCache: blockStatesCache{blockStates: map[proto.BlockID]proto.Block{}}, } } func (a *NGFsm) NewPeer(p peer.Peer) (FSM, Async, error) { - fsm, as, err := newPeer(a, p, a.peers) - if a.peers.ConnectedCount() == a.minPeersMining { - a.Reschedule() + fsm, as, err := newPeer(a, p, a.baseInfo.peers) + if a.baseInfo.peers.ConnectedCount() == a.baseInfo.minPeersMining { + a.baseInfo.Reschedule() } - sendScore(p, a.storage) + sendScore(p, a.baseInfo.storage) return fsm, as, err } func (a *NGFsm) PeerError(p peer.Peer, e error) (FSM, Async, error) { - return peerError(a, p, a.peers, e) + return peerError(a, p, a.baseInfo.peers, e) } func (a *NGFsm) Score(p peer.Peer, score *proto.Score) (FSM, Async, error) { metrics.FSMScore("ng", score, p.Handshake().NodeName) - return handleScore(a, a.BaseInfo, p, score) + if err := a.baseInfo.peers.UpdateScore(p, score); err != nil { + return a, nil, err + } + nodeScore, err := a.baseInfo.storage.CurrentScore() + if err != nil { + return a, nil, err + } + if score.Cmp(nodeScore) == 1 { + lastSignatures, err := signatures.LastSignaturesImpl{}.LastBlockIDs(a.baseInfo.storage) + if err != nil { + return a, nil, err + } + internal := sync_internal.InternalFromLastSignatures(extension.NewPeerExtension(p, a.baseInfo.scheme), lastSignatures) + c := conf{ + peerSyncWith: p, + timeout: 30 * time.Second, + } + zap.S().Debugf("[NG] Higher score received, starting synchronisation with peer '%s'", p.ID()) + return NewSyncFsm(a.baseInfo, c.Now(a.baseInfo.tm), internal) + } + return noop(a) } func (a *NGFsm) rollbackToStateFromCache(blockFromCache *proto.Block) error { previousBlockID := blockFromCache.Parent - err := a.storage.RollbackTo(previousBlockID) + err := a.baseInfo.storage.RollbackTo(previousBlockID) if err != nil { return errors.Wrapf(err, "failed to rollback to parent block '%s' of cached block '%s'", previousBlockID.String(), blockFromCache.ID.String()) } - _, err = a.blocksApplier.Apply(a.storage, []*proto.Block{blockFromCache}) + _, err = a.baseInfo.blocksApplier.Apply(a.baseInfo.storage, []*proto.Block{blockFromCache}) if err != nil { return err } @@ -86,7 +111,7 @@ func (a *NGFsm) rollbackToStateFromCache(blockFromCache *proto.Block) error { } func (a *NGFsm) Block(peer peer.Peer, block *proto.Block) (FSM, Async, error) { - ok, err := a.blocksApplier.BlockExists(a.storage, block) + ok, err := a.baseInfo.blocksApplier.BlockExists(a.baseInfo.storage, block) if err != nil { return a, nil, err } @@ -96,7 +121,7 @@ func (a *NGFsm) Block(peer peer.Peer, block *proto.Block) (FSM, Async, error) { metrics.FSMKeyBlockReceived("ng", block, peer.Handshake().NodeName) - top := a.storage.TopBlock() + top := a.baseInfo.storage.TopBlock() if top.BlockID() != block.Parent { // does block refer to last block zap.S().Debugf("Key-block '%s' has parent '%s' which is not the top block '%s'", block.ID.String(), block.Parent.String(), top.ID.String()) @@ -109,7 +134,7 @@ func (a *NGFsm) Block(peer peer.Peer, block *proto.Block) (FSM, Async, error) { } } - _, err = a.blocksApplier.Apply(a.storage, []*proto.Block{block}) + _, err = a.baseInfo.blocksApplier.Apply(a.baseInfo.storage, []*proto.Block{block}) if err != nil { metrics.FSMKeyBlockDeclined("ng", block, err) return a, nil, err @@ -119,18 +144,18 @@ func (a *NGFsm) Block(peer peer.Peer, block *proto.Block) (FSM, Async, error) { a.blocksCache.Clear() a.blocksCache.AddBlockState(block) - a.Scheduler.Reschedule() - a.actions.SendScore(a.storage) - a.CleanUtx() + a.baseInfo.Scheduler.Reschedule() + a.baseInfo.actions.SendScore(a.baseInfo.storage) + a.baseInfo.CleanUtx() - return NewNGFsm12(a.BaseInfo), nil, nil + return NewNGFsm12(a.baseInfo), nil, nil } func (a *NGFsm) MinedBlock(block *proto.Block, limits proto.MiningLimits, keyPair proto.KeyPair, vrf []byte) (FSM, Async, error) { metrics.FSMKeyBlockGenerated("ng", block) - err := a.storage.Map(func(state state.NonThreadSafeState) error { + err := a.baseInfo.storage.Map(func(state state.NonThreadSafeState) error { var err error - _, err = a.blocksApplier.Apply(state, []*proto.Block{block}) + _, err = a.baseInfo.blocksApplier.Apply(state, []*proto.Block{block}) return err }) if err != nil { @@ -138,17 +163,18 @@ func (a *NGFsm) MinedBlock(block *proto.Block, limits proto.MiningLimits, keyPai metrics.FSMKeyBlockDeclined("ng", block, err) return a, nil, err } + zap.S().Infof("Key block '%s' generated and applied", block.ID.String()) metrics.FSMKeyBlockApplied("ng", block) a.blocksCache.Clear() a.blocksCache.AddBlockState(block) - a.Reschedule() - a.actions.SendBlock(block) - a.actions.SendScore(a.storage) - a.CleanUtx() + a.baseInfo.Reschedule() + a.baseInfo.actions.SendBlock(block) + a.baseInfo.actions.SendScore(a.baseInfo.storage) + a.baseInfo.CleanUtx() - return NewNGFsm12(a.BaseInfo), Tasks(NewMineMicroTask(1*time.Second, block, limits, keyPair, vrf)), nil + return NewNGFsm12(a.baseInfo), Tasks(NewMineMicroTask(1*time.Second, block, limits, keyPair, vrf)), nil } func (a *NGFsm) BlockIDs(_ peer.Peer, _ []proto.BlockID) (FSM, Async, error) { @@ -163,17 +189,17 @@ func (a *NGFsm) MicroBlock(p peer.Peer, micro *proto.MicroBlock) (FSM, Async, er metrics.FSMMicroBlockDeclined("ng", micro, err) return a, nil, err } - a.MicroBlockCache.Add(block.BlockID(), micro) + a.baseInfo.MicroBlockCache.Add(block.BlockID(), micro) a.blocksCache.AddBlockState(block) - a.BaseInfo.Reschedule() + a.baseInfo.Reschedule() // Notify all connected peers about new microblock, send them microblock inv network message - inv, ok := a.MicroBlockInvCache.Get(block.BlockID()) + inv, ok := a.baseInfo.MicroBlockInvCache.Get(block.BlockID()) if ok { invBts, err := inv.MarshalBinary() if err == nil { //TODO: We have to exclude from recipients peers that already have this microblock - a.peers.EachConnected(func(p peer.Peer, score *proto.Score) { + a.baseInfo.peers.EachConnected(func(p peer.Peer, score *proto.Score) { p.SendMessage( &proto.MicroBlockInvMessage{ Body: invBts, @@ -189,7 +215,7 @@ func (a *NGFsm) MicroBlock(p peer.Peer, micro *proto.MicroBlock) (FSM, Async, er // New microblock generated by miner func (a *NGFsm) mineMicro(minedBlock *proto.Block, rest proto.MiningLimits, keyPair proto.KeyPair, vrf []byte) (FSM, Async, error) { - block, micro, rest, err := a.microMiner.Micro(minedBlock, rest, keyPair) + block, micro, rest, err := a.baseInfo.microMiner.Micro(minedBlock, rest, keyPair) if err == miner.NoTransactionsErr { return a, Tasks(NewMineMicroTask(5*time.Second, minedBlock, rest, keyPair, vrf)), nil } @@ -200,21 +226,21 @@ func (a *NGFsm) mineMicro(minedBlock *proto.Block, rest proto.MiningLimits, keyP return a, nil, errors.Wrap(err, "NGFsm.mineMicro") } metrics.FSMMicroBlockGenerated("ng", micro) - err = a.storage.Map(func(s state.NonThreadSafeState) error { - _, err := a.blocksApplier.ApplyMicro(s, block) + err = a.baseInfo.storage.Map(func(s state.NonThreadSafeState) error { + _, err := a.baseInfo.blocksApplier.ApplyMicro(s, block) return err }) if err != nil { return a, nil, err } a.blocksCache.AddBlockState(block) - a.Reschedule() + a.baseInfo.Reschedule() metrics.FSMMicroBlockApplied("ng", micro) inv := proto.NewUnsignedMicroblockInv( micro.SenderPK, block.BlockID(), micro.Reference) - err = inv.Sign(keyPair.Secret, a.scheme) + err = inv.Sign(keyPair.Secret, a.baseInfo.scheme) if err != nil { return a, nil, err } @@ -223,10 +249,10 @@ func (a *NGFsm) mineMicro(minedBlock *proto.Block, rest proto.MiningLimits, keyP return a, nil, err } - a.MicroBlockCache.Add(block.BlockID(), micro) - a.MicroBlockInvCache.Add(block.BlockID(), inv) + a.baseInfo.MicroBlockCache.Add(block.BlockID(), micro) + a.baseInfo.MicroBlockInvCache.Add(block.BlockID(), inv) // TODO wrap - a.peers.EachConnected(func(p peer.Peer, score *proto.Score) { + a.baseInfo.peers.EachConnected(func(p peer.Peer, score *proto.Score) { p.SendMessage( &proto.MicroBlockInvMessage{ Body: invBts, @@ -239,13 +265,13 @@ func (a *NGFsm) mineMicro(minedBlock *proto.Block, rest proto.MiningLimits, keyP // Check than microblock is appendable and append it func (a *NGFsm) checkAndAppendMicroblock(micro *proto.MicroBlock) (*proto.Block, error) { - top := a.storage.TopBlock() // Get the last block + top := a.baseInfo.storage.TopBlock() // Get the last block if top.BlockID() != micro.Reference { // Microblock doesn't refer to last block err := errors.Errorf("microblock TBID '%s' refer to block ID '%s' but last block ID is '%s'", micro.TotalBlockID.String(), micro.Reference.String(), top.BlockID().String()) metrics.FSMMicroBlockDeclined("ng", micro, err) return &proto.Block{}, proto.NewInfoMsg(err) } - ok, err := micro.VerifySignature(a.scheme) + ok, err := micro.VerifySignature(a.baseInfo.scheme) if err != nil { return nil, err } @@ -253,24 +279,24 @@ func (a *NGFsm) checkAndAppendMicroblock(micro *proto.MicroBlock) (*proto.Block, return nil, errors.Errorf("microblock '%s' has invalid signature", micro.TotalBlockID.String()) } newTrs := top.Transactions.Join(micro.Transactions) - newBlock, err := proto.CreateBlock(newTrs, top.Timestamp, top.Parent, top.GenPublicKey, top.NxtConsensus, top.Version, top.Features, top.RewardVote, a.scheme) + newBlock, err := proto.CreateBlock(newTrs, top.Timestamp, top.Parent, top.GenPublicKey, top.NxtConsensus, top.Version, top.Features, top.RewardVote, a.baseInfo.scheme) if err != nil { return nil, err } newBlock.BlockSignature = micro.TotalResBlockSigField - ok, err = newBlock.VerifySignature(a.scheme) + ok, err = newBlock.VerifySignature(a.baseInfo.scheme) if err != nil { return nil, err } if !ok { return nil, errors.New("incorrect signature for applied microblock") } - err = newBlock.GenerateBlockID(a.scheme) + err = newBlock.GenerateBlockID(a.baseInfo.scheme) if err != nil { return nil, errors.Wrap(err, "NGFsm microBlockByID: failed generate block id") } - err = a.storage.Map(func(state state.State) error { - _, err := a.blocksApplier.ApplyMicro(state, newBlock) + err = a.baseInfo.storage.Map(func(state state.State) error { + _, err := a.baseInfo.blocksApplier.ApplyMicro(state, newBlock) return err }) if err != nil { @@ -283,11 +309,15 @@ func (a *NGFsm) checkAndAppendMicroblock(micro *proto.MicroBlock) (*proto.Block, func (a *NGFsm) MicroBlockInv(p peer.Peer, inv *proto.MicroBlockInv) (FSM, Async, error) { metrics.MicroBlockInv(inv, p.Handshake().NodeName) - a.invRequester.Request(p, inv.TotalBlockID.Bytes()) - a.MicroBlockInvCache.Add(inv.TotalBlockID, inv) + a.baseInfo.invRequester.Request(p, inv.TotalBlockID.Bytes()) + a.baseInfo.MicroBlockInvCache.Add(inv.TotalBlockID, inv) return a, nil, nil } +func (a *NGFsm) String() string { + return "NG" +} + func MinedBlockNgTransition(info BaseInfo, block *proto.Block, limits proto.MiningLimits, keyPair proto.KeyPair, vrf []byte) (FSM, Async, error) { return NewNGFsm12(info).MinedBlock(block, limits, keyPair, vrf) } diff --git a/pkg/node/state_fsm/fsm_persist.go b/pkg/node/state_fsm/fsm_persist.go index e78d05646e..aebb03887f 100644 --- a/pkg/node/state_fsm/fsm_persist.go +++ b/pkg/node/state_fsm/fsm_persist.go @@ -64,6 +64,10 @@ func (a *PersistFsm) Halt() (FSM, Async, error) { return HaltTransition(a.BaseInfo) } +func (a *PersistFsm) String() string { + return "Persist" +} + func NewPersistTransition(info BaseInfo) (FSM, Async, error) { t := tasks.NewFuncTask(func(ctx context.Context, output chan tasks.AsyncTask) error { err := info.storage.PersistAddressTransactions() diff --git a/pkg/node/state_fsm/fsm_sync.go b/pkg/node/state_fsm/fsm_sync.go index fc6d227fa7..131c1a6594 100644 --- a/pkg/node/state_fsm/fsm_sync.go +++ b/pkg/node/state_fsm/fsm_sync.go @@ -5,40 +5,49 @@ import ( "github.com/pkg/errors" "github.com/wavesplatform/gowaves/pkg/errs" - "github.com/wavesplatform/gowaves/pkg/libs/signatures" "github.com/wavesplatform/gowaves/pkg/metrics" "github.com/wavesplatform/gowaves/pkg/node/state_fsm/sync_internal" - . "github.com/wavesplatform/gowaves/pkg/node/state_fsm/tasks" - . "github.com/wavesplatform/gowaves/pkg/p2p/peer" + "github.com/wavesplatform/gowaves/pkg/node/state_fsm/tasks" + "github.com/wavesplatform/gowaves/pkg/p2p/peer" "github.com/wavesplatform/gowaves/pkg/p2p/peer/extension" "github.com/wavesplatform/gowaves/pkg/proto" "github.com/wavesplatform/gowaves/pkg/state" + "github.com/wavesplatform/gowaves/pkg/types" "go.uber.org/zap" ) type conf struct { - peerSyncWith Peer + peerSyncWith peer.Peer // if nothing happens more than N duration, means we stalled, so go to idle and again lastReceiveTime time.Time timeout time.Duration } -func (c conf) Now() conf { +func (c conf) Now(tm types.Time) conf { return conf{ peerSyncWith: c.peerSyncWith, - lastReceiveTime: time.Now(), + lastReceiveTime: tm.Now(), timeout: c.timeout, } } +type noopWrapper struct { +} + +func (noopWrapper) AskBlocksIDs([]proto.BlockID) { +} + +func (noopWrapper) AskBlock(proto.BlockID) { +} + type SyncFsm struct { baseInfo BaseInfo conf conf internal sync_internal.Internal } -func (a *SyncFsm) Transaction(p Peer, t proto.Transaction) (FSM, Async, error) { +func (a *SyncFsm) Transaction(p peer.Peer, t proto.Transaction) (FSM, Async, error) { err := a.baseInfo.utx.Add(t) if err != nil { return a, nil, proto.NewInfoMsg(err) @@ -48,44 +57,37 @@ func (a *SyncFsm) Transaction(p Peer, t proto.Transaction) (FSM, Async, error) { } // MicroBlock ignores new microblocks while syncing. -func (a *SyncFsm) MicroBlock(_ Peer, _ *proto.MicroBlock) (FSM, Async, error) { +func (a *SyncFsm) MicroBlock(_ peer.Peer, _ *proto.MicroBlock) (FSM, Async, error) { return a.baseInfo.d.Noop(a) } // MicroBlockInv ignores microblock requests while syncing. -func (a *SyncFsm) MicroBlockInv(_ Peer, _ *proto.MicroBlockInv) (FSM, Async, error) { +func (a *SyncFsm) MicroBlockInv(_ peer.Peer, _ *proto.MicroBlockInv) (FSM, Async, error) { return a.baseInfo.d.Noop(a) } -func (a *SyncFsm) Task(task AsyncTask) (FSM, Async, error) { - zap.S().Debugf("SyncFsm Task: got task type %d, data %+v", task.TaskType, task.Data) +func (a *SyncFsm) Task(task tasks.AsyncTask) (FSM, Async, error) { switch task.TaskType { - case AskPeers: + case tasks.AskPeers: + zap.S().Debug("[Sync] Requesting peers") a.baseInfo.peers.AskPeers() return a, nil, nil - case Ping: + case tasks.Ping: + zap.S().Debug("[Sync] Checking timeout") timeout := a.conf.lastReceiveTime.Add(a.conf.timeout).Before(a.baseInfo.tm.Now()) if timeout { + zap.S().Debugf("[Sync] Timeout (%s) while syncronisation with peer '%s'", a.conf.timeout.String(), a.conf.peerSyncWith.ID()) return NewIdleFsm(a.baseInfo), nil, TimeoutErr } return a, nil, nil - case MineMicro: // Do nothing + case tasks.MineMicro: return a, nil, nil default: - return a, nil, errors.Errorf("SyncFsm Task: unknown task type %d, data %+v", task.TaskType, task.Data) + return a, nil, errors.Errorf("unexpected internal task '%d' with data '%+v' received by %s FSM", task.TaskType, task.Data, a.String()) } } -type noopWrapper struct { -} - -func (noopWrapper) AskBlocksIDs([]proto.BlockID) { -} - -func (noopWrapper) AskBlock(proto.BlockID) { -} - -func (a *SyncFsm) PeerError(p Peer, _ error) (FSM, Async, error) { +func (a *SyncFsm) PeerError(p peer.Peer, _ error) (FSM, Async, error) { a.baseInfo.peers.Disconnect(p) if a.conf.peerSyncWith == p { _, blocks, _ := a.internal.Blocks(noopWrapper{}) @@ -100,7 +102,7 @@ func (a *SyncFsm) PeerError(p Peer, _ error) (FSM, Async, error) { return a, nil, nil } -func (a *SyncFsm) BlockIDs(peer Peer, signatures []proto.BlockID) (FSM, Async, error) { +func (a *SyncFsm) BlockIDs(peer peer.Peer, signatures []proto.BlockID) (FSM, Async, error) { if a.conf.peerSyncWith != peer { return a, nil, nil } @@ -110,7 +112,7 @@ func (a *SyncFsm) BlockIDs(peer Peer, signatures []proto.BlockID) (FSM, Async, e } if internal.RequestedCount() > 0 { // Blocks were requested waiting for them to receive and apply - return newSyncFsm(a.baseInfo, a.conf.Now(), internal), nil, nil + return newSyncFsm(a.baseInfo, a.conf.Now(a.baseInfo.tm), internal), nil, nil } // No blocks were request, switching to NG working mode err = a.baseInfo.storage.StartProvidingExtendedApi() @@ -120,7 +122,7 @@ func (a *SyncFsm) BlockIDs(peer Peer, signatures []proto.BlockID) (FSM, Async, e return NewNGFsm12(a.baseInfo), nil, nil } -func (a *SyncFsm) NewPeer(p Peer) (FSM, Async, error) { +func (a *SyncFsm) NewPeer(p peer.Peer) (FSM, Async, error) { err := a.baseInfo.peers.NewConnection(p) if err != nil { return a, nil, proto.NewInfoMsg(err) @@ -128,27 +130,45 @@ func (a *SyncFsm) NewPeer(p Peer) (FSM, Async, error) { return a, nil, nil } -func (a *SyncFsm) Score(p Peer, score *proto.Score) (FSM, Async, error) { - // TODO handle new max score +func (a *SyncFsm) Score(p peer.Peer, score *proto.Score) (FSM, Async, error) { metrics.FSMScore("sync", score, p.Handshake().NodeName) - err := a.baseInfo.peers.UpdateScore(p, score) - if err != nil { + if err := a.baseInfo.peers.UpdateScore(p, score); err != nil { return a, nil, err } - return a, nil, nil + //TODO: Handle new higher score + /* + nodeScore, err := a.baseInfo.storage.CurrentScore() + if err != nil { + return a, nil, err + } + if score.Cmp(nodeScore) == 1 { + lastSignatures, err := signatures.LastSignaturesImpl{}.LastBlockIDs(a.baseInfo.storage) + if err != nil { + return a, nil, err + } + internal := sync_internal.InternalFromLastSignatures(extension.NewPeerExtension(p, a.baseInfo.scheme), lastSignatures) + c := conf{ + peerSyncWith: p, + timeout: 30 * time.Second, + } + zap.S().Debugf("[Sync] Higher score received, starting synchronisation with peer '%s'", p.ID()) + return NewSyncFsm(a.baseInfo, c.Now(), internal) + } + */ + return noop(a) } -func (a *SyncFsm) Block(p Peer, block *proto.Block) (FSM, Async, error) { +func (a *SyncFsm) Block(p peer.Peer, block *proto.Block) (FSM, Async, error) { if p != a.conf.peerSyncWith { return a, nil, nil } metrics.FSMKeyBlockReceived("sync", block, p.Handshake().NodeName) - zap.S().Debugf("[%s] Received block %s", p.ID(), block.ID.String()) + zap.S().Debugf("[Sync][%s] Received block %s", p.ID(), block.ID.String()) internal, err := a.internal.Block(block) if err != nil { return newSyncFsm(a.baseInfo, a.conf, internal), nil, err } - return a.applyBlocks(a.baseInfo, a.conf.Now(), internal) + return a.applyBlocks(a.baseInfo, a.conf.Now(a.baseInfo.tm), internal) } func (a *SyncFsm) MinedBlock(block *proto.Block, limits proto.MiningLimits, keyPair proto.KeyPair, vrf []byte) (FSM, Async, error) { @@ -164,7 +184,7 @@ func (a *SyncFsm) MinedBlock(block *proto.Block, limits proto.MiningLimits, keyP // first we should send block a.baseInfo.actions.SendBlock(block) a.baseInfo.actions.SendScore(a.baseInfo.storage) - return a, Tasks(NewMineMicroTask(5*time.Second, block, limits, keyPair, vrf)), nil + return a, tasks.Tasks(tasks.NewMineMicroTask(5*time.Second, block, limits, keyPair, vrf)), nil } func (a *SyncFsm) Halt() (FSM, Async, error) { @@ -213,6 +233,10 @@ func (a *SyncFsm) applyBlocks(baseInfo BaseInfo, conf conf, internal sync_intern return newSyncFsm(baseInfo, conf, internal), nil, nil } +func (a *SyncFsm) String() string { + return "Sync" +} + func NewSyncFsm(baseInfo BaseInfo, conf conf, internal sync_internal.Internal) (FSM, Async, error) { return newSyncFsm(baseInfo, conf, internal), nil, nil } @@ -224,16 +248,3 @@ func newSyncFsm(baseInfo BaseInfo, conf conf, internal sync_internal.Internal) F internal: internal, } } - -func NewIdleToSyncTransition(baseInfo BaseInfo, p Peer) (FSM, Async, error) { - lastSignatures, err := signatures.LastSignaturesImpl{}.LastBlockIDs(baseInfo.storage) - if err != nil { - return NewIdleFsm(baseInfo), nil, err - } - internal := sync_internal.InternalFromLastSignatures(extension.NewPeerExtension(p, baseInfo.scheme), lastSignatures) - c := conf{ - peerSyncWith: p, - timeout: 30 * time.Second, - } - return NewSyncFsm(baseInfo, c.Now(), internal) -} diff --git a/pkg/node/state_fsm/fsm_sync_test.go b/pkg/node/state_fsm/fsm_sync_test.go index 203c8acc96..e75e83fc2c 100644 --- a/pkg/node/state_fsm/fsm_sync_test.go +++ b/pkg/node/state_fsm/fsm_sync_test.go @@ -2,16 +2,21 @@ package state_fsm import ( "testing" + "time" "github.com/golang/mock/gomock" "github.com/stretchr/testify/require" "github.com/wavesplatform/gowaves/pkg/libs/ntptime" + "github.com/wavesplatform/gowaves/pkg/libs/signatures" "github.com/wavesplatform/gowaves/pkg/mock" "github.com/wavesplatform/gowaves/pkg/node/state_fsm/sync_internal" - . "github.com/wavesplatform/gowaves/pkg/node/state_fsm/tasks" + "github.com/wavesplatform/gowaves/pkg/node/state_fsm/tasks" + "github.com/wavesplatform/gowaves/pkg/p2p/peer/extension" "github.com/wavesplatform/gowaves/pkg/proto" ) +//go:generate moq -pkg state_fsm -out time_moq.go ../../types Time:MockTime + func TestSyncFsm_Sync(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() @@ -25,11 +30,24 @@ func TestSyncFsm_Sync(t *testing.T) { mockPeer.EXPECT().Handshake().Return(proto.Handshake{Version: proto.NewVersion(1, 2, 0)}) mockPeer.EXPECT().SendMessage(gomock.Any()) - fsm, async, err := NewIdleToSyncTransition( - BaseInfo{ - peers: mockManager, - storage: mockState}, - mockPeer) + baseInfo := BaseInfo{ + peers: mockManager, + storage: mockState, + tm: &MockTime{ + NowFunc: func() time.Time { + return time.Now() + }, + }, + } + lastSignatures, err := signatures.LastSignaturesImpl{}.LastBlockIDs(baseInfo.storage) + require.NoError(t, err) + internal := sync_internal.InternalFromLastSignatures(extension.NewPeerExtension(mockPeer, baseInfo.scheme), lastSignatures) + c := conf{ + peerSyncWith: mockPeer, + timeout: 30 * time.Second, + } + fsm, async, err := NewSyncFsm(baseInfo, c.Now(baseInfo.tm), internal) + require.NoError(t, err) require.NotEmpty(t, fsm) require.Empty(t, async) @@ -39,6 +57,7 @@ func TestSyncFsm_SignaturesTimeout(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() p := mock.NewMockPeer(ctrl) + p.EXPECT().ID() conf := conf{peerSyncWith: p} fsm, async, err := NewSyncFsm(BaseInfo{tm: ntptime.Stub{}}, conf, sync_internal.Internal{}) @@ -46,8 +65,8 @@ func TestSyncFsm_SignaturesTimeout(t *testing.T) { require.Len(t, async, 0) require.NotNil(t, fsm) - fsm, _, _ = fsm.Task(AsyncTask{ - TaskType: Ping, + fsm, _, _ = fsm.Task(tasks.AsyncTask{ + TaskType: tasks.Ping, }) require.IsType(t, &IdleFsm{}, fsm) diff --git a/pkg/node/state_fsm/time_moq.go b/pkg/node/state_fsm/time_moq.go new file mode 100644 index 0000000000..b16ae40a2a --- /dev/null +++ b/pkg/node/state_fsm/time_moq.go @@ -0,0 +1,68 @@ +// Code generated by moq; DO NOT EDIT. +// github.com/matryer/moq + +package state_fsm + +import ( + "github.com/wavesplatform/gowaves/pkg/types" + "sync" + "time" +) + +// Ensure, that MockTime does implement types.Time. +// If this is not the case, regenerate this file with moq. +var _ types.Time = &MockTime{} + +// MockTime is a mock implementation of types.Time. +// +// func TestSomethingThatUsesTime(t *testing.T) { +// +// // make and configure a mocked types.Time +// mockedTime := &MockTime{ +// NowFunc: func() time.Time { +// panic("mock out the Now method") +// }, +// } +// +// // use mockedTime in code that requires types.Time +// // and then make assertions. +// +// } +type MockTime struct { + // NowFunc mocks the Now method. + NowFunc func() time.Time + + // calls tracks calls to the methods. + calls struct { + // Now holds details about calls to the Now method. + Now []struct { + } + } + lockNow sync.RWMutex +} + +// Now calls NowFunc. +func (mock *MockTime) Now() time.Time { + if mock.NowFunc == nil { + panic("MockTime.NowFunc: method is nil but Time.Now was just called") + } + callInfo := struct { + }{} + mock.lockNow.Lock() + mock.calls.Now = append(mock.calls.Now, callInfo) + mock.lockNow.Unlock() + return mock.NowFunc() +} + +// NowCalls gets all the calls that were made to Now. +// Check the length with: +// len(mockedTime.NowCalls()) +func (mock *MockTime) NowCalls() []struct { +} { + var calls []struct { + } + mock.lockNow.RLock() + calls = mock.calls.Now + mock.lockNow.RUnlock() + return calls +} diff --git a/pkg/p2p/outgoing/outgoing.go b/pkg/p2p/outgoing/outgoing.go index 8e77e263da..45e5816931 100644 --- a/pkg/p2p/outgoing/outgoing.go +++ b/pkg/p2p/outgoing/outgoing.go @@ -105,7 +105,7 @@ func (a *connector) connect(ctx context.Context, c net.Conn, v proto.Version) (c _, err = handshake.ReadFrom(c) if err != nil { - zap.S().Debugf("Failed to read handshake: %s %s", err, a.params.Address) + zap.S().Debugf("[%s] Failed to read handshake: %v", a.params.Address.String(), err) select { case <-ctx.Done(): return nil, nil, errors.Wrap(ctx.Err(), "connector.connect") diff --git a/pkg/proto/address.go b/pkg/proto/address.go index 69a31fdb8f..6c844d83a9 100644 --- a/pkg/proto/address.go +++ b/pkg/proto/address.go @@ -4,16 +4,16 @@ import ( "bytes" "encoding/binary" "fmt" - "io" - "strconv" - "strings" - "github.com/mr-tron/base58/base58" "github.com/pkg/errors" "github.com/wavesplatform/gowaves/pkg/crypto" "github.com/wavesplatform/gowaves/pkg/errs" g "github.com/wavesplatform/gowaves/pkg/grpc/generated/waves" "github.com/wavesplatform/gowaves/pkg/libs/serializer" + "io" + "strconv" + "strings" + "unicode/utf8" ) const ( @@ -31,10 +31,10 @@ const ( AliasAlphabet = "-.0123456789@_abcdefghijklmnopqrstuvwxyz" AliasPrefix = "alias" - MainNetScheme byte = 'W' - TestNetScheme byte = 'T' - StageNetScheme byte = 'S' - CustomNetScheme byte = 'E' + MainNetScheme Scheme = 'W' + TestNetScheme Scheme = 'T' + StageNetScheme Scheme = 'S' + CustomNetScheme Scheme = 'E' ) // Address is the transformed Public Key with additional bytes of the version, a blockchain scheme and a checksum. @@ -344,12 +344,14 @@ func NewAlias(scheme byte, alias string) *Alias { return &Alias{aliasVersion, scheme, alias} } -// Valid validates the Alias checking it length, version and symbols. +// Valid validates the Alias checking it UTF8 length, version and symbols. func (a Alias) Valid() (bool, error) { if v := a.Version; v != aliasVersion { return false, errors.Errorf("%d is incorrect alias version, expected %d", v, aliasVersion) } - if l := len(a.Alias); l < AliasMinLength || l > AliasMaxLength { + // nickeskov: runes count because non ASCII symbols can have length > 1 byte + // Using of utf8.RuneCountInString reproduces scala node behaviour + if l := utf8.RuneCountInString(a.Alias); l < AliasMinLength || l > AliasMaxLength { return false, errs.NewTxValidationError(fmt.Sprintf("Alias '%s' length should be between %d and %d", a.Alias, AliasMinLength, AliasMaxLength)) } if !correctAlphabet(a.Alias) { @@ -531,3 +533,29 @@ func (r *Recipient) String() string { } return r.Address.String() } + +// SchemeFromString returns Scheme from string representation (short or full). +func SchemeFromString(scheme string) Scheme { + switch len(scheme) { + case 0: + return CustomNetScheme + case 1: + switch b := scheme[0]; b { + case MainNetScheme, StageNetScheme, TestNetScheme: + return b + default: + return CustomNetScheme + } + default: + switch scheme { + case "mainnet": + return MainNetScheme + case "stagenet": + return StageNetScheme + case "testnet": + return TestNetScheme + default: + return CustomNetScheme + } + } +} diff --git a/pkg/proto/address_test.go b/pkg/proto/address_test.go index c9d8ee2761..70053f93c3 100644 --- a/pkg/proto/address_test.go +++ b/pkg/proto/address_test.go @@ -169,3 +169,29 @@ func TestRecipient_WriteTo(t *testing.T) { require.Equal(t, bin, buf.Bytes()) } + +func TestSchemeFromString(t *testing.T) { + tests := []struct { + schemeStr string + expectedScheme Scheme + }{ + {"", CustomNetScheme}, + + {"W", MainNetScheme}, + {"S", StageNetScheme}, + {"T", TestNetScheme}, + + {"E", CustomNetScheme}, + {"@", CustomNetScheme}, + + {"mainnet", MainNetScheme}, + {"stagenet", StageNetScheme}, + {"testnet", TestNetScheme}, + {"any-string", CustomNetScheme}, + } + + for _, testCase := range tests { + actualScheme := SchemeFromString(testCase.schemeStr) + require.Equal(t, testCase.expectedScheme, actualScheme) + } +} diff --git a/pkg/proto/transactions_test.go b/pkg/proto/transactions_test.go index a2cd645c8f..df783bfb25 100644 --- a/pkg/proto/transactions_test.go +++ b/pkg/proto/transactions_test.go @@ -2377,6 +2377,17 @@ func newSignedOrderV1(t *testing.T, sender, matcher crypto.PublicKey, amountAsse return *o } +func newSignedOrderV4(t *testing.T, sender, matcher crypto.PublicKey, amountAsset, priceAsset OptionalAsset, ot OrderType, price, amount, ts, exp, fee uint64, sID, sSig string) OrderV4 { + id, err := crypto.NewDigestFromBase58(sID) + require.NoError(t, err) + sig, err := crypto.NewSignatureFromBase58(sSig) + require.NoError(t, err) + o := NewUnsignedOrderV4(sender, matcher, amountAsset, priceAsset, ot, price, amount, ts, exp, fee, OptionalAsset{}) + o.ID = &id + o.Proofs = NewProofsFromSignature(&sig) + return *o +} + func TestExchangeWithSigFromMainNet(t *testing.T) { tests := []struct { matcher string @@ -2720,6 +2731,19 @@ func TestExchangeWithProofsValidations(t *testing.T) { } } +func TestExchangeV3PriceValidation(t *testing.T) { + buySender, _ := crypto.NewPublicKeyFromBase58("HFw9wjsuaeZ6w8HqJeyxz9RUXJN8krLpgjwtPrqyicr") + sellSender, _ := crypto.NewPublicKeyFromBase58("BvJEWY79uQEFetuyiZAF5U4yjPioMj9J6ZrF9uTNfe3E") + mpk, _ := crypto.NewPublicKeyFromBase58("BvJEWY79uQEFetuyiZAF5U4yjPioMj9J6ZrF9uTNfe3E") + aa, _ := NewOptionalAssetFromString("3JmaWyFqWo8YSA8x3DXCBUW7veesxacvKx19dMv7wTMg") + pa, _ := NewOptionalAssetFromString("25FEqEjRkqK6yCkiT7Lz6SAYz7gUFCtxfCChnrVFD5AT") + sbo := newSignedOrderV4(t, buySender, mpk, *aa, *pa, Buy, 1000000, 800000000, 1624445095222, 1626950695222, 300000, "3fdNTCQ7o2TvN8eDV3m7J9aSLxcUitwN2SMZpn1irSXX", "3aKUz8boZingH8r18grL8Rst5RyGVnESaQtuEoV5piUnvJKNf67xFwFpPpmfiuAuud1AAzj94xYNw1MKkmJaBicR") + sso := newSignedOrderV4(t, sellSender, mpk, *aa, *pa, Sell, 1000000, 800000000, 1624445095267, 1626950695267, 300000, "81Xc8YP1Ev2bqvSLgN5k3ent6Fr7rnEdCg8x2DH5twqX", "4VQmM6QB8yaQ1AChNNkVH5EvVKenS8YG7YqXK9SsjWAnjJm5xvd48kW2akwcEbhgzqqGMDtS2AmeGSfpEcHEMYGU") + tx := NewUnsignedExchangeWithProofs(3, &sbo, &sso, 100000000, 800000000, 100, 100, 300000, 1624445095293) + _, err := tx.Validate() + assert.NoError(t, err) +} + func TestExchangeWithProofsFromTestNet(t *testing.T) { tests := []struct { matcher string diff --git a/pkg/proto/transactions_with_proofs.go b/pkg/proto/transactions_with_proofs.go index ed2d98ff13..5836d84fd8 100644 --- a/pkg/proto/transactions_with_proofs.go +++ b/pkg/proto/transactions_with_proofs.go @@ -51,6 +51,8 @@ const ( maxArguments = 22 maxFunctionNameBytes = 255 maxInvokeScriptWithProofsBytes = 5 * 1024 + + topRideVersion = 5 ) // IssueWithProofs is a transaction to issue new asset, second version. @@ -184,9 +186,8 @@ func validContentType(t byte) bool { return t >= 1 && t <= 3 } -// version in range [0, 5) -func validStdVersion(v byte) bool { - return v < 5 +func validScriptVersion(v byte) bool { + return v <= topRideVersion } func (tx *IssueWithProofs) Validate() (Transaction, error) { @@ -198,10 +199,9 @@ func (tx *IssueWithProofs) Validate() (Transaction, error) { return tx, err } if tx.NonEmptyScript() { - if !validStdVersion(tx.Script[0]) { + if !validScriptVersion(tx.Script[0]) { return tx, errors.Errorf("Invalid version of script: %d", tx.Script[0]) } - if tx.Script[0] == 0 { // version byte if len(tx.Script) <= 2 { return tx, errors.Errorf("Illegal length of script: %d", len(tx.Script)) @@ -209,12 +209,10 @@ func (tx *IssueWithProofs) Validate() (Transaction, error) { if !validContentType(tx.Script[1]) { return tx, errors.Errorf("Invalid content type of script: %d", tx.Script[1]) } - if tx.Script[2] > 4 { // 4 is current max script version + if !validScriptVersion(tx.Script[2]) { return tx, errors.Errorf("Invalid version of script: %d", tx.Script[2]) } - } - if !tx.Script.IsValidChecksum() { return tx, errors.Errorf("Invalid checksum: %+v", []byte(tx.Script)) } @@ -1441,7 +1439,7 @@ func (tx *ExchangeWithProofs) Validate() (Transaction, error) { if err != nil { return tx, err } - if tx.Price > bo.GetPrice() || tx.Price < so.GetPrice() { + if tx.Version < 3 && tx.Price > bo.GetPrice() || tx.Price < so.GetPrice() { if tx.Price > bo.GetPrice() { return tx, errors.Errorf("invalid price: tx.Price %d > bo.GetPrice() %d", tx.Price, bo.GetPrice()) } @@ -3152,7 +3150,7 @@ func (tx *DataWithProofs) bodyUnmarshalBinary(data []byte) error { if err != nil { return errors.Errorf("failed to extract type of data entry") } - switch DataValueType(t) { + switch t { case DataInteger: var ie IntegerDataEntry err = ie.UnmarshalBinary(data) @@ -4281,7 +4279,7 @@ func (tx *InvokeScriptWithProofs) Clone() *InvokeScriptWithProofs { return out } -//NewUnsignedSetAssetScriptWithProofs creates new unsigned SetAssetScriptWithProofs transaction. +//NewUnsignedInvokeScriptWithProofs creates new unsigned InvokeScriptWithProofs transaction. func NewUnsignedInvokeScriptWithProofs(v, chain byte, senderPK crypto.PublicKey, scriptRecipient Recipient, call FunctionCall, payments ScriptPayments, feeAsset OptionalAsset, fee, timestamp uint64) *InvokeScriptWithProofs { return &InvokeScriptWithProofs{ Type: InvokeScriptTransaction, @@ -4756,7 +4754,7 @@ func (tx *UpdateAssetInfoWithProofs) MarshalBinary() ([]byte, error) { return nil, errors.New("binary format is not defined for UpdateAssetInfoTransaction") } -func (tx *UpdateAssetInfoWithProofs) UnmarshalBinary(data []byte, scheme Scheme) error { +func (tx *UpdateAssetInfoWithProofs) UnmarshalBinary(_ []byte, _ Scheme) error { return errors.New("binary format is not defined for UpdateAssetInfoTransaction") } diff --git a/pkg/state/aliases.go b/pkg/state/aliases.go index c8a45ba896..15ca312107 100644 --- a/pkg/state/aliases.go +++ b/pkg/state/aliases.go @@ -76,18 +76,21 @@ type aliases struct { disabled map[string]bool + hasher *stateHasher + calculateHashes bool - hasher *stateHasher + extendedAPI bool } -func newAliases(db keyvalue.IterableKeyVal, dbBatch keyvalue.Batch, hs *historyStorage, calcHashes bool) *aliases { +func newAliases(db keyvalue.IterableKeyVal, dbBatch keyvalue.Batch, hs *historyStorage, calcHashes, extendedAPI bool) *aliases { return &aliases{ db: db, dbBatch: dbBatch, hs: hs, disabled: make(map[string]bool), - calculateHashes: calcHashes, hasher: newStateHasher(), + calculateHashes: calcHashes, + extendedAPI: extendedAPI, } } @@ -258,3 +261,13 @@ func (a *aliases) disabledAliases() (map[string]struct{}, error) { } return als, nil } + +func (a *aliases) startProvidingAliasesByAddr() error { + if a.extendedAPI { + // Already provides. + return nil + } + // TODO(nickeskov): need flush? + a.extendedAPI = true + return nil +} diff --git a/pkg/state/api.go b/pkg/state/api.go index 27a96356e6..7e14681a8d 100644 --- a/pkg/state/api.go +++ b/pkg/state/api.go @@ -73,6 +73,7 @@ type StateInfo interface { // Aliases. AddrByAlias(alias proto.Alias) (proto.Address, error) + //AliasesByAddr(alias proto.Alias) (proto.Address, error) // Accounts data storage. RetrieveEntries(account proto.Recipient) ([]proto.DataEntry, error) diff --git a/pkg/state/balances.go b/pkg/state/balances.go index f8b983011c..db7727a942 100644 --- a/pkg/state/balances.go +++ b/pkg/state/balances.go @@ -339,6 +339,31 @@ func (s *balances) cancelInvalidLeaseIns(correctLeaseIns map[proto.Address]int64 return nil } +func (s *balances) cancelLeases(changes map[proto.Address]balanceDiff, blockID proto.BlockID) error { + zap.S().Infof("Updating balances for cancelled leases") + for a, bd := range changes { + k := wavesBalanceKey{address: a} + r, err := s.newestWavesRecord(k.bytes(), true) + if err != nil { + return err + } + profile := r.balanceProfile + newProfile, err := bd.applyTo(&profile) + if err != nil { + return err + } + val := &wavesValue{leaseChange: true, profile: *newProfile} + if err := s.setWavesBalance(a, val, blockID); err != nil { + return err + } + zap.S().Infof("Balance of %s changed from (B: %d, LIn: %d, LOut: %d) to (B: %d, lIn: %d, lOut: %d)", + a.String(), profile.balance, profile.leaseIn, profile.leaseOut, + newProfile.balance, newProfile.leaseIn, newProfile.leaseOut) + } + zap.S().Infof("Finished to update balances") + return nil +} + type assetInfoFn func(crypto.Digest, bool) (*assetInfo, error) func (s *balances) nftList(addr proto.Address, limit uint64, after []byte, assetInfoById assetInfoFn) ([]crypto.Digest, error) { diff --git a/pkg/state/common_test.go b/pkg/state/common_test.go index 88c1cf397a..1a4f80410c 100644 --- a/pkg/state/common_test.go +++ b/pkg/state/common_test.go @@ -293,7 +293,10 @@ func createStorageObjects() (*testStorageObjects, []string, error) { if err != nil { return nil, res, err } - entities, err := newBlockchainEntitiesStorage(hs, settings.MainNetSettings, rw, false) + params := StateParams{ + BuildStateHashes: false, + } + entities, err := newBlockchainEntitiesStorage(hs, settings.MainNetSettings, rw, ¶ms) if err != nil { return nil, res, err } diff --git a/pkg/state/history_storage.go b/pkg/state/history_storage.go index 99e6924d47..86bdfc7ac5 100644 --- a/pkg/state/history_storage.go +++ b/pkg/state/history_storage.go @@ -229,7 +229,7 @@ func newHistoryRecordFromBytes(data []byte) (*historyRecord, error) { dataSize := len(data) recordSize := property.recordSize if dataSize < 1+recordSize { - return nil, errInvalidDataSize + return nil, errors.Wrapf(errInvalidDataSize, "entity type %v", entityType) } for i := 1; i <= dataSize-recordSize; i += recordSize { var entry historyEntry diff --git a/pkg/state/leases.go b/pkg/state/leases.go index faaf465284..23ddfb4bc7 100644 --- a/pkg/state/leases.go +++ b/pkg/state/leases.go @@ -116,10 +116,10 @@ func (l *leases) cancelLeases(bySenders map[proto.Address]struct{}, blockID prot return nil } -func (l *leases) cancelLeasesToAliases(aliases map[string]struct{}, blockID proto.BlockID) error { +func (l *leases) cancelLeasesToAliases(aliases map[string]struct{}, blockID proto.BlockID) (map[proto.Address]balanceDiff, error) { leaseIter, err := l.hs.newNewestTopEntryIterator(lease, true) if err != nil { - return errors.Wrap(err, "failed to create key iterator to cancel leases to stolen aliases") + return nil, errors.Wrap(err, "failed to create key iterator to cancel leases to stolen aliases") } defer func() { leaseIter.Release() @@ -129,30 +129,43 @@ func (l *leases) cancelLeasesToAliases(aliases map[string]struct{}, blockID prot }() // Iterate all the leases. - zap.S().Info("Started collecting leases") + zap.S().Info("Started cancelling leases to disabled aliases") + changes := make(map[proto.Address]balanceDiff) for leaseIter.Next() { keyBytes := keyvalue.SafeKey(leaseIter) var key leaseKey if err := key.unmarshal(keyBytes); err != nil { - return errors.Wrap(err, "failed ot unmarshal leasing key") + return nil, errors.Wrap(err, "failed ot unmarshal leasing key") } leaseBytes := keyvalue.SafeValue(leaseIter) record := new(leasing) if err := cbor.Unmarshal(leaseBytes, record); err != nil { - return errors.Wrap(err, "failed to unmarshal lease") + return nil, errors.Wrap(err, "failed to unmarshal lease") } if record.isActive() && record.RecipientAlias != nil { if _, ok := aliases[record.RecipientAlias.Alias]; ok { zap.S().Infof("State: canceling lease %s", key.leaseID.String()) record.Status = LeaseCanceled if err := l.addLeasing(key.leaseID, record, blockID); err != nil { - return errors.Wrap(err, "failed to save lease to storage") + return nil, errors.Wrap(err, "failed to save lease to storage") + } + if diff, ok := changes[record.Sender]; ok { + diff.leaseOut += -int64(record.Amount) + changes[record.Sender] = diff + } else { + changes[record.Sender] = newBalanceDiff(0, 0, -int64(record.Amount), false) + } + if diff, ok := changes[record.Recipient]; ok { + diff.leaseIn += -int64(record.Amount) + changes[record.Recipient] = diff + } else { + changes[record.Recipient] = newBalanceDiff(0, -int64(record.Amount), 0, false) } } } } - zap.S().Info("Finished collecting leases") - return nil + zap.S().Info("Finished cancelling leases to disabled aliases") + return changes, nil } func (l *leases) validLeaseIns() (map[proto.Address]int64, error) { diff --git a/pkg/state/state.go b/pkg/state/state.go index 0c4041ebd5..f20056505a 100644 --- a/pkg/state/state.go +++ b/pkg/state/state.go @@ -62,7 +62,10 @@ type blockchainEntitiesStorage struct { calculateHashes bool } -func newBlockchainEntitiesStorage(hs *historyStorage, sets *settings.BlockchainSettings, rw *blockReadWriter, calcHashes bool) (*blockchainEntitiesStorage, error) { +func newBlockchainEntitiesStorage(hs *historyStorage, sets *settings.BlockchainSettings, rw *blockReadWriter, params *StateParams) (*blockchainEntitiesStorage, error) { + calcHashes := params.BuildStateHashes + extendedAPI := params.StoreExtendedApiData + balances, err := newBalances(hs.db, hs, calcHashes) if err != nil { return nil, err @@ -74,7 +77,7 @@ func newBlockchainEntitiesStorage(hs *historyStorage, sets *settings.BlockchainS features := newFeatures(rw, hs.db, hs, sets, settings.FeaturesInfo) return &blockchainEntitiesStorage{ hs, - newAliases(hs.db, hs.dbBatch, hs, calcHashes), + newAliases(hs.db, hs.dbBatch, hs, calcHashes, extendedAPI), newAssets(hs.db, hs.dbBatch, hs), newLeases(hs, calcHashes), newScores(hs), @@ -407,7 +410,7 @@ func newStateManager(dataDir string, params StateParams, settings *settings.Bloc if err != nil { return nil, wrapErr(Other, errors.Errorf("failed to create history storage: %v", err)) } - stor, err := newBlockchainEntitiesStorage(hs, settings, rw, params.BuildStateHashes) + stor, err := newBlockchainEntitiesStorage(hs, settings, rw, ¶ms) if err != nil { return nil, wrapErr(Other, errors.Errorf("failed to create blockchain entities storage: %v", err)) } @@ -1297,7 +1300,11 @@ func (s *stateManager) cancelLeases(height uint64, blockID proto.BlockID, initia if err != nil { return err } - if err = s.stor.leases.cancelLeasesToAliases(disabledAliases, blockID); err != nil { + changes, err := s.stor.leases.cancelLeasesToAliases(disabledAliases, blockID) + if err != nil { + return err + } + if err := s.stor.balances.cancelLeases(changes, blockID); err != nil { return err } } @@ -1530,7 +1537,11 @@ func (s *stateManager) CurrentScore() (*big.Int, error) { if err != nil { return nil, wrapErr(RetrievalError, err) } - return s.ScoreAtHeight(height) + score, err := s.stor.scores.score(height, true) + if err != nil { + return nil, wrapErr(RetrievalError, err) + } + return score, nil } func (s *stateManager) NewestRecipientToAddress(recipient proto.Recipient) (*proto.Address, error) {