package core

import (
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"math/big"
	"os"
	"path"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/nspcc-dev/neo-go/internal/testchain"
	"github.com/nspcc-dev/neo-go/pkg/compiler"
	"github.com/nspcc-dev/neo-go/pkg/config"
	"github.com/nspcc-dev/neo-go/pkg/core/block"
	"github.com/nspcc-dev/neo-go/pkg/core/blockchainer"
	"github.com/nspcc-dev/neo-go/pkg/core/chaindump"
	"github.com/nspcc-dev/neo-go/pkg/core/fee"
	"github.com/nspcc-dev/neo-go/pkg/core/native"
	"github.com/nspcc-dev/neo-go/pkg/core/native/noderoles"
	"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"
	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
	"github.com/nspcc-dev/neo-go/pkg/encoding/address"
	"github.com/nspcc-dev/neo-go/pkg/encoding/fixedn"
	"github.com/nspcc-dev/neo-go/pkg/io"
	"github.com/nspcc-dev/neo-go/pkg/rpc/client/nns"
	"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/trigger"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm"
	"github.com/nspcc-dev/neo-go/pkg/vm/emit"
	"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
	"github.com/nspcc-dev/neo-go/pkg/wallet"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap"
	"go.uber.org/zap/zaptest"
)

// multisig address which possess all NEO.
var neoOwner = testchain.MultisigScriptHash()

// examplesPrefix is a prefix of the example smart-contracts.
const examplesPrefix = "../../examples/"

// newTestChain should be called before newBlock invocation to properly setup
// global state.
func newTestChain(t testing.TB) *Blockchain {
	return newTestChainWithCustomCfg(t, nil)
}

func newTestChainWithCustomCfg(t testing.TB, f func(*config.Config)) *Blockchain {
	return newTestChainWithCustomCfgAndStore(t, nil, f)
}

func newTestChainWithCustomCfgAndStore(t testing.TB, st storage.Store, f func(*config.Config)) *Blockchain {
	chain := initTestChain(t, st, f)
	go chain.Run()
	t.Cleanup(chain.Close)
	return chain
}

func newLevelDBForTesting(t testing.TB) storage.Store {
	ldbDir := t.TempDir()
	dbOptions := storage.LevelDBOptions{
		DataDirectoryPath: ldbDir,
	}
	newLevelStore, err := storage.NewLevelDBStore(dbOptions)
	require.Nil(t, err, "NewLevelDBStore error")
	return newLevelStore
}

func newBoltStoreForTesting(t testing.TB) storage.Store {
	d := t.TempDir()
	testFileName := filepath.Join(d, "test_bolt_db")
	boltDBStore, err := storage.NewBoltDBStore(storage.BoltDBOptions{FilePath: testFileName})
	require.NoError(t, err)
	return boltDBStore
}

func initTestChain(t testing.TB, st storage.Store, f func(*config.Config)) *Blockchain {
	unitTestNetCfg, err := config.Load("../../config", testchain.Network())
	require.NoError(t, err)
	if f != nil {
		f(&unitTestNetCfg)
	}
	if st == nil {
		st = storage.NewMemoryStore()
	}
	log := zaptest.NewLogger(t)
	if _, ok := t.(*testing.B); ok {
		log = zap.NewNop()
	}
	chain, err := NewBlockchain(st, unitTestNetCfg.ProtocolConfiguration, log)
	require.NoError(t, err)
	return chain
}

func (bc *Blockchain) newBlock(txs ...*transaction.Transaction) *block.Block {
	lastBlock, ok := bc.topBlock.Load().(*block.Block)
	if !ok {
		var err error
		lastBlock, err = bc.GetBlock(bc.GetHeaderHash(int(bc.BlockHeight())))
		if err != nil {
			panic(err)
		}
	}
	if bc.config.StateRootInHeader {
		sr, err := bc.GetStateModule().GetStateRoot(bc.BlockHeight())
		if err != nil {
			panic(err)
		}
		return newBlockWithState(bc.config, lastBlock.Index+1, lastBlock.Hash(), &sr.Root, txs...)
	}
	return newBlock(bc.config, lastBlock.Index+1, lastBlock.Hash(), txs...)
}

func newBlock(cfg config.ProtocolConfiguration, index uint32, prev util.Uint256, txs ...*transaction.Transaction) *block.Block {
	return newBlockWithState(cfg, index, prev, nil, txs...)
}

func newBlockCustom(cfg config.ProtocolConfiguration, f func(b *block.Block),
	txs ...*transaction.Transaction) *block.Block {
	validators, _ := validatorsFromConfig(cfg)
	valScript, _ := smartcontract.CreateDefaultMultiSigRedeemScript(validators)
	witness := transaction.Witness{
		VerificationScript: valScript,
	}
	b := &block.Block{
		Header: block.Header{
			NextConsensus: witness.ScriptHash(),
			Script:        witness,
		},
		Transactions: txs,
	}
	f(b)

	b.RebuildMerkleRoot()
	b.Script.InvocationScript = testchain.Sign(b)
	return b
}

