core: introduce whitelisted fee contracts

Close #4039.

Signed-off-by: Anna Shaleva <shaleva.ann@nspcc.ru>

Author: AnnaShaleva

cli/vm/cli.go

@@ -1160,7 +1160,7 @@ func handleRun(c *cli.Context) error {
 			breaks := v.Context().BreakPoints() // We ensure that there's a context loaded.
 			ic.ReuseVM(v)
 			v.GasLimit = gasLimit
-			v.LoadNEFMethod(&cs.NEF, &cs.Manifest, util.Uint160{}, cs.Hash, callflag.All, hasRet, offset, initOff, nil)
+			v.LoadNEFMethod(&cs.NEF, &cs.Manifest, util.Uint160{}, cs.Hash, callflag.All, hasRet, offset, initOff, nil, false)
 			for _, bp := range breaks {
 				v.AddBreakPoint(bp)
 			}

docs/node-configuration.md

@@ -582,7 +582,7 @@ in development and can change in an incompatible way.
 | `Cockatrice`    | Introduces the ability to update native contracts. Includes a couple of new native smart contract APIs: `keccak256` of native CryptoLib contract and `getCommitteeAddress` of native NeoToken contract. | https://github.com/nspcc-dev/neo-go/pull/3402 <br> https://github.com/neo-project/neo/pull/2942 <br> https://github.com/nspcc-dev/neo-go/pull/3301 <br> https://github.com/neo-project/neo/pull/2925 <br> https://github.com/nspcc-dev/neo-go/pull/3362 <br> https://github.com/neo-project/neo/pull/3154 |
 | `Domovoi`       | Makes node use executing contract state for the contract call permissions check instead of the state stored in the native Management contract. In C# also makes System.Runtime.GetNotifications interop properly count stack references of notification parameters which prevents users from creating objects that exceed MaxStackSize constraint, but NeoGo has never had this bug, thus proper behaviour is preserved even before HFDomovoi. It results in the fact that some T5 testnet transactions have different ApplicationLogs compared to the C# node, but the node states match. | https://github.com/nspcc-dev/neo-go/pull/3476 <br> https://github.com/neo-project/neo/pull/3290 <br> https://github.com/nspcc-dev/neo-go/pull/3473 <br> https://github.com/neo-project/neo/pull/3290 <br> https://github.com/neo-project/neo/pull/3301 <br> https://github.com/nspcc-dev/neo-go/pull/3485 |
 | `Echidna`       | Introduces `Designation` event extension with `Old` and `New` roles data to native RoleManagement contract. Adds support for `base64UrlEncode` and `base64UrlDecode` methods to native StdLib contract. Extends the list of required call flags for `registerCandidate`, `unregisterCandidate`and `vote` methods of native NeoToken contract with AllowNotify flag. Enables `onNEP17Payment` method of NEO contract for candidate registration. Introduces constraint for maximum number of execution notifications. Adds support for `recoverSecp256K1` method of native CryptoLib contract. Introduces `setMillisecondsPerBlock` and `getMillisecondsPerBlock` methods of native Policy contract. Introduces support for NotaryAssisted transaction attribute and native Notary contract. | https://github.com/nspcc-dev/neo-go/pull/3554 <br> https://github.com/nspcc-dev/neo-go/pull/3761 <br> https://github.com/nspcc-dev/neo-go/pull/3554 <br> https://github.com/neo-project/neo/pull/3597 <br> https://github.com/nspcc-dev/neo-go/pull/3700 <br> https://github.com/nspcc-dev/neo-go/pull/3640 <br> https://github.com/neo-project/neo/pull/3548 <br> https://github.com/nspcc-dev/neo-go/pull/3863 <br> https://github.com/neo-project/neo/pull/3696 <br> https://github.com/neo-project/neo/pull/3895 <br> https://github.com/nspcc-dev/neo-go/pull/3835 <br> https://github.com/nspcc-dev/neo-go/pull/3854 <br> https://github.com/neo-project/neo/pull/3175 <br> https://github.com/nspcc-dev/neo-go/pull/3478 <br> https://github.com/neo-project/neo/pull/3178 |
-| `Faun`          | Adds `getBlockedAccounts` method to native Policy contract. Adds `hexEncode` and `hexDecode` methods to native StdLib contract. | https://github.com/nspcc-dev/neo-go/pull/3932 <br> https://github.com/nspcc-dev/neo-go/pull/4004 <br> https://github.com/neo-project/neo/pull/4147 <br> https://github.com/neo-project/neo/pull/4150 |
+| `Faun`          | Adds `getBlockedAccounts` method to native Policy contract. Adds `hexEncode` and `hexDecode` methods to native StdLib contract. Adds whitelist fee contract management to native Policy contract: `setWhitelistFeeContract`, `removeWhitelistFeeContract`, `getWhitelistFeeContracts` methods and `WhitelistChanged` event. | https://github.com/nspcc-dev/neo-go/pull/3932 <br> https://github.com/nspcc-dev/neo-go/pull/4004 <br> https://github.com/neo-project/neo/pull/4147 <br> https://github.com/neo-project/neo/pull/4150 <br> https://github.com/nspcc-dev/neo-go/pull/4052 <br> https://github.com/neo-project/neo/pull/4201 |
 
 ## DB compatibility
 

pkg/compiler/native_test.go

@@ -203,6 +203,9 @@ func TestNativeHelpersCompile(t *testing.T) {
 		{"getMillisecondsPerBlock", nil},
 		{"setMillisecondsPerBlock", []string{"10"}},
 		{"getBlockedAccounts", nil},
+		{"setWhitelistFeeContract", []string{u160, `"method"`, "1", "2"}},
+		{"removeWhitelistFeeContract", []string{u160, `"method"`, "1"}},
+		{"getWhitelistFeeContracts", nil},
 	})
 	runNativeTestCases(t, *cs.ByName(nativenames.Ledger).Metadata(), "ledger", []nativeTestCase{
 		{"currentHash", nil},

pkg/config/hardfork.go

@@ -50,9 +50,10 @@ const (
 	// https://github.com/neo-project/neo/pull/3895), #3854 (ported from
 	// https://github.com/neo-project/neo/pull/3175).
 	HFEchidna // Echidna
-	// HFFaun represents hard-fork introduced in #3931, #4004 (ported from
-	// https://github.com/neo-project/neo/pull/4147,
-	// https://github.com/neo-project/neo/pull/4150).
+	// HFFaun represents hard-fork introduced in #3931 (ported from
+	// https://github.com/neo-project/neo/pull/4147), #4004 (ported from
+	// https://github.com/neo-project/neo/pull/4150), #4052 (ported from
+	// https://github.com/neo-project/neo/pull/4201).
 	HFFaun // Faun
 	// hfLast denotes the end of hardforks enum. Consider adding new hardforks
 	// before hfLast.

pkg/core/blockchain.go

@@ -3352,7 +3352,7 @@ func (bc *Blockchain) InitVerificationContext(ic *interop.Context, hash util.Uin
 		}
 		ic.Invocations[cs.Hash]++
 		ic.VM.LoadNEFMethod(&cs.NEF, &cs.Manifest, util.Uint160{}, hash, callflag.ReadOnly,
-			true, verifyOffset, initOffset, nil)
+			true, verifyOffset, initOffset, nil, false)
 	}
 	if len(witness.InvocationScript) != 0 {
 		err := vm.IsScriptCorrect(witness.InvocationScript, nil)

pkg/core/custom_native_test.go

@@ -198,10 +198,14 @@ func (p *policy) GetMaxValidUntilBlockIncrementFromCache(d *dao.Simple) uint32 {
 func (p *policy) GetAttributeFeeInternal(d *dao.Simple, attrType transaction.AttrType) int64 {
 	return 1
 }
-func (p *policy) CheckPolicy(d *dao.Simple, tx *transaction.Transaction) error      { return nil }
-func (p *policy) GetFeePerByteInternal(d *dao.Simple) int64                         { return 1 }
-func (p *policy) BlockAccountInternal(d *dao.Simple, hash util.Uint160) bool        { return false }
-func (p *policy) IsBlocked(dao *dao.Simple, hash util.Uint160) bool                 { return false }
+func (p *policy) CheckPolicy(d *dao.Simple, tx *transaction.Transaction) error { return nil }
+func (p *policy) GetFeePerByteInternal(d *dao.Simple) int64                    { return 1 }
+func (p *policy) BlockAccountInternal(d *dao.Simple, hash util.Uint160) bool   { return false }
+func (p *policy) IsBlocked(dao *dao.Simple, hash util.Uint160) bool            { return false }
+func (p *policy) IsWhitelisted(d *dao.Simple, hash util.Uint160, method string, argCnt int) int64 {
+	return -1
+}
+func (p *policy) CleanWhitelist(ic *interop.Context, hash util.Uint160)             {}
 func (p *policy) GetMaxValidUntilBlockIncrementInternal(ic *interop.Context) uint32 { return 2 }
 func (p *policy) getTimePerBlock(ic *interop.Context, args []stackitem.Item) stackitem.Item {
 	return stackitem.NewBigInteger(big.NewInt(1000))

pkg/core/interop/context.go

@@ -12,6 +12,7 @@ import (
 	"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/interopnames"
+	"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/storage"
 	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
@@ -49,15 +50,25 @@ type Ledger interface {
 	NativeManagementID() int32
 }
 
+// PolicyChecker is an interface required for checking native Policy constraints.
+type PolicyChecker interface {
+	// IsBlocked returns whether the provided account is blocked by network policy.
+	IsBlocked(d *dao.Simple, hash util.Uint160) bool
+	// IsWhitelisted returns whether the specified contract method is whitelisted.
+	// Non-negative return value defines the execution fee of a whitelisted method call.
+	IsWhitelisted(d *dao.Simple, hash util.Uint160, method string, argCnt int) int64
+}
+
 // Context represents context in which interops are executed.
 type Context struct {
-	Chain     Ledger
-	Container hash.Hashable
-	Network   uint32
-	Hardforks map[string]uint32
-	Natives   []Contract
-	Trigger   trigger.Type
-	Block     *block.Block
+	Chain         Ledger
+	Container     hash.Hashable
+	Network       uint32
+	Hardforks     map[string]uint32
+	Natives       []Contract
+	PolicyChecker PolicyChecker
+	Trigger       trigger.Type
+	Block         *block.Block
 	// IsBlockPersisted denotes whether current Block was persisted by native
 	// Ledger contract via PostPersist method.
 	IsBlockPersisted bool
@@ -85,13 +96,22 @@ func NewContext(trigger trigger.Type, bc Ledger, d *dao.Simple, baseExecFee, bas
 	getContract func(*dao.Simple, util.Uint160) (*state.Contract, error), natives []Contract,
 	loadTokenFunc func(ic *Context, id int32) error,
 	block *block.Block, tx *transaction.Transaction, log *zap.Logger) *Context {
-	dao := d.GetPrivate()
-	cfg := bc.GetConfig()
+	var (
+		dao = d.GetPrivate()
+		cfg = bc.GetConfig()
+		pch PolicyChecker
+	)
+	for _, nc := range natives {
+		if nc.Metadata().Name == nativenames.Policy {
+			pch = nc.(PolicyChecker)
+		}
+	}
 	return &Context{
 		Chain:           bc,
 		Network:         uint32(cfg.Magic),
 		Hardforks:       cfg.Hardforks,
 		Natives:         natives,
+		PolicyChecker:   pch,
 		Trigger:         trigger,
 		Block:           block,
 		Tx:              tx,

pkg/core/interop/contract/call.go

@@ -8,9 +8,8 @@ import (
 	"strings"
 
 	"github.com/nspcc-dev/neo-go/pkg/config"
-	"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/interop/storage"
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
@@ -20,10 +19,6 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 )
 
-type policyChecker interface {
-	IsBlocked(*dao.Simple, util.Uint160) bool
-}
-
 // LoadToken calls method specified by the token id.
 func LoadToken(ic *interop.Context, id int32) error {
 	ctx := ic.VM.Context()
@@ -110,13 +105,19 @@ func callInternal(ic *interop.Context, cs *state.Contract, name string, f callfl
 // callExFromNative calls a contract with flags using the provided calling hash.
 func callExFromNative(ic *interop.Context, caller util.Uint160, cs *state.Contract,
 	name string, args []stackitem.Item, f callflag.CallFlag, hasReturn bool, isDynamic bool, callFromNative bool) error {
-	for _, nc := range ic.Natives {
-		if nc.Metadata().Name == nativenames.Policy {
-			var pch = nc.(policyChecker)
-			if pch.IsBlocked(ic.DAO, cs.Hash) {
-				return fmt.Errorf("contract %s is blocked", cs.Hash.StringLE())
+	var whitelisted bool
+	if ic.PolicyChecker != nil {
+		if ic.PolicyChecker.IsBlocked(ic.DAO, cs.Hash) {
+			return fmt.Errorf("contract %s is blocked", cs.Hash.StringLE())
+		}
+		if ic.IsHardforkEnabled(config.HFFaun) {
+			fee := ic.PolicyChecker.IsWhitelisted(ic.DAO, cs.Hash, name, len(args))
+			if fee >= 0 {
+				if !ic.VM.AddGas(fee) {
+					return fmt.Errorf("%w during whitelisted contract execution", storage.ErrGasLimitExceeded)
+				}
+				whitelisted = true
 			}
-			break
 		}
 	}
 	md := cs.Manifest.ABI.GetMethod(name, len(args))
@@ -165,7 +166,7 @@ func callExFromNative(ic *interop.Context, caller util.Uint160, cs *state.Contra
 		return nil
 	}
 	ic.VM.LoadNEFMethod(&cs.NEF, &cs.Manifest, caller, cs.Hash, f,
-		hasReturn, methodOff, initOff, onUnload)
+		hasReturn, methodOff, initOff, onUnload, whitelisted)
 
 	for e, i := ic.VM.Estack(), len(args)-1; i >= 0; i-- {
 		e.PushItem(args[i])

pkg/core/interop/runtime/ext_test.go

@@ -637,7 +637,7 @@ func TestNotify(t *testing.T) {
 		_, _, bc, cs := getDeployedInternal(t)
 		ic, err := bc.GetTestVM(trigger.Application, nil, nil)
 		require.NoError(t, err)
-		ic.VM.LoadNEFMethod(&cs.NEF, &cs.Manifest, caller, cs.Hash, callflag.NoneFlag, true, 0, -1, nil)
+		ic.VM.LoadNEFMethod(&cs.NEF, &cs.Manifest, caller, cs.Hash, callflag.NoneFlag, true, 0, -1, nil, false)
 		ic.VM.Estack().PushVal(args)
 		ic.VM.Estack().PushVal(name)
 		return ic

pkg/core/native/contract.go

@@ -72,8 +72,9 @@ type (
 
 		// Methods required for proper cross-native communication.
 		BlockAccountInternal(d *dao.Simple, hash util.Uint160) bool
-		IsBlocked(dao *dao.Simple, hash util.Uint160) bool
 		GetMaxValidUntilBlockIncrementInternal(ic *interop.Context) uint32
+		CleanWhitelist(ic *interop.Context, hash util.Uint160)
+		interop.PolicyChecker
 	}
 
 	// IOracle is an interface required from native OracleContract contract for