Merge pull request #1759 from nspcc-dev/config/policy

Move some Policy settings to config

internal/fakechain/fakechain.go

@@ -164,16 +164,6 @@ func (chain *FakeChain) P2PSigExtensionsEnabled() bool {
 	return true
 }
 
-// GetMaxBlockSystemFee implements Policer interface.
-func (chain *FakeChain) GetMaxBlockSystemFee() int64 {
-	panic("TODO")
-}
-
-// GetMaxBlockSize implements Policer interface.
-func (chain *FakeChain) GetMaxBlockSize() uint32 {
-	panic("TODO")
-}
-
 // AddHeaders implements Blockchainer interface.
 func (chain *FakeChain) AddHeaders(...*block.Header) error {
 	panic("TODO")

pkg/compiler/native_test.go

@@ -118,16 +118,10 @@ func TestNativeHelpersCompile(t *testing.T) {
 		{"blockAccount", []string{u160}},
 		{"getExecFeeFactor", nil},
 		{"getFeePerByte", nil},
-		{"getMaxBlockSize", nil},
-		{"getMaxBlockSystemFee", nil},
-		{"getMaxTransactionsPerBlock", nil},
 		{"getStoragePrice", nil},
 		{"isBlocked", []string{u160}},
 		{"setExecFeeFactor", []string{"42"}},
 		{"setFeePerByte", []string{"42"}},
-		{"setMaxBlockSize", []string{"42"}},
-		{"setMaxBlockSystemFee", []string{"42"}},
-		{"setMaxTransactionsPerBlock", []string{"42"}},
 		{"setStoragePrice", []string{"42"}},
 		{"unblockAccount", []string{u160}},
 	})

pkg/config/protocol_config.go

@@ -20,6 +20,8 @@ type (
 		RemoveUntraceableBlocks bool `yaml:"RemoveUntraceableBlocks"`
 		// MaxTraceableBlocks is the length of the chain accessible to smart contracts.
 		MaxTraceableBlocks uint32 `yaml:"MaxTraceableBlocks"`
+		// MaxTransactionsPerBlock is the maximum amount of transactions per block.
+		MaxTransactionsPerBlock uint16 `yaml:"MaxTransactionsPerBlock"`
 		// P2PSigExtensions enables additional signature-related logic.
 		P2PSigExtensions bool `yaml:"P2PSigExtensions"`
 		// ReservedAttributes allows to have reserved attributes range for experimental or private purposes.

pkg/consensus/consensus.go

@@ -439,22 +439,12 @@ func (s *service) verifyBlock(b block.Block) bool {
 			zap.Uint64("last", s.lastTimestamp))
 		return false
 	}
-	maxBlockSize := int(s.Chain.GetPolicer().GetMaxBlockSize())
-	size := io.GetVarSize(coreb)
-	if size > maxBlockSize {
-		s.log.Warn("proposed block size exceeds policy max block size",
-			zap.Int("max size allowed", maxBlockSize),
-			zap.Int("block size", size))
-		return false
-	}
 
-	var fee int64
 	var pool = mempool.New(len(coreb.Transactions), 0, false)
 	var mainPool = s.Chain.GetMemPool()
 	for _, tx := range coreb.Transactions {
 		var err error
 
-		fee += tx.SystemFee
 		if mainPool.ContainsKey(tx.Hash()) {
 			err = pool.Add(tx, s.Chain)
 			if err == nil {
@@ -475,14 +465,6 @@ func (s *service) verifyBlock(b block.Block) bool {
 		}
 	}
 
-	maxBlockSysFee := s.Chain.GetPolicer().GetMaxBlockSystemFee()
-	if fee > maxBlockSysFee {
-		s.log.Warn("proposed block system fee exceeds policy max block system fee",
-			zap.Int("max system fee allowed", int(maxBlockSysFee)),
-			zap.Int("block system fee", int(fee)))
-		return false
-	}
-
 	return true
 }
 

pkg/consensus/consensus_test.go

@@ -407,16 +407,6 @@ func TestVerifyBlock(t *testing.T) {
 		b.Timestamp = srv.lastTimestamp - 1
 		require.False(t, srv.verifyBlock(&neoBlock{Block: *b}))
 	})