func newBlockWithState(cfg config.ProtocolConfiguration, index uint32, prev util.Uint256,
	prevState *util.Uint256, txs ...*transaction.Transaction) *block.Block {
	return newBlockCustom(cfg, func(b *block.Block) {
		b.PrevHash = prev
		b.Timestamp = uint64(time.Now().UTC().Unix())*1000 + uint64(index)
		b.Index = index

		if prevState != nil {
			b.StateRootEnabled = true
			b.PrevStateRoot = *prevState
		}
	}, txs...)
}

func (bc *Blockchain) genBlocks(n int) ([]*block.Block, error) {
	blocks := make([]*block.Block, n)
	lastHash := bc.topBlock.Load().(*block.Block).Hash()
	lastIndex := bc.topBlock.Load().(*block.Block).Index
	for i := 0; i < n; i++ {
		blocks[i] = newBlock(bc.config, uint32(i)+lastIndex+1, lastHash)
		if err := bc.AddBlock(blocks[i]); err != nil {
			return blocks, err
		}
		lastHash = blocks[i].Hash()
	}
	return blocks, nil
}

func TestBug1728(t *testing.T) {
	src := `package example
	import "github.com/nspcc-dev/neo-go/pkg/interop/runtime"
	func init() { if true { } else { } }
	func _deploy(_ interface{}, isUpdate bool) {
		runtime.Log("Deploy")
	}`
	nf, di, err := compiler.CompileWithOptions("foo.go", strings.NewReader(src), nil)
	require.NoError(t, err)
	m, err := di.ConvertToManifest(&compiler.Options{Name: "TestContract"})
	require.NoError(t, err)

	rawManifest, err := json.Marshal(m)
	require.NoError(t, err)
	rawNef, err := nf.Bytes()
	require.NoError(t, err)

	bc := newTestChain(t)

	aer, err := invokeContractMethod(bc, 10000000000,
		bc.contracts.Management.Hash, "deploy", rawNef, rawManifest)
	require.NoError(t, err)
	require.Equal(t, aer.VMState, vm.HaltState)
}

// This function generates "../rpc/testdata/testblocks.acc" file which contains data
// for RPC unit tests. It also is a nice integration test.
// To generate new "../rpc/testdata/testblocks.acc", follow the steps:
// 		1. Set saveChain down below to true
// 		2. Run tests with `$ make test`
func TestCreateBasicChain(t *testing.T) {
	const saveChain = false
	const prefix = "../rpc/server/testdata/"

	bc := newTestChain(t)
	initBasicChain(t, bc)

	if saveChain {
		outStream, err := os.Create(prefix + "testblocks.acc")
		require.NoError(t, err)
		t.Cleanup(func() {
			outStream.Close()
		})

		writer := io.NewBinWriterFromIO(outStream)
		writer.WriteU32LE(bc.BlockHeight())
		err = chaindump.Dump(bc, writer, 1, bc.BlockHeight())
		require.NoError(t, err)
	}

	priv0 := testchain.PrivateKeyByID(0)
	priv1 := testchain.PrivateKeyByID(1)
	priv0ScriptHash := priv0.GetScriptHash()
	acc0 := wallet.NewAccountFromPrivateKey(priv0)

	// Prepare some transaction for future submission.
	txSendRaw := newNEP17Transfer(bc.contracts.NEO.Hash, priv0ScriptHash, priv1.GetScriptHash(), int64(fixedn.Fixed8FromInt64(1000)))
	txSendRaw.ValidUntilBlock = bc.config.MaxValidUntilBlockIncrement
	txSendRaw.Nonce = 0x1234
	txSendRaw.Signers = []transaction.Signer{{
		Account:          priv0ScriptHash,
		Scopes:           transaction.CalledByEntry,
		AllowedContracts: nil,
		AllowedGroups:    nil,
	}}
	require.NoError(t, addNetworkFee(bc, txSendRaw, acc0))
	require.NoError(t, acc0.SignTx(testchain.Network(), txSendRaw))
	bw := io.NewBufBinWriter()
	txSendRaw.EncodeBinary(bw.BinWriter)
	t.Logf("sendrawtransaction: \n\tbase64: %s\n\tHash LE: %s", base64.StdEncoding.EncodeToString(bw.Bytes()), txSendRaw.Hash().StringLE())
	require.False(t, saveChain)
}

