diff --git a/pkg/core/helper_test.go b/pkg/core/helper_test.go index 342678823..733ecf969 100644 --- a/pkg/core/helper_test.go +++ b/pkg/core/helper_test.go @@ -8,6 +8,7 @@ import ( "io/ioutil" "math/big" "os" + "path" "strings" "testing" "time" @@ -25,6 +26,7 @@ import ( "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/hash" + "github.com/nspcc-dev/neo-go/pkg/crypto/keys" "github.com/nspcc-dev/neo-go/pkg/encoding/fixedn" "github.com/nspcc-dev/neo-go/pkg/io" "github.com/nspcc-dev/neo-go/pkg/smartcontract" @@ -296,9 +298,11 @@ func initBasicChain(t *testing.T, bc *Blockchain) { 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) priv0 := testchain.PrivateKeyByID(0) priv0ScriptHash := priv0.GetScriptHash() @@ -426,6 +430,31 @@ func initBasicChain(t *testing.T, bc *Blockchain) { require.NoError(t, acc0.SignTx(txDeploy2)) b = bc.newBlock(txDeploy2) require.NoError(t, bc.AddBlock(b)) + + // 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(transferTx)) + + b = bc.newBlock(transferTx) + require.NoError(t, bc.AddBlock(b)) + t.Logf("notaryDepositTxPriv0: %v", transferTx.Hash().StringLE()) + + // 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")) + bc.setNodesByRole(t, true, native.RoleP2PNotary, keys.PublicKeys{ntr.Accounts[0].PrivateKey().PublicKey()}) + t.Logf("Designated Notary node: %s", hex.EncodeToString(ntr.Accounts[0].PrivateKey().PublicKey().Bytes())) } func newNEP17Transfer(sc, from, to util.Uint160, amount int64, additionalArgs ...interface{}) *transaction.Transaction { diff --git a/pkg/network/server_test.go b/pkg/network/server_test.go index 85fd51c36..3e3e79292 100644 --- a/pkg/network/server_test.go +++ b/pkg/network/server_test.go @@ -22,7 +22,6 @@ import ( "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/opcode" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.uber.org/atomic" diff --git a/pkg/rpc/server/client_test.go b/pkg/rpc/server/client_test.go index c7980e571..acca59101 100644 --- a/pkg/rpc/server/client_test.go +++ b/pkg/rpc/server/client_test.go @@ -6,6 +6,7 @@ import ( "testing" "github.com/nspcc-dev/neo-go/internal/testchain" + "github.com/nspcc-dev/neo-go/pkg/config/netmode" "github.com/nspcc-dev/neo-go/pkg/core/fee" "github.com/nspcc-dev/neo-go/pkg/core/native/nativenames" "github.com/nspcc-dev/neo-go/pkg/core/transaction" @@ -17,6 +18,7 @@ import ( "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/opcode" "github.com/nspcc-dev/neo-go/pkg/wallet" "github.com/stretchr/testify/require" @@ -214,6 +216,111 @@ func TestSignAndPushInvocationTx(t *testing.T) { require.EqualValues(t, 30, tx.SystemFee) } +func TestSignAndPushP2PNotaryRequest(t *testing.T) { + chain, rpcSrv, httpSrv := initServerWithInMemoryChainAndServices(t, false, true) + defer chain.Close() + defer rpcSrv.Shutdown() + + c, err := client.New(context.Background(), httpSrv.URL, client.Options{}) + require.NoError(t, err) + + t.Run("client wasn't initialized", func(t *testing.T) { + _, err := c.SignAndPushP2PNotaryRequest(nil, nil, 0, 0, 0, nil) + require.NotNil(t, err) + }) + + require.NoError(t, c.Init()) + t.Run("bad account address", func(t *testing.T) { + _, err := c.SignAndPushP2PNotaryRequest(nil, nil, 0, 0, 0, &wallet.Account{Address: "not-an-addr"}) + require.NotNil(t, err) + }) + + acc, err := wallet.NewAccount() + require.NoError(t, err) + t.Run("bad fallback script", func(t *testing.T) { + _, err := c.SignAndPushP2PNotaryRequest(nil, []byte{byte(opcode.ASSERT)}, -1, 0, 0, acc) + require.NotNil(t, err) + }) + + t.Run("too large fallbackValidFor", func(t *testing.T) { + _, err := c.SignAndPushP2PNotaryRequest(nil, []byte{byte(opcode.RET)}, -1, 0, 141, acc) + require.NotNil(t, err) + }) + + t.Run("good", func(t *testing.T) { + sender := testchain.PrivateKeyByID(0) // owner of the deposit in testchain + acc := wallet.NewAccountFromPrivateKey(sender) + expected := transaction.Transaction{ + Network: netmode.UnitTestNet, + Attributes: []transaction.Attribute{{Type: transaction.NotaryAssistedT, Value: &transaction.NotaryAssisted{NKeys: 1}}}, + Script: []byte{byte(opcode.RET)}, + ValidUntilBlock: chain.BlockHeight() + 5, + Signers: []transaction.Signer{{Account: util.Uint160{1, 5, 9}}}, + Scripts: []transaction.Witness{{ + InvocationScript: []byte{1, 4, 7}, + VerificationScript: []byte{3, 6, 9}, + }}, + } + mainTx := expected + _ = expected.Hash() + req, err := c.SignAndPushP2PNotaryRequest(&mainTx, []byte{byte(opcode.RET)}, -1, 0, 6, acc) + require.NoError(t, err) + + // check that request was correctly completed + require.Equal(t, expected, *req.MainTransaction) // main tx should be the same + require.ElementsMatch(t, []transaction.Attribute{ + { + Type: transaction.NotaryAssistedT, + Value: &transaction.NotaryAssisted{NKeys: 0}, + }, + { + Type: transaction.NotValidBeforeT, + Value: &transaction.NotValidBefore{Height: chain.BlockHeight()}, + }, + { + Type: transaction.ConflictsT, + Value: &transaction.Conflicts{Hash: mainTx.Hash()}, + }, + }, req.FallbackTransaction.Attributes) + require.Equal(t, []transaction.Signer{ + {Account: chain.GetNotaryContractScriptHash()}, + {Account: acc.PrivateKey().GetScriptHash()}, + }, req.FallbackTransaction.Signers) + + // it shouldn't be an error to add completed fallback to the chain + w, err := wallet.NewWalletFromFile(notaryPath) + require.NoError(t, err) + ntr := w.Accounts[0] + ntr.Decrypt(notaryPass) + req.FallbackTransaction.Scripts[0] = transaction.Witness{ + InvocationScript: append([]byte{byte(opcode.PUSHDATA1), 64}, ntr.PrivateKey().Sign(req.FallbackTransaction.GetSignedPart())...), + VerificationScript: []byte{}, + } + b := testchain.NewBlock(t, chain, 1, 0, req.FallbackTransaction) + require.NoError(t, chain.AddBlock(b)) + appLogs, err := chain.GetAppExecResults(req.FallbackTransaction.Hash(), trigger.Application) + require.NoError(t, err) + require.Equal(t, 1, len(appLogs)) + appLog := appLogs[0] + require.Equal(t, vm.HaltState, appLog.VMState) + require.Equal(t, appLog.GasConsumed, req.FallbackTransaction.SystemFee) + }) +} + +func TestCalculateNotaryFee(t *testing.T) { + chain, rpcSrv, httpSrv := initServerWithInMemoryChain(t) + defer chain.Close() + defer rpcSrv.Shutdown() + + c, err := client.New(context.Background(), httpSrv.URL, client.Options{}) + require.NoError(t, err) + + t.Run("client not initialized", func(t *testing.T) { + _, err := c.CalculateNotaryFee(0) + require.NotNil(t, err) + }) +} + func TestPing(t *testing.T) { chain, rpcSrv, httpSrv := initServerWithInMemoryChain(t) defer chain.Close() diff --git a/pkg/rpc/server/server_helper_test.go b/pkg/rpc/server/server_helper_test.go index 3511ac5c2..aacb7961e 100644 --- a/pkg/rpc/server/server_helper_test.go +++ b/pkg/rpc/server/server_helper_test.go @@ -23,7 +23,12 @@ import ( "go.uber.org/zap/zaptest" ) -func getUnitTestChain(t *testing.T, enableOracle bool) (*core.Blockchain, *oracle.Oracle, config.Config, *zap.Logger) { +const ( + notaryPath = "../../services/notary/testdata/notary1.json" + notaryPass = "one" +) + +func getUnitTestChain(t *testing.T, enableOracle bool, enableNotary bool) (*core.Blockchain, *oracle.Oracle, config.Config, *zap.Logger) { net := netmode.UnitTestNet configPath := "../../../config" cfg, err := config.Load(configPath, net) @@ -31,6 +36,19 @@ func getUnitTestChain(t *testing.T, enableOracle bool) (*core.Blockchain, *oracl memoryStore := storage.NewMemoryStore() logger := zaptest.NewLogger(t) + if enableNotary { + cfg.ProtocolConfiguration.P2PSigExtensions = true + cfg.ProtocolConfiguration.P2PNotaryRequestPayloadPoolSize = 1000 + cfg.ProtocolConfiguration.P2PNotary = config.P2PNotary{ + Enabled: true, + UnlockWallet: config.Wallet{ + Path: notaryPath, + Password: notaryPass, + }, + } + } else { + cfg.ProtocolConfiguration.P2PNotary.Enabled = false + } chain, err := core.NewBlockchain(memoryStore, cfg.ProtocolConfiguration, logger) require.NoError(t, err, "could not create chain") @@ -79,8 +97,8 @@ func getTestBlocks(t *testing.T) []*block.Block { return blocks } -func initClearServerWithOracle(t *testing.T, needOracle bool) (*core.Blockchain, *Server, *httptest.Server) { - chain, orc, cfg, logger := getUnitTestChain(t, needOracle) +func initClearServerWithServices(t *testing.T, needOracle bool, needNotary bool) (*core.Blockchain, *Server, *httptest.Server) { + chain, orc, cfg, logger := getUnitTestChain(t, needOracle, needNotary) serverConfig := network.NewServerConfig(cfg) server, err := network.NewServer(serverConfig, chain, logger) @@ -96,7 +114,7 @@ func initClearServerWithOracle(t *testing.T, needOracle bool) (*core.Blockchain, } func initClearServerWithInMemoryChain(t *testing.T) (*core.Blockchain, *Server, *httptest.Server) { - return initClearServerWithOracle(t, false) + return initClearServerWithServices(t, false, false) } func initServerWithInMemoryChain(t *testing.T) (*core.Blockchain, *Server, *httptest.Server) { @@ -108,6 +126,15 @@ func initServerWithInMemoryChain(t *testing.T) (*core.Blockchain, *Server, *http return chain, rpcServer, srv } +func initServerWithInMemoryChainAndServices(t *testing.T, needOracle bool, needNotary bool) (*core.Blockchain, *Server, *httptest.Server) { + chain, rpcServer, srv := initClearServerWithServices(t, needOracle, needNotary) + + for _, b := range getTestBlocks(t) { + require.NoError(t, chain.AddBlock(b)) + } + return chain, rpcServer, srv +} + type FeerStub struct{} func (fs *FeerStub) FeePerByte() int64 { diff --git a/pkg/rpc/server/server_test.go b/pkg/rpc/server/server_test.go index fc68ae6e3..fbeebd2a2 100644 --- a/pkg/rpc/server/server_test.go +++ b/pkg/rpc/server/server_test.go @@ -19,6 +19,7 @@ import ( "github.com/gorilla/websocket" "github.com/nspcc-dev/neo-go/internal/testchain" "github.com/nspcc-dev/neo-go/internal/testserdes" + "github.com/nspcc-dev/neo-go/pkg/config/netmode" "github.com/nspcc-dev/neo-go/pkg/core" "github.com/nspcc-dev/neo-go/pkg/core/block" "github.com/nspcc-dev/neo-go/pkg/core/fee" @@ -27,6 +28,7 @@ import ( "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/io" + "github.com/nspcc-dev/neo-go/pkg/network/payload" "github.com/nspcc-dev/neo-go/pkg/rpc/response" "github.com/nspcc-dev/neo-go/pkg/rpc/response/result" rpc2 "github.com/nspcc-dev/neo-go/pkg/services/oracle/broadcaster" @@ -58,7 +60,7 @@ type rpcTestCase struct { } const testContractHash = "c6436aab21ebd15279b85af8d7b5808d38455b0a" -const deploymentTxHash = "9a9d6b0876d1e6cfd68efadd0facaaba7e07efbe7b24282d094a0893645581f3" +const deploymentTxHash = "d0de42d5d23211174a50d74fbd4a919631236a63f16431a5a7e7126759e7ba23" const genesisBlockHash = "0542f4350c6e236d0509bcd98188b0034bfbecc1a0c7fcdb8e4295310d468b70" const verifyContractHash = "03ffc0897543b9b709e0f8cab4a7682dae0ba943" @@ -649,7 +651,7 @@ var rpcTestCases = map[string][]rpcTestCase{ require.True(t, ok) expected := result.UnclaimedGas{ Address: testchain.MultisigScriptHash(), - Unclaimed: *big.NewInt(3500), + Unclaimed: *big.NewInt(4500), } assert.Equal(t, expected, *actual) }, @@ -918,6 +920,13 @@ var rpcTestCases = map[string][]rpcTestCase{ fail: true, }, }, + "submitnotaryrequest": { + { + name: "no params", + params: `[]`, + fail: true, + }, + }, "validateaddress": { { name: "positive", @@ -954,7 +963,7 @@ func TestRPC(t *testing.T) { } func TestSubmitOracle(t *testing.T) { - chain, rpcSrv, httpSrv := initClearServerWithOracle(t, true) + chain, rpcSrv, httpSrv := initClearServerWithServices(t, true, false) defer chain.Close() defer rpcSrv.Shutdown() @@ -986,6 +995,121 @@ func TestSubmitOracle(t *testing.T) { t.Run("Valid", runCase(t, false, pubStr, `1`, txSigStr, msgSigStr)) } +func TestSubmitNotaryRequest(t *testing.T) { + rpc := `{"jsonrpc": "2.0", "id": 1, "method": "submitnotaryrequest", "params": %s}` + + t.Run("disabled P2PSigExtensions", func(t *testing.T) { + chain, rpcSrv, httpSrv := initClearServerWithServices(t, false, false) + defer chain.Close() + defer rpcSrv.Shutdown() + req := fmt.Sprintf(rpc, "[]") + body := doRPCCallOverHTTP(req, httpSrv.URL, t) + checkErrGetResult(t, body, true) + }) + + chain, rpcSrv, httpSrv := initServerWithInMemoryChainAndServices(t, false, true) + defer chain.Close() + defer rpcSrv.Shutdown() + + runCase := func(t *testing.T, fail bool, params ...string) func(t *testing.T) { + return func(t *testing.T) { + ps := `[` + strings.Join(params, ",") + `]` + req := fmt.Sprintf(rpc, ps) + body := doRPCCallOverHTTP(req, httpSrv.URL, t) + checkErrGetResult(t, body, fail) + } + } + t.Run("missing request", runCase(t, true)) + t.Run("not a base64", runCase(t, true, `"not-a-base64$"`)) + t.Run("invalid request bytes", runCase(t, true, `"not-a-request"`)) + t.Run("invalid request", func(t *testing.T) { + mainTx := &transaction.Transaction{ + Network: netmode.UnitTestNet, + Attributes: []transaction.Attribute{{Type: transaction.NotaryAssistedT, Value: &transaction.NotaryAssisted{NKeys: 1}}}, + Script: []byte{byte(opcode.RET)}, + ValidUntilBlock: 123, + Signers: []transaction.Signer{{Account: util.Uint160{1, 5, 9}}}, + Scripts: []transaction.Witness{{ + InvocationScript: []byte{1, 4, 7}, + VerificationScript: []byte{3, 6, 9}, + }}, + } + fallbackTx := &transaction.Transaction{ + Network: netmode.UnitTestNet, + Script: []byte{byte(opcode.RET)}, + ValidUntilBlock: 123, + Attributes: []transaction.Attribute{ + {Type: transaction.NotValidBeforeT, Value: &transaction.NotValidBefore{Height: 123}}, + {Type: transaction.ConflictsT, Value: &transaction.Conflicts{Hash: mainTx.Hash()}}, + {Type: transaction.NotaryAssistedT, Value: &transaction.NotaryAssisted{NKeys: 0}}, + }, + Signers: []transaction.Signer{{Account: util.Uint160{1, 4, 7}}, {Account: util.Uint160{9, 8, 7}}}, + Scripts: []transaction.Witness{ + {InvocationScript: append([]byte{byte(opcode.PUSHDATA1), 64}, make([]byte, 64, 64)...), VerificationScript: make([]byte, 0)}, + {InvocationScript: []byte{1, 2, 3}, VerificationScript: []byte{1, 2, 3}}}, + } + p := &payload.P2PNotaryRequest{ + Network: netmode.UnitTestNet, + MainTransaction: mainTx, + FallbackTransaction: fallbackTx, + Witness: transaction.Witness{ + InvocationScript: []byte{1, 2, 3}, + VerificationScript: []byte{7, 8, 9}, + }, + } + bytes, err := p.Bytes() + require.NoError(t, err) + str := fmt.Sprintf(`"%s"`, base64.StdEncoding.EncodeToString(bytes)) + runCase(t, true, str)(t) + }) + t.Run("valid request", func(t *testing.T) { + sender := testchain.PrivateKeyByID(0) // owner of the deposit in testchain + mainTx := &transaction.Transaction{ + Network: netmode.UnitTestNet, + Attributes: []transaction.Attribute{{Type: transaction.NotaryAssistedT, Value: &transaction.NotaryAssisted{NKeys: 1}}}, + Script: []byte{byte(opcode.RET)}, + ValidUntilBlock: 123, + Signers: []transaction.Signer{{Account: util.Uint160{1, 5, 9}}}, + Scripts: []transaction.Witness{{ + InvocationScript: []byte{1, 4, 7}, + VerificationScript: []byte{3, 6, 9}, + }}, + } + fallbackTx := &transaction.Transaction{ + Network: netmode.UnitTestNet, + Script: []byte{byte(opcode.RET)}, + ValidUntilBlock: 123, + Attributes: []transaction.Attribute{ + {Type: transaction.NotValidBeforeT, Value: &transaction.NotValidBefore{Height: 123}}, + {Type: transaction.ConflictsT, Value: &transaction.Conflicts{Hash: mainTx.Hash()}}, + {Type: transaction.NotaryAssistedT, Value: &transaction.NotaryAssisted{NKeys: 0}}, + }, + Signers: []transaction.Signer{{Account: chain.GetNotaryContractScriptHash()}, {Account: sender.GetScriptHash()}}, + Scripts: []transaction.Witness{ + {InvocationScript: append([]byte{byte(opcode.PUSHDATA1), 64}, make([]byte, 64, 64)...), VerificationScript: []byte{}}, + }, + NetworkFee: 2_0000_0000, + } + fallbackTx.Scripts = append(fallbackTx.Scripts, transaction.Witness{ + InvocationScript: append([]byte{byte(opcode.PUSHDATA1), 64}, sender.Sign(fallbackTx.GetSignedPart())...), + VerificationScript: sender.PublicKey().GetVerificationScript(), + }) + p := &payload.P2PNotaryRequest{ + Network: netmode.UnitTestNet, + MainTransaction: mainTx, + FallbackTransaction: fallbackTx, + } + p.Witness = transaction.Witness{ + InvocationScript: append([]byte{byte(opcode.PUSHDATA1), 64}, sender.Sign(p.GetSignedPart())...), + VerificationScript: sender.PublicKey().GetVerificationScript(), + } + bytes, err := p.Bytes() + require.NoError(t, err) + str := fmt.Sprintf(`"%s"`, base64.StdEncoding.EncodeToString(bytes)) + runCase(t, false, str)(t) + }) +} + // testRPCProtocol runs a full set of tests using given callback to make actual // calls. Some tests change the chain state, thus we reinitialize the chain from // scratch here. @@ -1246,7 +1370,7 @@ func testRPCProtocol(t *testing.T, doRPCCall func(string, string, *testing.T) [] require.NoErrorf(t, err, "could not parse response: %s", txOut) assert.Equal(t, *block.Transactions[0], actual.Transaction) - assert.Equal(t, 8, actual.Confirmations) + assert.Equal(t, 10, actual.Confirmations) assert.Equal(t, TXHash, actual.Transaction.Hash()) }) @@ -1364,12 +1488,12 @@ func testRPCProtocol(t *testing.T, doRPCCall func(string, string, *testing.T) [] require.NoError(t, json.Unmarshal(res, actual)) checkNep17TransfersAux(t, e, actual, sent, rcvd) } - t.Run("time frame only", func(t *testing.T) { testNEP17T(t, 4, 5, 0, 0, []int{3, 4, 5, 6}, []int{1, 2}) }) + t.Run("time frame only", func(t *testing.T) { testNEP17T(t, 4, 5, 0, 0, []int{5, 6, 7, 8}, []int{1, 2}) }) t.Run("no res", func(t *testing.T) { testNEP17T(t, 100, 100, 0, 0, []int{}, []int{}) }) - t.Run("limit", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 0, []int{0, 1}, []int{0}) }) - t.Run("limit 2", func(t *testing.T) { testNEP17T(t, 4, 5, 2, 0, []int{3}, []int{1}) }) - t.Run("limit with page", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 1, []int{2, 3}, []int{1}) }) - t.Run("limit with page 2", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 2, []int{4, 5}, []int{2}) }) + t.Run("limit", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 0, []int{2, 3}, []int{0}) }) + t.Run("limit 2", func(t *testing.T) { testNEP17T(t, 4, 5, 2, 0, []int{5}, []int{1}) }) + t.Run("limit with page", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 1, []int{4, 5}, []int{1}) }) + t.Run("limit with page 2", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 2, []int{6, 7}, []int{2}) }) }) } @@ -1474,8 +1598,8 @@ func checkNep17Balances(t *testing.T, e *executor, acc interface{}) { }, { Asset: e.chain.UtilityTokenHash(), - Amount: "80006665650", - LastUpdated: 7, + Amount: "78994306100", + LastUpdated: 8, }}, Address: testchain.PrivateKeyByID(0).GetScriptHash().StringLE(), } @@ -1484,7 +1608,7 @@ func checkNep17Balances(t *testing.T, e *executor, acc interface{}) { } func checkNep17Transfers(t *testing.T, e *executor, acc interface{}) { - checkNep17TransfersAux(t, e, acc, []int{0, 1, 2, 3, 4, 5, 6, 7, 8}, []int{0, 1, 2, 3, 4, 5, 6}) + checkNep17TransfersAux(t, e, acc, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, []int{0, 1, 2, 3, 4, 5, 6}) } func checkNep17TransfersAux(t *testing.T, e *executor, acc interface{}, sent, rcvd []int) { @@ -1493,6 +1617,11 @@ func checkNep17TransfersAux(t *testing.T, e *executor, acc interface{}, sent, rc rublesHash, err := util.Uint160DecodeStringLE(testContractHash) require.NoError(t, err) + blockDepositGAS, err := e.chain.GetBlock(e.chain.GetHeaderHash(8)) + require.NoError(t, err) + require.Equal(t, 1, len(blockDepositGAS.Transactions)) + txDepositGAS := blockDepositGAS.Transactions[0] + blockDeploy2, err := e.chain.GetBlock(e.chain.GetHeaderHash(7)) require.NoError(t, err) require.Equal(t, 1, len(blockDeploy2.Transactions)) @@ -1541,6 +1670,23 @@ func checkNep17TransfersAux(t *testing.T, e *executor, acc interface{}, sent, rc // duplicate the Server method. expected := result.NEP17Transfers{ Sent: []result.NEP17Transfer{ + { + Timestamp: blockDepositGAS.Timestamp, + Asset: e.chain.UtilityTokenHash(), + Address: address.Uint160ToString(e.chain.GetNotaryContractScriptHash()), + Amount: "1000000000", + Index: 8, + NotifyIndex: 0, + TxHash: txDepositGAS.Hash(), + }, + { + Timestamp: blockDepositGAS.Timestamp, + Asset: e.chain.UtilityTokenHash(), + Address: "", // burn + Amount: big.NewInt(txDepositGAS.SystemFee + txDepositGAS.NetworkFee).String(), + Index: 8, + TxHash: blockDepositGAS.Hash(), + }, { Timestamp: blockDeploy2.Timestamp, Asset: e.chain.UtilityTokenHash(), diff --git a/pkg/rpc/server/testdata/testblocks.acc b/pkg/rpc/server/testdata/testblocks.acc index d8320664d..48120fe74 100644 Binary files a/pkg/rpc/server/testdata/testblocks.acc and b/pkg/rpc/server/testdata/testblocks.acc differ