-	t.Run("bad big size", func(t *testing.T) {
-		script := make([]byte, int(srv.Chain.GetPolicer().GetMaxBlockSize()))
-		script[0] = byte(opcode.RET)
-		tx := transaction.New(netmode.UnitTestNet, script, 100000)
-		tx.ValidUntilBlock = 1
-		addSender(t, tx)
-		signTx(t, srv.Chain, tx)
-		b := testchain.NewBlock(t, srv.Chain, 1, 0, tx)
-		require.False(t, srv.verifyBlock(&neoBlock{Block: *b}))
-	})
 	t.Run("bad tx", func(t *testing.T) {
 		tx := transaction.New(netmode.UnitTestNet, []byte{byte(opcode.RET)}, 100000)
 		tx.ValidUntilBlock = 1
@@ -426,17 +416,6 @@ func TestVerifyBlock(t *testing.T) {
 		b := testchain.NewBlock(t, srv.Chain, 1, 0, tx)
 		require.False(t, srv.verifyBlock(&neoBlock{Block: *b}))
 	})
-	t.Run("bad big sys fee", func(t *testing.T) {
-		txes := make([]*transaction.Transaction, 2)
-		for i := range txes {
-			txes[i] = transaction.New(netmode.UnitTestNet, []byte{byte(opcode.RET)}, srv.Chain.GetPolicer().GetMaxBlockSystemFee()/2+1)
-			txes[i].ValidUntilBlock = 1
-			addSender(t, txes[i])
-			signTx(t, srv.Chain, txes[i])
-		}
-		b := testchain.NewBlock(t, srv.Chain, 1, 0, txes...)
-		require.False(t, srv.verifyBlock(&neoBlock{Block: *b}))
-	})
 }
 
 func shouldReceive(t *testing.T, ch chan Payload) {

pkg/core/blockchain.go

@@ -47,6 +47,7 @@ const (
 	defaultMemPoolSize                     = 50000
 	defaultP2PNotaryRequestPayloadPoolSize = 1000
 	defaultMaxTraceableBlocks              = 2102400 // 1 year of 15s blocks
+	defaultMaxTransactionsPerBlock         = 512
 	verificationGasLimit                   = 100000000 // 1 GAS
 )
 
@@ -168,6 +169,11 @@ func NewBlockchain(s storage.Store, cfg config.ProtocolConfiguration, log *zap.L
 		cfg.MaxTraceableBlocks = defaultMaxTraceableBlocks
 		log.Info("MaxTraceableBlocks is not set or wrong, using default value", zap.Uint32("MaxTraceableBlocks", cfg.MaxTraceableBlocks))
 	}
+	if cfg.MaxTransactionsPerBlock == 0 {
+		cfg.MaxTransactionsPerBlock = defaultMaxTransactionsPerBlock
+		log.Info("MaxTransactionsPerBlock is not set or wrong, using default value",
+			zap.Uint16("MaxTransactionsPerBlock", cfg.MaxTransactionsPerBlock))
+	}
 	committee, err := committeeFromConfig(cfg)
 	if err != nil {
 		return nil, err
@@ -1347,25 +1353,10 @@ func (bc *Blockchain) GetMemPool() *mempool.Pool {
 // ApplyPolicyToTxSet applies configured policies to given transaction set. It
 // expects slice to be ordered by fee and returns a subslice of it.
 func (bc *Blockchain) ApplyPolicyToTxSet(txes []*transaction.Transaction) []*transaction.Transaction {
-	maxTx := bc.contracts.Policy.GetMaxTransactionsPerBlockInternal(bc.dao)
+	maxTx := bc.config.MaxTransactionsPerBlock
 	if maxTx != 0 && len(txes) > int(maxTx) {
 		txes = txes[:maxTx]
 	}
-	maxBlockSize := bc.contracts.Policy.GetMaxBlockSizeInternal(bc.dao)
-	maxBlockSysFee := bc.contracts.Policy.GetMaxBlockSystemFeeInternal(bc.dao)
-	var (
-		blockSize uint32
-		sysFee    int64
-	)
-	blockSize = uint32(io.GetVarSize(new(block.Block)) + io.GetVarSize(len(txes)+1))
-	for i, tx := range txes {
-		blockSize += uint32(tx.Size())
-		sysFee += tx.SystemFee
-		if blockSize > maxBlockSize || sysFee > maxBlockSysFee {
-			txes = txes[:i]
-			break
-		}
-	}
 	return txes
 }
 
@@ -1943,16 +1934,6 @@ func (bc *Blockchain) GetBaseExecFee() int64 {
 	return bc.contracts.Policy.GetExecFeeFactorInternal(bc.dao)
 }
 
-// GetMaxBlockSize returns maximum allowed block size from native Policy contract.
-func (bc *Blockchain) GetMaxBlockSize() uint32 {
-	return bc.contracts.Policy.GetMaxBlockSizeInternal(bc.dao)
-}
-
-// GetMaxBlockSystemFee returns maximum block system fee from native Policy contract.
-func (bc *Blockchain) GetMaxBlockSystemFee() int64 {
-	return bc.contracts.Policy.GetMaxBlockSystemFeeInternal(bc.dao)
-}
-
 // GetMaxVerificationGAS returns maximum verification GAS Policy limit.
 func (bc *Blockchain) GetMaxVerificationGAS() int64 {
 	return bc.contracts.Policy.GetMaxVerificationGas(bc.dao)

pkg/core/blockchainer/policer.go

@@ -3,8 +3,6 @@ package blockchainer
 // Policer is an interface that abstracts the implementation of policy methods.
 type Policer interface {
 	GetBaseExecFee() int64
-	GetMaxBlockSize() uint32
-	GetMaxBlockSystemFee() int64
 	GetMaxVerificationGAS() int64
 	GetStoragePrice() int64
 }

pkg/core/native/policy.go

@@ -6,13 +6,11 @@ import (
 	"sort"
 	"sync"
 
-	"github.com/nspcc-dev/neo-go/pkg/core/block"
 	"github.com/nspcc-dev/neo-go/pkg/core/dao"
 	"github.com/nspcc-dev/neo-go/pkg/core/interop"
 	"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
 	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
-	"github.com/nspcc-dev/neo-go/pkg/network/payload"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
@@ -23,17 +21,12 @@ import (
 const (
 	policyContractID = -5
 
-	defaultMaxBlockSize            = 1024 * 256
-	defaultMaxTransactionsPerBlock = 512
 	defaultExecFeeFactor      = interop.DefaultBaseExecFee
 	defaultFeePerByte         = 1000
 	defaultMaxVerificationGas = 50000000
-	defaultMaxBlockSystemFee       = 9000 * GASFactor
 	// DefaultStoragePrice is the price to pay for 1 byte of storage.
 	DefaultStoragePrice = 100000
 
-	// minBlockSystemFee is the minimum allowed system fee per block.
-	minBlockSystemFee = 4007600
 	// maxExecFeeFactor is the maximum allowed execution fee factor.
 	maxExecFeeFactor = 1000
 	// maxFeePerByte is the maximum allowed fee per byte value.
@@ -46,18 +39,11 @@ const (
 )
 
 var (
-	// maxTransactionsPerBlockKey is a key used to store the maximum number of
-	// transactions allowed in block.
-	maxTransactionsPerBlockKey = []byte{23}
 	// execFeeFactorKey is a key used to store execution fee factor.
 	execFeeFactorKey = []byte{18}
 	// feePerByteKey is a key used to store the minimum fee per byte for
 	// transaction.
 	feePerByteKey = []byte{10}
-	// maxBlockSizeKey is a key used to store the maximum block size value.
-	maxBlockSizeKey = []byte{12}
-	// maxBlockSystemFeeKey is a key used to store the maximum block system fee value.
-	maxBlockSystemFeeKey = []byte{17}
 	// storagePriceKey is a key used to store storage price.
 	storagePriceKey = []byte{19}
 )
@@ -71,11 +57,8 @@ type Policy struct {
 	// consensus iteration. If false, these values will be updated after
 	// blockchain DAO persisting. If true, we can safely use cached values.
 	isValid            bool
-	maxTransactionsPerBlock uint32
-	maxBlockSize            uint32
 	execFeeFactor      uint32
 	feePerByte         int64
-	maxBlockSystemFee       int64
 	maxVerificationGas int64
 	storagePrice       uint32
 	blockedAccounts    []util.Uint160
@@ -88,16 +71,8 @@ func newPolicy() *Policy {
 	p := &Policy{ContractMD: *interop.NewContractMD(nativenames.Policy, policyContractID)}
 	defer p.UpdateHash()
 
-	desc := newDescriptor("getMaxTransactionsPerBlock", smartcontract.IntegerType)
+	desc := newDescriptor("getFeePerByte", smartcontract.IntegerType)
-	md := newMethodAndPrice(p.getMaxTransactionsPerBlock, 1000000, callflag.ReadStates)
+	md := newMethodAndPrice(p.getFeePerByte, 1000000, callflag.ReadStates)
-	p.AddMethod(md, desc)
-
-	desc = newDescriptor("getMaxBlockSize", smartcontract.IntegerType)
-	md = newMethodAndPrice(p.getMaxBlockSize, 1000000, callflag.ReadStates)
-	p.AddMethod(md, desc)
-
-	desc = newDescriptor("getFeePerByte", smartcontract.IntegerType)
-	md = newMethodAndPrice(p.getFeePerByte, 1000000, callflag.ReadStates)
 	p.AddMethod(md, desc)
 
 	desc = newDescriptor("isBlocked", smartcontract.BoolType,
@@ -105,10 +80,6 @@ func newPolicy() *Policy {
 	md = newMethodAndPrice(p.isBlocked, 1000000, callflag.ReadStates)
 	p.AddMethod(md, desc)
 
-	desc = newDescriptor("getMaxBlockSystemFee", smartcontract.IntegerType)
-	md = newMethodAndPrice(p.getMaxBlockSystemFee, 1000000, callflag.ReadStates)
-	p.AddMethod(md, desc)
-
 	desc = newDescriptor("getExecFeeFactor", smartcontract.IntegerType)
 	md = newMethodAndPrice(p.getExecFeeFactor, 1000000, callflag.ReadStates)
 	p.AddMethod(md, desc)
@@ -127,26 +98,11 @@ func newPolicy() *Policy {
 	md = newMethodAndPrice(p.setStoragePrice, 3000000, callflag.States)
 	p.AddMethod(md, desc)
 
-	desc = newDescriptor("setMaxBlockSize", smartcontract.VoidType,
-		manifest.NewParameter("value", smartcontract.IntegerType))
-	md = newMethodAndPrice(p.setMaxBlockSize, 3000000, callflag.States)
-	p.AddMethod(md, desc)
-
-	desc = newDescriptor("setMaxTransactionsPerBlock", smartcontract.VoidType,
-		manifest.NewParameter("value", smartcontract.IntegerType))
-	md = newMethodAndPrice(p.setMaxTransactionsPerBlock, 3000000, callflag.States)
-	p.AddMethod(md, desc)
-
 	desc = newDescriptor("setFeePerByte", smartcontract.VoidType,
 		manifest.NewParameter("value", smartcontract.IntegerType))
 	md = newMethodAndPrice(p.setFeePerByte, 3000000, callflag.States)
 	p.AddMethod(md, desc)
 
-	desc = newDescriptor("setMaxBlockSystemFee", smartcontract.VoidType,
-		manifest.NewParameter("value", smartcontract.IntegerType))
-	md = newMethodAndPrice(p.setMaxBlockSystemFee, 3000000, callflag.States)
-	p.AddMethod(md, desc)
-
 	desc = newDescriptor("blockAccount", smartcontract.BoolType,
 		manifest.NewParameter("account", smartcontract.Hash160Type))
 	md = newMethodAndPrice(p.blockAccount, 3000000, callflag.States)
@@ -167,18 +123,9 @@ func (p *Policy) Metadata() *interop.ContractMD {
 
 // Initialize initializes Policy native contract and implements Contract interface.
 func (p *Policy) Initialize(ic *interop.Context) error {
-	if err := setIntWithKey(p.ID, ic.DAO, maxTransactionsPerBlockKey, defaultMaxTransactionsPerBlock); err != nil {
-		return err
-	}
 	if err := setIntWithKey(p.ID, ic.DAO, feePerByteKey, defaultFeePerByte); err != nil {
 		return err
 	}
-	if err := setIntWithKey(p.ID, ic.DAO, maxBlockSizeKey, defaultMaxBlockSize); err != nil {
-		return err
-	}
-	if err := setIntWithKey(p.ID, ic.DAO, maxBlockSystemFeeKey, defaultMaxBlockSystemFee); err != nil {
-		return err
-	}
 	if err := setIntWithKey(p.ID, ic.DAO, execFeeFactorKey, defaultExecFeeFactor); err != nil {
 		return err
 	}
@@ -187,11 +134,8 @@ func (p *Policy) Initialize(ic *interop.Context) error {
 	}
 
 	p.isValid = true
-	p.maxTransactionsPerBlock = defaultMaxTransactionsPerBlock
-	p.maxBlockSize = defaultMaxBlockSize
 	p.execFeeFactor = defaultExecFeeFactor
 	p.feePerByte = defaultFeePerByte
-	p.maxBlockSystemFee = defaultMaxBlockSystemFee
 	p.maxVerificationGas = defaultMaxVerificationGas
 	p.storagePrice = DefaultStoragePrice
 	p.blockedAccounts = make([]util.Uint160, 0)
@@ -212,11 +156,8 @@ func (p *Policy) PostPersist(ic *interop.Context) error {
 		return nil
 	}
 
-	p.maxTransactionsPerBlock = uint32(getIntWithKey(p.ID, ic.DAO, maxTransactionsPerBlockKey))
-	p.maxBlockSize = uint32(getIntWithKey(p.ID, ic.DAO, maxBlockSizeKey))
 	p.execFeeFactor = uint32(getIntWithKey(p.ID, ic.DAO, execFeeFactorKey))
 	p.feePerByte = getIntWithKey(p.ID, ic.DAO, feePerByteKey)
-	p.maxBlockSystemFee = getIntWithKey(p.ID, ic.DAO, maxBlockSystemFeeKey)
 	p.maxVerificationGas = defaultMaxVerificationGas
 	p.storagePrice = uint32(getIntWithKey(p.ID, ic.DAO, storagePriceKey))
 
@@ -240,38 +181,6 @@ func (p *Policy) PostPersist(ic *interop.Context) error {
 	return nil
 }
 
-// getMaxTransactionsPerBlock is Policy contract method and returns the upper
-// limit of transactions per block.
-func (p *Policy) getMaxTransactionsPerBlock(ic *interop.Context, _ []stackitem.Item) stackitem.Item {
-	return stackitem.NewBigInteger(big.NewInt(int64(p.GetMaxTransactionsPerBlockInternal(ic.DAO))))
-}
-
-// GetMaxTransactionsPerBlockInternal returns the upper limit of transactions per
-// block.
-func (p *Policy) GetMaxTransactionsPerBlockInternal(dao dao.DAO) uint32 {
-	p.lock.RLock()
-	defer p.lock.RUnlock()
-	if p.isValid {
-		return p.maxTransactionsPerBlock
-	}
-	return uint32(getIntWithKey(p.ID, dao, maxTransactionsPerBlockKey))
-}
-
-// getMaxBlockSize is Policy contract method and returns maximum block size.
-func (p *Policy) getMaxBlockSize(ic *interop.Context, _ []stackitem.Item) stackitem.Item {
-	return stackitem.NewBigInteger(big.NewInt(int64(p.GetMaxBlockSizeInternal(ic.DAO))))
-}
-
-// GetMaxBlockSizeInternal returns maximum block size.
-func (p *Policy) GetMaxBlockSizeInternal(dao dao.DAO) uint32 {
-	p.lock.RLock()
-	defer p.lock.RUnlock()
-	if p.isValid {
-		return p.maxBlockSize
-	}
-	return uint32(getIntWithKey(p.ID, dao, maxBlockSizeKey))
-}
-
 // getFeePerByte is Policy contract method and returns required transaction's fee
 // per byte.
 func (p *Policy) getFeePerByte(ic *interop.Context, _ []stackitem.Item) stackitem.Item {
@@ -296,22 +205,6 @@ func (p *Policy) GetMaxVerificationGas(_ dao.DAO) int64 {
 	return defaultMaxVerificationGas
 }
 
-// getMaxBlockSystemFee is Policy contract method and returns the maximum overall
-// system fee per block.
-func (p *Policy) getMaxBlockSystemFee(ic *interop.Context, _ []stackitem.Item) stackitem.Item {
-	return stackitem.NewBigInteger(big.NewInt(p.GetMaxBlockSystemFeeInternal(ic.DAO)))
-}
-
-// GetMaxBlockSystemFeeInternal the maximum overall system fee per block.
-func (p *Policy) GetMaxBlockSystemFeeInternal(dao dao.DAO) int64 {
-	p.lock.RLock()
-	defer p.lock.RUnlock()
-	if p.isValid {
-		return p.maxBlockSystemFee
-	}
-	return getIntWithKey(p.ID, dao, maxBlockSystemFeeKey)
-}
-
 func (p *Policy) getExecFeeFactor(ic *interop.Context, _ []stackitem.Item) stackitem.Item {
 	return stackitem.NewBigInteger(big.NewInt(int64(p.GetExecFeeFactorInternal(ic.DAO))))
 }
@@ -400,45 +293,6 @@ func (p *Policy) setStoragePrice(ic *interop.Context, args []stackitem.Item) sta
 	return stackitem.Null{}
 }
 
-// setMaxTransactionsPerBlock is Policy contract method and  sets the upper limit
-// of transactions per block.
-func (p *Policy) setMaxTransactionsPerBlock(ic *interop.Context, args []stackitem.Item) stackitem.Item {
-	value := uint32(toBigInt(args[0]).Int64())
-	if value > block.MaxTransactionsPerBlock {
-		panic(fmt.Errorf("MaxTransactionsPerBlock cannot exceed the maximum allowed transactions per block = %d", block.MaxTransactionsPerBlock))
-	}
-	if !p.NEO.checkCommittee(ic) {
-		panic("invalid committee signature")
-	}
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	err := setIntWithKey(p.ID, ic.DAO, maxTransactionsPerBlockKey, int64(value))
-	if err != nil {
-		panic(err)
-	}
-	p.isValid = false
-	return stackitem.Null{}
-}
-
-// setMaxBlockSize is Policy contract method and sets maximum block size.
-func (p *Policy) setMaxBlockSize(ic *interop.Context, args []stackitem.Item) stackitem.Item {
-	value := uint32(toBigInt(args[0]).Int64())
-	if value > payload.MaxSize {
-		panic(fmt.Errorf("MaxBlockSize cannot be more than the maximum payload size = %d", payload.MaxSize))
-	}
-	if !p.NEO.checkCommittee(ic) {
-		panic("invalid committee signature")
-	}
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	err := setIntWithKey(p.ID, ic.DAO, maxBlockSizeKey, int64(value))
-	if err != nil {
-		panic(err)
-	}
-	p.isValid = false
-	return stackitem.Null{}
-}
-
 // setFeePerByte is Policy contract method and sets transaction's fee per byte.
 func (p *Policy) setFeePerByte(ic *interop.Context, args []stackitem.Item) stackitem.Item {
 	value := toBigInt(args[0]).Int64()
@@ -458,25 +312,6 @@ func (p *Policy) setFeePerByte(ic *interop.Context, args []stackitem.Item) stack
 	return stackitem.Null{}
 }
 
-// setMaxBlockSystemFee is Policy contract method and sets the maximum system fee per block.
-func (p *Policy) setMaxBlockSystemFee(ic *interop.Context, args []stackitem.Item) stackitem.Item {
-	value := toBigInt(args[0]).Int64()
-	if value <= minBlockSystemFee {
-		panic(fmt.Errorf("MaxBlockSystemFee cannot be less then %d", minBlockSystemFee))
-	}
-	if !p.NEO.checkCommittee(ic) {
-		panic("invalid committee signature")
-	}
-	p.lock.Lock()
-	defer p.lock.Unlock()
-	err := setIntWithKey(p.ID, ic.DAO, maxBlockSystemFeeKey, value)
-	if err != nil {
-		panic(err)
-	}
-	p.isValid = false
-	return stackitem.Null{}
-}
-
 // blockAccount is Policy contract method and adds given account hash to the list
 // of blocked accounts.
 func (p *Policy) blockAccount(ic *interop.Context, args []stackitem.Item) stackitem.Item {
@@ -530,9 +365,5 @@ func (p *Policy) CheckPolicy(d dao.DAO, tx *transaction.Transaction) error {
 			return fmt.Errorf("account %s is blocked", signer.Account.StringLE())
 		}
 	}
-	maxBlockSystemFee := p.GetMaxBlockSystemFeeInternal(d)
-	if maxBlockSystemFee < tx.SystemFee {
-		return fmt.Errorf("transaction's fee can't exceed maximum block system fee %d", maxBlockSystemFee)
-	}
 	return nil
 }

pkg/core/native_policy_test.go

@@ -5,10 +5,8 @@ import (
 
 	"github.com/nspcc-dev/neo-go/internal/random"
 	"github.com/nspcc-dev/neo-go/internal/testchain"
-	"github.com/nspcc-dev/neo-go/pkg/core/block"
 	"github.com/nspcc-dev/neo-go/pkg/core/interop"
 	"github.com/nspcc-dev/neo-go/pkg/core/native"
-	"github.com/nspcc-dev/neo-go/pkg/network/payload"
 	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 	"github.com/nspcc-dev/neo-go/pkg/wallet"
@@ -76,28 +74,6 @@ func testGetSet(t *testing.T, chain *Blockchain, hash util.Uint160, name string,
 	})
 }
 
-func TestMaxTransactionsPerBlock(t *testing.T) {
-	chain := newTestChain(t)
-
-	t.Run("get, internal method", func(t *testing.T) {
-		n := chain.contracts.Policy.GetMaxTransactionsPerBlockInternal(chain.dao)
-		require.Equal(t, 512, int(n))
-	})
-
-	testGetSet(t, chain, chain.contracts.Policy.Hash, "MaxTransactionsPerBlock", 512, 0, block.MaxTransactionsPerBlock)
-}
-
-func TestMaxBlockSize(t *testing.T) {
-	chain := newTestChain(t)
-
-	t.Run("get, internal method", func(t *testing.T) {
-		n := chain.contracts.Policy.GetMaxBlockSizeInternal(chain.dao)
-		require.Equal(t, 1024*256, int(n))
-	})
-
-	testGetSet(t, chain, chain.contracts.Policy.Hash, "MaxBlockSize", 1024*256, 0, payload.MaxSize)
-}
-
 func TestFeePerByte(t *testing.T) {
 	chain := newTestChain(t)
 
@@ -120,17 +96,6 @@ func TestExecFeeFactor(t *testing.T) {
 	testGetSet(t, chain, chain.contracts.Policy.Hash, "ExecFeeFactor", interop.DefaultBaseExecFee, 1, 1000)
 }
 
-func TestBlockSystemFee(t *testing.T) {
-	chain := newTestChain(t)
-
-	t.Run("get, internal method", func(t *testing.T) {
-		n := chain.contracts.Policy.GetMaxBlockSystemFeeInternal(chain.dao)
-		require.Equal(t, 9000*native.GASFactor, int(n))
-	})
-
-	testGetSet(t, chain, chain.contracts.Policy.Hash, "MaxBlockSystemFee", 9000*native.GASFactor, 4007600, 0)
-}
-
 func TestStoragePrice(t *testing.T) {
 	chain := newTestChain(t)
 

pkg/interop/native/policy/policy.go

@@ -8,26 +8,6 @@ import (
 // Hash represents Policy contract hash.
 const Hash = "\x7b\xc6\x81\xc0\xa1\xf7\x1d\x54\x34\x57\xb6\x8b\xba\x8d\x5f\x9f\xdd\x4e\x5e\xcc"
 
-// GetMaxTransactionsPerBlock represents `getMaxTransactionsPerBlock` method of Policy native contract.
-func GetMaxTransactionsPerBlock() int {
-	return contract.Call(interop.Hash160(Hash), "getMaxTransactionsPerBlock", contract.ReadStates).(int)
-}
-
-// SetMaxTransactionsPerBlock represents `setMaxTransactionsPerBlock` method of Policy native contract.
-func SetMaxTransactionsPerBlock(value int) {
-	contract.Call(interop.Hash160(Hash), "setMaxTransactionsPerBlock", contract.States, value)
-}
-
-// GetMaxBlockSize represents `getMaxBlockSize` method of Policy native contract.
-func GetMaxBlockSize() int {
-	return contract.Call(interop.Hash160(Hash), "getMaxBlockSize", contract.ReadStates).(int)
-}
-
-// SetMaxBlockSize represents `setMaxBlockSize` method of Policy native contract.
-func SetMaxBlockSize(value int) {
-	contract.Call(interop.Hash160(Hash), "setMaxBlockSize", contract.States, value)
-}
-
 // GetFeePerByte represents `getFeePerByte` method of Policy native contract.
 func GetFeePerByte() int {
 	return contract.Call(interop.Hash160(Hash), "getFeePerByte", contract.ReadStates).(int)
@@ -38,16 +18,6 @@ func SetFeePerByte(value int) {
 	contract.Call(interop.Hash160(Hash), "setFeePerByte", contract.States, value)
 }
 
-// GetMaxBlockSystemFee represents `getMaxBlockSystemFee` method of Policy native contract.
-func GetMaxBlockSystemFee() int {
-	return contract.Call(interop.Hash160(Hash), "getMaxBlockSystemFee", contract.ReadStates).(int)
-}
-
-// SetMaxBlockSystemFee represents `setMaxBlockSystemFee` method of Policy native contract.
-func SetMaxBlockSystemFee(value int) {
-	contract.Call(interop.Hash160(Hash), "setMaxBlockSystemFee", contract.States, value)
-}
-
 // GetExecFeeFactor represents `getExecFeeFactor` method of Policy native contract.
 func GetExecFeeFactor() int {
 	return contract.Call(interop.Hash160(Hash), "getExecFeeFactor", contract.ReadStates).(int)

pkg/rpc/client/policy.go

@@ -9,17 +9,6 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 )
 
-// GetMaxTransactionsPerBlock invokes `getMaxTransactionsPerBlock` method on a
-// native Policy contract.
-func (c *Client) GetMaxTransactionsPerBlock() (int64, error) {
-	return c.invokeNativePolicyMethod("getMaxTransactionsPerBlock")
-}
-
-// GetMaxBlockSize invokes `getMaxBlockSize` method on a native Policy contract.
-func (c *Client) GetMaxBlockSize() (int64, error) {
-	return c.invokeNativePolicyMethod("getMaxBlockSize")
-}
-
 // GetFeePerByte invokes `getFeePerByte` method on a native Policy contract.
 func (c *Client) GetFeePerByte() (int64, error) {
 	if !c.initDone {

pkg/rpc/client/rpc_test.go

@@ -431,30 +431,6 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{
 			},
 		},
 	},
-	"getMaxTransacctionsPerBlock": {
-		{
-			name: "positive",
-			invoke: func(c *Client) (interface{}, error) {
-				return c.GetMaxTransactionsPerBlock()
-			},
-			serverResponse: `{"id":1,"jsonrpc":"2.0","result":{"state":"HALT","gasconsumed":"2007390","script":"EMAMGmdldE1heFRyYW5zYWN0aW9uc1BlckJsb2NrDBSaYaRu7Je4kwbXzoHxW0YgkdAJMkFifVtS","stack":[{"type":"Integer","value":"512"}],"tx":null}}`,
-			result: func(c *Client) interface{} {
-				return int64(512)
-			},
-		},
-	},
-	"getMaxBlockSize": {
-		{
-			name: "positive",
-			invoke: func(c *Client) (interface{}, error) {
-				return c.GetMaxBlockSize()
-			},
-			serverResponse: `{"id":1,"jsonrpc":"2.0","result":{"state":"HALT","gasconsumed":"2007390","script":"EMAMD2dldE1heEJsb2NrU2l6ZQwUmmGkbuyXuJMG186B8VtGIJHQCTJBYn1bUg==","stack":[{"type":"Integer","value":"262144"}],"tx":null}}`,
-			result: func(c *Client) interface{} {
-				return int64(262144)
-			},
-		},
-	},
 	"getMaxNotValidBeforeDelta": {
 		{
 			name: "positive",