func initBasicChain(t *testing.T, bc *Blockchain) {
	const prefix = "../rpc/server/testdata/"
	// Increase in case if you need more blocks
	const validUntilBlock = 1200

	// To be incremented after each created transaction to keep chain constant.
	var testNonce uint32 = 1

	// Use as nonce when new transaction is created to avoid random data in tests.
	getNextNonce := func() uint32 {
		testNonce++
		return testNonce
	}

	const neoAmount = 99999000

	gasHash := bc.contracts.GAS.Hash
	neoHash := bc.contracts.NEO.Hash
	policyHash := bc.contracts.Policy.Hash
	notaryHash := bc.contracts.Notary.Hash
	t.Logf("native GAS hash: %v", gasHash)
	t.Logf("native NEO hash: %v", neoHash)
	t.Logf("native Policy hash: %v", policyHash)
	t.Logf("native Notary hash: %v", notaryHash)
	t.Logf("Block0 hash: %s", bc.GetHeaderHash(0).StringLE())

	priv0 := testchain.PrivateKeyByID(0)
	priv0ScriptHash := priv0.GetScriptHash()
	priv1 := testchain.PrivateKeyByID(1)
	priv1ScriptHash := priv1.GetScriptHash()
	acc0 := wallet.NewAccountFromPrivateKey(priv0)
	acc1 := wallet.NewAccountFromPrivateKey(priv1)

	deployContractFromPriv0 := func(t *testing.T, path, contractName string, configPath *string, expectedID int32) (util.Uint256, util.Uint256, util.Uint160) {
		txDeploy, _ := newDeployTx(t, bc, priv0ScriptHash, path, contractName, configPath)
		txDeploy.Nonce = getNextNonce()
		txDeploy.ValidUntilBlock = validUntilBlock
		require.NoError(t, addNetworkFee(bc, txDeploy, acc0))
		require.NoError(t, acc0.SignTx(testchain.Network(), txDeploy))
		b := bc.newBlock(txDeploy)
		require.NoError(t, bc.AddBlock(b)) // block #11
		checkTxHalt(t, bc, txDeploy.Hash())
		sh, err := bc.GetContractScriptHash(expectedID)
		require.NoError(t, err)
		return b.Hash(), txDeploy.Hash(), sh
	}

	require.Equal(t, big.NewInt(5000_0000), bc.GetUtilityTokenBalance(priv0ScriptHash)) // gas bounty

	// Block #1: move 1000 GAS and neoAmount NEO to priv0.
	txMoveNeo, err := testchain.NewTransferFromOwner(bc, neoHash, priv0ScriptHash, neoAmount, getNextNonce(), validUntilBlock)
	require.NoError(t, err)
	// Move some GAS to one simple account.
	txMoveGas, err := testchain.NewTransferFromOwner(bc, gasHash, priv0ScriptHash, int64(fixedn.Fixed8FromInt64(1000)),
		getNextNonce(), validUntilBlock)
	require.NoError(t, err)
	b := bc.newBlock(txMoveNeo, txMoveGas)
	require.NoError(t, bc.AddBlock(b))
	checkTxHalt(t, bc, txMoveGas.Hash())
	checkTxHalt(t, bc, txMoveNeo.Hash())
	t.Logf("Block1 hash: %s", b.Hash().StringLE())
	bw := io.NewBufBinWriter()
	b.EncodeBinary(bw.BinWriter)
	require.NoError(t, bw.Err)
	jsonB, err := b.MarshalJSON()
	require.NoError(t, err)
	t.Logf("Block1 base64: %s", base64.StdEncoding.EncodeToString(bw.Bytes()))
	t.Logf("Block1 JSON: %s", string(jsonB))
	bw.Reset()
	b.Header.EncodeBinary(bw.BinWriter)
	require.NoError(t, bw.Err)
	jsonH, err := b.Header.MarshalJSON()
	require.NoError(t, err)
	t.Logf("Header1 base64: %s", base64.StdEncoding.EncodeToString(bw.Bytes()))
	t.Logf("Header1 JSON: %s", string(jsonH))
	jsonTxMoveNeo, err := txMoveNeo.MarshalJSON()
	require.NoError(t, err)
	t.Logf("txMoveNeo hash: %s", txMoveNeo.Hash().StringLE())
	t.Logf("txMoveNeo JSON: %s", string(jsonTxMoveNeo))
	t.Logf("txMoveNeo base64: %s", base64.StdEncoding.EncodeToString(txMoveNeo.Bytes()))
	t.Logf("txMoveGas hash: %s", txMoveGas.Hash().StringLE())

	require.True(t, bc.GetUtilityTokenBalance(priv0ScriptHash).Cmp(big.NewInt(1000*native.GASFactor)) >= 0)
	// info for getblockheader rpc tests
	t.Logf("header hash: %s", b.Hash().StringLE())
	buf := io.NewBufBinWriter()
	b.Header.EncodeBinary(buf.BinWriter)
	t.Logf("header: %s", hex.EncodeToString(buf.Bytes()))

	// Block #2: deploy test_contract.
	cfgPath := prefix + "test_contract.yml"
	block2H, txDeployH, cHash := deployContractFromPriv0(t, prefix+"test_contract.go", "Rubl", &cfgPath, 1)
	t.Logf("txDeploy: %s", txDeployH.StringLE())
	t.Logf("Block2 hash: %s", block2H.StringLE())

	// Block #3: invoke `putValue` method on the test_contract.
	script := io.NewBufBinWriter()
	emit.AppCall(script.BinWriter, cHash, "putValue", callflag.All, "testkey", "testvalue")
	txInv := transaction.New(script.Bytes(), 1*native.GASFactor)
	txInv.Nonce = getNextNonce()
	txInv.ValidUntilBlock = validUntilBlock
	txInv.Signers = []transaction.Signer{{Account: priv0ScriptHash}}
	require.NoError(t, addNetworkFee(bc, txInv, acc0))
	require.NoError(t, acc0.SignTx(testchain.Network(), txInv))
	b = bc.newBlock(txInv)
	require.NoError(t, bc.AddBlock(b))
	checkTxHalt(t, bc, txInv.Hash())
	t.Logf("txInv: %s", txInv.Hash().StringLE())

	// Block #4: transfer 0.0000_1 NEO from priv0 to priv1.
	txNeo0to1 := newNEP17Transfer(neoHash, priv0ScriptHash, priv1ScriptHash, 1000)
	txNeo0to1.Nonce = getNextNonce()
	txNeo0to1.ValidUntilBlock = validUntilBlock
	txNeo0to1.Signers = []transaction.Signer{
		{
			Account:          priv0ScriptHash,
			Scopes:           transaction.CalledByEntry,
			AllowedContracts: nil,
			AllowedGroups:    nil,
		},
	}
	require.NoError(t, addNetworkFee(bc, txNeo0to1, acc0))
	require.NoError(t, acc0.SignTx(testchain.Network(), txNeo0to1))
	b = bc.newBlock(txNeo0to1)
	require.NoError(t, bc.AddBlock(b))
	checkTxHalt(t, bc, txNeo0to1.Hash())

	// Block #5: initialize rubles contract and transfer 1000 rubles from the contract to priv0.
	w := io.NewBufBinWriter()
	emit.AppCall(w.BinWriter, cHash, "init", callflag.All)
	initTx := transaction.New(w.Bytes(), 1*native.GASFactor)
	initTx.Nonce = getNextNonce()
	initTx.ValidUntilBlock = validUntilBlock
	initTx.Signers = []transaction.Signer{{Account: priv0ScriptHash}}
	require.NoError(t, addNetworkFee(bc, initTx, acc0))
	require.NoError(t, acc0.SignTx(testchain.Network(), initTx))
	transferTx := newNEP17Transfer(cHash, cHash, priv0ScriptHash, 1000)
	transferTx.Nonce = getNextNonce()
	transferTx.ValidUntilBlock = validUntilBlock
	transferTx.Signers = []transaction.Signer{
		{
			Account:          priv0ScriptHash,
			Scopes:           transaction.CalledByEntry,
			AllowedContracts: nil,
			AllowedGroups:    nil,
		},
	}
	require.NoError(t, addNetworkFee(bc, transferTx, acc0))
	transferTx.SystemFee += 1000000
	require.NoError(t, acc0.SignTx(testchain.Network(), transferTx))
	b = bc.newBlock(initTx, transferTx)
	require.NoError(t, bc.AddBlock(b))
	checkTxHalt(t, bc, initTx.Hash())
	checkTxHalt(t, bc, transferTx.Hash())
	t.Logf("recieveRublesTx: %v", transferTx.Hash().StringLE())

	// Block #6: transfer 123 rubles from priv0 to priv1
	transferTx = newNEP17Transfer(cHash, priv0.GetScriptHash(), priv1ScriptHash, 123)
	transferTx.Nonce = getNextNonce()
	transferTx.ValidUntilBlock = validUntilBlock
	transferTx.Signers = []transaction.Signer{
		{
			Account:          priv0ScriptHash,
			Scopes:           transaction.CalledByEntry,
			AllowedContracts: nil,
			AllowedGroups:    nil,
		},
	}
	require.NoError(t, addNetworkFee(bc, transferTx, acc0))
	transferTx.SystemFee += 1000000
	require.NoError(t, acc0.SignTx(testchain.Network(), transferTx))
	b = bc.newBlock(transferTx)
	require.NoError(t, bc.AddBlock(b))
	checkTxHalt(t, bc, transferTx.Hash())
	t.Logf("sendRublesTx: %v", transferTx.Hash().StringLE())

	// Block #7: push verification contract into the chain.
	verifyPath := filepath.Join(prefix, "verify", "verification_contract.go")
	_, _, _ = deployContractFromPriv0(t, verifyPath, "Verify", nil, 2)

	// Block #8: deposit some GAS to notary contract for priv0.
	transferTx = newNEP17Transfer(gasHash, priv0.GetScriptHash(), notaryHash, 10_0000_0000, priv0.GetScriptHash(), int64(bc.BlockHeight()+1000))
	transferTx.Nonce = getNextNonce()
	transferTx.ValidUntilBlock = validUntilBlock
	transferTx.Signers = []transaction.Signer{
		{
			Account: priv0ScriptHash,
			Scopes:  transaction.CalledByEntry,
		},
	}
	require.NoError(t, addNetworkFee(bc, transferTx, acc0))
	transferTx.SystemFee += 10_0000
	require.NoError(t, acc0.SignTx(testchain.Network(), transferTx))
	b = bc.newBlock(transferTx)
	require.NoError(t, bc.AddBlock(b))
	checkTxHalt(t, bc, transferTx.Hash())
	t.Logf("notaryDepositTxPriv0: %v", transferTx.Hash().StringLE())

	// Block #9: designate new Notary node.
	ntr, err := wallet.NewWalletFromFile(path.Join(notaryModulePath, "./testdata/notary1.json"))
	require.NoError(t, err)
	require.NoError(t, ntr.Accounts[0].Decrypt("one", ntr.Scrypt))
	bc.setNodesByRole(t, true, noderoles.P2PNotary, keys.PublicKeys{ntr.Accounts[0].PrivateKey().PublicKey()})
	t.Logf("Designated Notary node: %s", hex.EncodeToString(ntr.Accounts[0].PrivateKey().PublicKey().Bytes()))

	// Block #10: push verification contract with arguments into the chain.
	verifyPath = filepath.Join(prefix, "verify_args", "verification_with_args_contract.go")
	_, _, _ = deployContractFromPriv0(t, verifyPath, "VerifyWithArgs", nil, 3) // block #10

	// Block #11: push NameService contract into the chain.
	nsPath := examplesPrefix + "nft-nd-nns/"
	nsConfigPath := nsPath + "nns.yml"
	_, _, nsHash := deployContractFromPriv0(t, nsPath, nsPath, &nsConfigPath, 4) // block #11

	// Block #12: transfer funds to committee for futher NS record registration.
	transferFundsToCommittee(t, bc) // block #12

	// Block #13: add `.com` root to NNS.
	res, err := invokeContractMethodGeneric(bc, -1,
		nsHash, "addRoot", true, "com") // block #13
	require.NoError(t, err)
	checkResult(t, res, stackitem.Null{})

	// Block #14: register `neo.com` via NNS.
	res, err = invokeContractMethodGeneric(bc, -1,
		nsHash, "register", acc0, "neo.com", priv0ScriptHash) // block #14
	require.NoError(t, err)
	checkResult(t, res, stackitem.NewBool(true))
	require.Equal(t, 1, len(res.Events)) // transfer
	tokenID, err := res.Events[0].Item.Value().([]stackitem.Item)[3].TryBytes()
	require.NoError(t, err)
	t.Logf("NNS token #1 ID (hex): %s", hex.EncodeToString(tokenID))

	// Block #15: set A record type with priv0 owner via NNS.
	res, err = invokeContractMethodGeneric(bc, -1, nsHash,
		"setRecord", acc0, "neo.com", int64(nns.A), "1.2.3.4") // block #15
	require.NoError(t, err)
	checkResult(t, res, stackitem.Null{})

	// Block #16: invoke `test_contract.go`: put new value with the same key to check `getstate` RPC call
	script.Reset()
	emit.AppCall(script.BinWriter, cHash, "putValue", callflag.All, "testkey", "newtestvalue")
	// Invoke `test_contract.go`: put values to check `findstates` RPC call
	emit.AppCall(script.BinWriter, cHash, "putValue", callflag.All, "aa", "v1")
	emit.AppCall(script.BinWriter, cHash, "putValue", callflag.All, "aa10", "v2")
	emit.AppCall(script.BinWriter, cHash, "putValue", callflag.All, "aa50", "v3")
	txInv = transaction.New(script.Bytes(), 1*native.GASFactor)
	txInv.Nonce = getNextNonce()
	txInv.ValidUntilBlock = validUntilBlock
	txInv.Signers = []transaction.Signer{{Account: priv0ScriptHash}}
	require.NoError(t, addNetworkFee(bc, txInv, acc0))
	require.NoError(t, acc0.SignTx(testchain.Network(), txInv))
	b = bc.newBlock(txInv)
	require.NoError(t, bc.AddBlock(b)) // block #16
	checkTxHalt(t, bc, txInv.Hash())

	// Block #17: deploy NeoFS Object contract (NEP11-Divisible).
	nfsPath := examplesPrefix + "nft-d/"
	nfsConfigPath := nfsPath + "nft.yml"
	_, _, nfsHash := deployContractFromPriv0(t, nfsPath, nfsPath, &nfsConfigPath, 5) // block #17

	// Block #18: mint 1.00 NFSO token by transferring 10 GAS to NFSO contract.
	containerID := util.Uint256{1, 2, 3}
	objectID := util.Uint256{4, 5, 6}
	txGas0toNFS := newNEP17Transfer(gasHash, priv0ScriptHash, nfsHash, 10_0000_0000, containerID.BytesBE(), objectID.BytesBE())
	txGas0toNFS.SystemFee += 4000_0000
	txGas0toNFS.Nonce = getNextNonce()
	txGas0toNFS.ValidUntilBlock = validUntilBlock
	txGas0toNFS.Signers = []transaction.Signer{
		{
			Account: priv0ScriptHash,
			Scopes:  transaction.CalledByEntry,
		},
	}
	require.NoError(t, addNetworkFee(bc, txGas0toNFS, acc0))
	require.NoError(t, acc0.SignTx(testchain.Network(), txGas0toNFS))
	b = bc.newBlock(txGas0toNFS)
	require.NoError(t, bc.AddBlock(b)) // block #18
	checkTxHalt(t, bc, txGas0toNFS.Hash())
	aer, _ := bc.GetAppExecResults(txGas0toNFS.Hash(), trigger.Application)
	require.Equal(t, 2, len(aer[0].Events)) // GAS transfer + NFSO transfer
	tokenID, err = aer[0].Events[1].Item.Value().([]stackitem.Item)[3].TryBytes()
	require.NoError(t, err)
	t.Logf("NFSO token #1 ID (hex): %s", hex.EncodeToString(tokenID))

	// Block #19: transfer 0.25 NFSO from priv0 to priv1.
	script.Reset()
	emit.AppCall(script.BinWriter, nfsHash, "transfer", callflag.All, priv0ScriptHash, priv1ScriptHash, 25, tokenID, nil)
	emit.Opcodes(script.BinWriter, opcode.ASSERT)
	require.NoError(t, script.Err)
	txNFS0to1 := transaction.New(script.Bytes(), 1*native.GASFactor)
	txNFS0to1.Nonce = getNextNonce()
	txNFS0to1.ValidUntilBlock = validUntilBlock
	txNFS0to1.Signers = []transaction.Signer{{Account: priv0ScriptHash, Scopes: transaction.CalledByEntry}}
	require.NoError(t, addNetworkFee(bc, txNFS0to1, acc0))
	require.NoError(t, acc0.SignTx(testchain.Network(), txNFS0to1))
	b = bc.newBlock(txNFS0to1)
	require.NoError(t, bc.AddBlock(b)) // block #19
	checkTxHalt(t, bc, txNFS0to1.Hash())

	// Block #20: transfer 1000 GAS to priv1.
	txMoveGas, err = testchain.NewTransferFromOwner(bc, gasHash, priv1ScriptHash, int64(fixedn.Fixed8FromInt64(1000)),
		getNextNonce(), validUntilBlock)
	require.NoError(t, err)
	require.NoError(t, bc.AddBlock(bc.newBlock(txMoveGas)))
	checkTxHalt(t, bc, txMoveGas.Hash()) // block #20

	// Block #21: transfer 0.05 NFSO from priv1 back to priv0.
	script.Reset()
	emit.AppCall(script.BinWriter, nfsHash, "transfer", callflag.All, priv1ScriptHash, priv0.GetScriptHash(), 5, tokenID, nil)
	emit.Opcodes(script.BinWriter, opcode.ASSERT)
	require.NoError(t, script.Err)
	txNFS1to0 := transaction.New(script.Bytes(), 1*native.GASFactor)
	txNFS1to0.Nonce = getNextNonce()
	txNFS1to0.ValidUntilBlock = validUntilBlock
	txNFS1to0.Signers = []transaction.Signer{{Account: priv1ScriptHash, Scopes: transaction.CalledByEntry}}
	require.NoError(t, addNetworkFee(bc, txNFS1to0, acc0))
	require.NoError(t, acc1.SignTx(testchain.Network(), txNFS1to0))
	b = bc.newBlock(txNFS1to0)
	require.NoError(t, bc.AddBlock(b)) // block #21
	checkTxHalt(t, bc, txNFS1to0.Hash())

	// Compile contract to test `invokescript` RPC call
	invokePath := filepath.Join(prefix, "invoke", "invokescript_contract.go")
	invokeCfg := filepath.Join(prefix, "invoke", "invoke.yml")
	_, _ = newDeployTx(t, bc, priv0ScriptHash, invokePath, "ContractForInvokescriptTest", &invokeCfg)
}

func newNEP17Transfer(sc, from, to util.Uint160, amount int64, additionalArgs ...interface{}) *transaction.Transaction {
	return newNEP17TransferWithAssert(sc, from, to, amount, true, additionalArgs...)
}

func newNEP17TransferWithAssert(sc, from, to util.Uint160, amount int64, needAssert bool, additionalArgs ...interface{}) *transaction.Transaction {
	w := io.NewBufBinWriter()
	emit.AppCall(w.BinWriter, sc, "transfer", callflag.All, from, to, amount, additionalArgs)
	if needAssert {
		emit.Opcodes(w.BinWriter, opcode.ASSERT)
	}
	if w.Err != nil {
		panic(fmt.Errorf("failed to create NEP-17 transfer transaction: %w", w.Err))
	}

	script := w.Bytes()
	return transaction.New(script, 11000000)
}

func newDeployTx(t *testing.T, bc *Blockchain, sender util.Uint160, name, ctrName string, cfgName *string) (*transaction.Transaction, util.Uint160) {
	tx, h, avm, err := testchain.NewDeployTx(bc, name, sender, nil, cfgName)
	require.NoError(t, err)
	t.Logf("contract (%s): \n\tHash: %s\n\tAVM: %s", name, h.StringLE(), base64.StdEncoding.EncodeToString(avm))
	return tx, h
}

func addSigners(sender util.Uint160, txs ...*transaction.Transaction) {
	for _, tx := range txs {
		tx.Signers = []transaction.Signer{{
			Account:          sender,
			Scopes:           transaction.Global,
			AllowedContracts: nil,
			AllowedGroups:    nil,
		}}
	}
}

func addNetworkFee(bc *Blockchain, tx *transaction.Transaction, sender *wallet.Account) error {
	size := io.GetVarSize(tx)
	netFee, sizeDelta := fee.Calculate(bc.GetBaseExecFee(), sender.Contract.Script)
	tx.NetworkFee += netFee
	size += sizeDelta
	for _, cosigner := range tx.Signers {
		contract := bc.GetContractState(cosigner.Account)
		if contract != nil {
			netFee, sizeDelta = fee.Calculate(bc.GetBaseExecFee(), contract.NEF.Script)
			tx.NetworkFee += netFee
			size += sizeDelta
		}
	}
	tx.NetworkFee += int64(size) * bc.FeePerByte()
	return nil
}

// Signer can be either bool or *wallet.Account.
// In the first case `true` means sign by committee, `false` means sign by validators.
func prepareContractMethodInvokeGeneric(chain *Blockchain, sysfee int64,
	hash util.Uint160, method string, signer interface{}, args ...interface{}) (*transaction.Transaction, error) {
	w := io.NewBufBinWriter()
	emit.AppCall(w.BinWriter, hash, method, callflag.All, args...)
	if w.Err != nil {
		return nil, w.Err
	}
	script := w.Bytes()
	tx := transaction.New(script, 0)
	tx.ValidUntilBlock = chain.blockHeight + 1
	var err error
	switch s := signer.(type) {
	case bool:
		if s {
			addSigners(testchain.CommitteeScriptHash(), tx)
			setTxSystemFee(chain, sysfee, tx)
			err = testchain.SignTxCommittee(chain, tx)
		} else {
			addSigners(neoOwner, tx)
			setTxSystemFee(chain, sysfee, tx)
			err = testchain.SignTx(chain, tx)
		}
	case *wallet.Account:
		signTxWithAccounts(chain, sysfee, tx, s)
	case []*wallet.Account:
		signTxWithAccounts(chain, sysfee, tx, s...)
	default:
		panic("invalid signer")
	}
	if err != nil {
		return nil, err
	}
	return tx, nil
}

func setTxSystemFee(bc *Blockchain, sysFee int64, tx *transaction.Transaction) {
	if sysFee >= 0 {
		tx.SystemFee = sysFee
		return
	}

	lastBlock := bc.topBlock.Load().(*block.Block)
	b := &block.Block{
		Header: block.Header{
			Index:     lastBlock.Index + 1,
			Timestamp: lastBlock.Timestamp + 1000,
		},
		Transactions: []*transaction.Transaction{tx},
	}

	ttx := *tx // prevent setting 'hash' field
	ic := bc.GetTestVM(trigger.Application, &ttx, b)
	defer ic.Finalize()

	ic.VM.LoadWithFlags(tx.Script, callflag.All)
	_ = ic.VM.Run()
	tx.SystemFee = ic.VM.GasConsumed()
}

func signTxWithAccounts(chain *Blockchain, sysFee int64, tx *transaction.Transaction, accs ...*wallet.Account) {
	scope := transaction.CalledByEntry
	for _, acc := range accs {
		accH, _ := address.StringToUint160(acc.Address)
		tx.Signers = append(tx.Signers, transaction.Signer{
			Account: accH,
			Scopes:  scope,
		})
		scope = transaction.Global
	}
	setTxSystemFee(chain, sysFee, tx)
	size := io.GetVarSize(tx)
	for _, acc := range accs {
		if acc.Contract.Deployed {
			// don't need precise calculation for tests
			tx.NetworkFee += 1000_0000
			continue
		}
		netFee, sizeDelta := fee.Calculate(chain.GetBaseExecFee(), acc.Contract.Script)
		size += sizeDelta
		tx.NetworkFee += netFee
	}
	tx.NetworkFee += int64(size) * chain.FeePerByte()

	for _, acc := range accs {
		if err := acc.SignTx(testchain.Network(), tx); err != nil {
			panic(err)
		}
	}
}

func persistBlock(chain *Blockchain, txs ...*transaction.Transaction) ([]*state.AppExecResult, error) {
	b := chain.newBlock(txs...)
	err := chain.AddBlock(b)
	if err != nil {
		return nil, err
	}

	aers := make([]*state.AppExecResult, len(txs))
	for i, tx := range txs {
		res, err := chain.GetAppExecResults(tx.Hash(), trigger.Application)
		if err != nil {
			return nil, err
		}
		aers[i] = &res[0]
	}
	return aers, nil
}

func invokeContractMethod(chain *Blockchain, sysfee int64, hash util.Uint160, method string, args ...interface{}) (*state.AppExecResult, error) {
	return invokeContractMethodGeneric(chain, sysfee, hash, method, false, args...)
}

func invokeContractMethodGeneric(chain *Blockchain, sysfee int64, hash util.Uint160, method string,
	signer interface{}, args ...interface{}) (*state.AppExecResult, error) {
	tx, err := prepareContractMethodInvokeGeneric(chain, sysfee, hash,
		method, signer, args...)
	if err != nil {
		return nil, err
	}
	aers, err := persistBlock(chain, tx)
	if err != nil {
		return nil, err
	}
	return aers[0], nil
}

func transferTokenFromMultisigAccountCheckOK(t *testing.T, chain *Blockchain, to, tokenHash util.Uint160, amount int64, additionalArgs ...interface{}) {
	transferTx := transferTokenFromMultisigAccount(t, chain, to, tokenHash, amount, additionalArgs...)
	res, err := chain.GetAppExecResults(transferTx.Hash(), trigger.Application)
	require.NoError(t, err)
	require.Equal(t, vm.HaltState, res[0].VMState)
	require.Equal(t, 0, len(res[0].Stack))
}

func transferTokenFromMultisigAccount(t *testing.T, chain *Blockchain, to, tokenHash util.Uint160, amount int64, additionalArgs ...interface{}) *transaction.Transaction {
	return transferTokenFromMultisigAccountWithAssert(t, chain, to, tokenHash, amount, true, additionalArgs...)
}

func transferTokenFromMultisigAccountWithAssert(t *testing.T, chain *Blockchain, to, tokenHash util.Uint160, amount int64, needAssert bool, additionalArgs ...interface{}) *transaction.Transaction {
	transferTx := newNEP17TransferWithAssert(tokenHash, testchain.MultisigScriptHash(), to, amount, needAssert, additionalArgs...)
	transferTx.SystemFee = 100000000
	transferTx.ValidUntilBlock = chain.BlockHeight() + 1
	addSigners(neoOwner, transferTx)
	require.NoError(t, testchain.SignTx(chain, transferTx))
	b := chain.newBlock(transferTx)
	require.NoError(t, chain.AddBlock(b))
	return transferTx
}

func checkResult(t *testing.T, result *state.AppExecResult, expected stackitem.Item) {
	require.Equal(t, vm.HaltState, result.VMState, result.FaultException)
	require.Equal(t, 1, len(result.Stack))
	require.Equal(t, expected, result.Stack[0])
}

func checkTxHalt(t testing.TB, bc *Blockchain, h util.Uint256) {
	aer, err := bc.GetAppExecResults(h, trigger.Application)
	require.NoError(t, err)
	require.Equal(t, 1, len(aer))
	require.Equal(t, vm.HaltState, aer[0].VMState, aer[0].FaultException)
}

func checkFAULTState(t *testing.T, result *state.AppExecResult) {
	require.Equal(t, vm.FaultState, result.VMState)
}

func checkBalanceOf(t *testing.T, chain *Blockchain, addr util.Uint160, expected int) {
	balance := chain.GetUtilityTokenBalance(addr)
	require.Equal(t, int64(expected), balance.Int64())
}

type NotaryFeerStub struct {
	bc blockchainer.Blockchainer
}

func (f NotaryFeerStub) FeePerByte() int64 { return f.bc.FeePerByte() }
func (f NotaryFeerStub) GetUtilityTokenBalance(acc util.Uint160) *big.Int {
	return f.bc.GetNotaryBalance(acc)
}
func (f NotaryFeerStub) BlockHeight() uint32           { return f.bc.BlockHeight() }
func (f NotaryFeerStub) P2PSigExtensionsEnabled() bool { return f.bc.P2PSigExtensionsEnabled() }
func NewNotaryFeerStub(bc blockchainer.Blockchainer) NotaryFeerStub {
	return NotaryFeerStub{
		bc: bc,
	}
}