From 22c39d391625b60c074a72ea50ddc04cf57d0226 Mon Sep 17 00:00:00 2001
From: Anna Shaleva <anna@nspcc.ru>
Date: Mon, 7 Feb 2022 11:38:04 +0300
Subject: [PATCH 1/5] examples: properly store owner of nft-d token

---
 examples/nft-d/nft.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/nft-d/nft.go b/examples/nft-d/nft.go
index d7f18ec7ad..18d36adc3c 100644
--- a/examples/nft-d/nft.go
+++ b/examples/nft-d/nft.go
@@ -383,7 +383,7 @@ func OnNEP17Payment(from interop.Hash160, amount int, data interface{}) {
 
 	total := totalSupply(ctx)
 
-	addOwner(ctx, from, id)
+	addOwner(ctx, id, from)
 	addToBalance(ctx, from, id, multiplier)
 
 	total++

From 3c75f047c142b9c53ee695840edd3fc4b226a280 Mon Sep 17 00:00:00 2001
From: Anna Shaleva <shaleva.ann@nspcc.ru>
Date: Fri, 4 Feb 2022 19:18:35 +0300
Subject: [PATCH 2/5] cli: refactor nep11-related commands and add tests

Specify tokenID via hex-encoded string.
---
 cli/executor_test.go   |   1 +
 cli/nep11_test.go      | 317 +++++++++++++++++++++++++++++++++++++----
 cli/wallet/nep11.go    |  69 +++++++--
 cli/wallet/nep17.go    |   9 +-
 examples/nft-d/nft.go  |  25 ++--
 examples/nft-d/nft.yml |   2 +-
 examples/nft-nd/nft.go |   2 +-
 7 files changed, 371 insertions(+), 54 deletions(-)

diff --git a/cli/executor_test.go b/cli/executor_test.go
index a82d8fc32e..587aba713a 100644
--- a/cli/executor_test.go
+++ b/cli/executor_test.go
@@ -40,6 +40,7 @@ const (
 	testWalletAccount = "Nfyz4KcsgYepRJw1W5C2uKCi6QWKf7v6gG"
 
 	validatorWallet = "testdata/wallet1_solo.json"
+	validatorPass   = "one"
 )
 
 var (
diff --git a/cli/nep11_test.go b/cli/nep11_test.go
index e86d63042a..a3a3125ed2 100644
--- a/cli/nep11_test.go
+++ b/cli/nep11_test.go
@@ -2,12 +2,15 @@ package main
 
 import (
 	"bytes"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"math/big"
 	"path/filepath"
-	"strings"
+	"strconv"
 	"testing"
 
 	"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
@@ -35,6 +38,8 @@ func TestNEP11Import(t *testing.T) {
 
 	// deploy NFT NeoNameService contract
 	nnsContractHash := deployNNSContract(t, e)
+	// deploy NFT-D NeoFS Object contract
+	nfsContractHash := deployNFSContract(t, e)
 	neoContractHash, err := e.Chain.GetNativeContractScriptHash(nativenames.Neo)
 	require.NoError(t, err)
 	e.Run(t, "neo-go", "wallet", "init", "--wallet", walletPath)
@@ -47,33 +52,38 @@ func TestNEP11Import(t *testing.T) {
 	// missing token hash
 	e.RunWithError(t, args...)
 
-	// good
+	// good: non-divisible
 	e.Run(t, append(args, "--token", nnsContractHash.StringLE())...)
 
+	// good: divisible
+	e.Run(t, append(args, "--token", nfsContractHash.StringLE())...)
+
 	// already exists
 	e.RunWithError(t, append(args, "--token", nnsContractHash.StringLE())...)
 
 	// not a NEP-11 token
 	e.RunWithError(t, append(args, "--token", neoContractHash.StringLE())...)
 
+	checkInfo := func(t *testing.T, h util.Uint160, name string, symbol string, decimals int) {
+		e.checkNextLine(t, "^Name:\\s*"+name)
+		e.checkNextLine(t, "^Symbol:\\s*"+symbol)
+		e.checkNextLine(t, "^Hash:\\s*"+h.StringLE())
+		e.checkNextLine(t, "^Decimals:\\s*"+strconv.Itoa(decimals))
+		e.checkNextLine(t, "^Address:\\s*"+address.Uint160ToString(h))
+		e.checkNextLine(t, "^Standard:\\s*"+string(manifest.NEP11StandardName))
+	}
 	t.Run("Info", func(t *testing.T) {
-		checkNNSInfo := func(t *testing.T) {
-			e.checkNextLine(t, "^Name:\\s*NameService")
-			e.checkNextLine(t, "^Symbol:\\s*NNS")
-			e.checkNextLine(t, "^Hash:\\s*"+nnsContractHash.StringLE())
-			e.checkNextLine(t, "^Decimals:\\s*0")
-			e.checkNextLine(t, "^Address:\\s*"+address.Uint160ToString(nnsContractHash))
-			e.checkNextLine(t, "^Standard:\\s*"+string(manifest.NEP11StandardName))
-		}
 		t.Run("WithToken", func(t *testing.T) {
 			e.Run(t, "neo-go", "wallet", "nep11", "info",
 				"--wallet", walletPath, "--token", nnsContractHash.StringLE())
-			checkNNSInfo(t)
+			checkInfo(t, nnsContractHash, "NameService", "NNS", 0)
 		})
 		t.Run("NoToken", func(t *testing.T) {
 			e.Run(t, "neo-go", "wallet", "nep11", "info",
 				"--wallet", walletPath)
-			checkNNSInfo(t)
+			checkInfo(t, nnsContractHash, "NameService", "NNS", 0)
+			e.checkNextLine(t, "")
+			checkInfo(t, nfsContractHash, "NeoFS Object NFT", "NFSO", 2)
 		})
 	})
 
@@ -83,12 +93,13 @@ func TestNEP11Import(t *testing.T) {
 			"--wallet", walletPath, "--token", nnsContractHash.StringLE())
 		e.Run(t, "neo-go", "wallet", "nep11", "info",
 			"--wallet", walletPath)
+		checkInfo(t, nfsContractHash, "NeoFS Object NFT", "NFSO", 2)
 		_, err := e.Out.ReadString('\n')
 		require.Equal(t, err, io.EOF)
 	})
 }
 
-func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
+func TestNEP11_ND_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 	e := newExecutor(t, true)
 	tmpDir := t.TempDir()
 
@@ -190,7 +201,7 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 
 	// ownerOf: missing token ID
 	e.RunWithError(t, cmdOwnerOf...)
-	cmdOwnerOf = append(cmdOwnerOf, "--id", string(tokenID))
+	cmdOwnerOf = append(cmdOwnerOf, "--id", hex.EncodeToString(tokenID))
 
 	// ownerOf: good
 	e.Run(t, cmdOwnerOf...)
@@ -209,7 +220,7 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 
 	// tokensOf: good
 	e.Run(t, cmdTokensOf...)
-	require.Equal(t, string(tokenID), e.getNextLine(t))
+	require.Equal(t, hex.EncodeToString(tokenID), e.getNextLine(t))
 
 	// properties: no contract
 	cmdProperties := []string{
@@ -221,12 +232,11 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 
 	// properties: no token ID
 	e.RunWithError(t, cmdProperties...)
-	cmdProperties = append(cmdProperties, "--id", string(tokenID))
+	cmdProperties = append(cmdProperties, "--id", hex.EncodeToString(tokenID))
 
 	// properties: ok
 	e.Run(t, cmdProperties...)
-	marshalledID := strings.Replace(string(tokenID), "+", "\\u002B", -1)
-	require.Equal(t, fmt.Sprintf(`{"name":"HASHY %s"}`, marshalledID), e.getNextLine(t))
+	require.Equal(t, fmt.Sprintf(`{"name":"HASHY %s"}`, base64.StdEncoding.EncodeToString(tokenID)), e.getNextLine(t))
 
 	// tokensOf: good, several tokens
 	tokenID1 := mint(t)
@@ -236,8 +246,8 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 		fst, snd = snd, fst
 	}
 
-	require.Equal(t, string(fst), e.getNextLine(t))
-	require.Equal(t, string(snd), e.getNextLine(t))
+	require.Equal(t, hex.EncodeToString(fst), e.getNextLine(t))
+	require.Equal(t, hex.EncodeToString(snd), e.getNextLine(t))
 
 	// tokens: missing contract hash
 	cmdTokens := []string{"neo-go", "wallet", "nep11", "tokens",
@@ -248,8 +258,8 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 
 	// tokens: good, several tokens
 	e.Run(t, cmdTokens...)
-	require.Equal(t, string(fst), e.getNextLine(t))
-	require.Equal(t, string(snd), e.getNextLine(t))
+	require.Equal(t, hex.EncodeToString(fst), e.getNextLine(t))
+	require.Equal(t, hex.EncodeToString(snd), e.getNextLine(t))
 
 	// balance check: several tokens, ok
 	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE())...)
@@ -276,7 +286,7 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 
 	// transfer: good
 	e.In.WriteString(nftOwnerPass + "\r")
-	e.Run(t, append(cmdTransfer, "--id", string(tokenID))...)
+	e.Run(t, append(cmdTransfer, "--id", hex.EncodeToString(tokenID))...)
 	e.checkTxPersisted(t)
 
 	// check balance after transfer
@@ -292,7 +302,7 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 		"--to", verifyH.StringLE(),
 		"--from", nftOwnerAddr,
 		"--token", h.StringLE(),
-		"--id", string(tokenID1),
+		"--id", hex.EncodeToString(tokenID1),
 		"--force",
 		"string:some_data",
 	}
@@ -321,10 +331,267 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 	checkBalanceResult(t, nftOwnerAddr, "0")
 }
 
+func TestNEP11_D_OwnerOf_BalanceOf_Transfer(t *testing.T) {
+	e := newExecutor(t, true)
+	tmpDir := t.TempDir()
+
+	// copy wallet to temp dir in order not to overwrite the original file
+	bytesRead, err := ioutil.ReadFile(validatorWallet)
+	require.NoError(t, err)
+	wall := filepath.Join(tmpDir, "my_wallet.json")
+	err = ioutil.WriteFile(wall, bytesRead, 0755)
+	require.NoError(t, err)
+
+	// deploy NeoFS Object contract
+	h := deployNFSContract(t, e)
+
+	mint := func(t *testing.T, containerID, objectID util.Uint256) []byte {
+		// mint 1.00 NFSO token by transferring 10 GAS to NFSO contract
+		e.In.WriteString(validatorPass + "\r")
+		e.Run(t, "neo-go", "wallet", "nep17", "transfer",
+			"--rpc-endpoint", "http://"+e.RPC.Addr,
+			"--wallet", wall,
+			"--to", h.StringLE(),
+			"--token", "GAS",
+			"--amount", "10",
+			"--force",
+			"--from", validatorAddr,
+			"--", "[", "hash256:"+containerID.StringLE(), "hash256:"+objectID.StringLE(), "]",
+		)
+		txMint, _ := e.checkTxPersisted(t)
+
+		// get NFT ID from AER
+		aer, err := e.Chain.GetAppExecResults(txMint.Hash(), trigger.Application)
+		require.NoError(t, err)
+		require.Equal(t, 1, len(aer))
+		require.Equal(t, 2, len(aer[0].Events))
+		nfsoMintEvent := aer[0].Events[1]
+		require.Equal(t, "Transfer", nfsoMintEvent.Name)
+		tokenID, err := nfsoMintEvent.Item.Value().([]stackitem.Item)[3].TryBytes()
+		require.NoError(t, err)
+		require.NotNil(t, tokenID)
+		return tokenID
+	}
+
+	container1ID := util.Uint256{1, 2, 3}
+	object1ID := util.Uint256{4, 5, 6}
+	token1ID := mint(t, container1ID, object1ID)
+
+	container2ID := util.Uint256{7, 8, 9}
+	object2ID := util.Uint256{10, 11, 12}
+	token2ID := mint(t, container2ID, object2ID)
+
+	// check properties
+	e.Run(t, "neo-go", "wallet", "nep11", "properties",
+		"--rpc-endpoint", "http://"+e.RPC.Addr,
+		"--token", h.StringLE(),
+		"--id", hex.EncodeToString(token1ID))
+	jProps := e.getNextLine(t)
+	props := make(map[string]string)
+	require.NoError(t, json.Unmarshal([]byte(jProps), &props))
+	require.Equal(t, base64.StdEncoding.EncodeToString(container1ID.BytesBE()), props["containerID"])
+	require.Equal(t, base64.StdEncoding.EncodeToString(object1ID.BytesBE()), props["objectID"])
+	e.checkEOF(t)
+
+	// check the balance
+	cmdCheckBalance := []string{"neo-go", "wallet", "nep11", "balance",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+		"--wallet", wall,
+		"--address", validatorAddr}
+	checkBalanceResult := func(t *testing.T, acc string, amount string, id []byte) {
+		e.checkNextLine(t, "^\\s*Account\\s+"+acc)
+		if id == nil {
+			e.checkNextLine(t, "^\\s*NFSO:\\s+NeoFS Object NFT \\("+h.StringLE()+"\\)")
+		} else {
+			e.checkNextLine(t, "^\\s*NFSO:\\s+NeoFS Object NFT \\("+h.StringLE()+", "+hex.EncodeToString(id)+"\\)")
+		}
+		e.checkNextLine(t, "^\\s*Amount\\s*:\\s*"+amount+"$")
+		e.checkEOF(t)
+	}
+	// balance check: by symbol, token is not imported
+	e.RunWithError(t, append(cmdCheckBalance, "--token", "NFSO")...)
+
+	// overall NFSO balance check: by hash, ok
+	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE())...)
+	checkBalanceResult(t, validatorAddr, "2", nil)
+
+	// particular NFSO balance check: by hash, ok
+	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE(), "--id", hex.EncodeToString(token2ID))...)
+	checkBalanceResult(t, validatorAddr, "1", token2ID)
+
+	// import token
+	e.Run(t, "neo-go", "wallet", "nep11", "import",
+		"--rpc-endpoint", "http://"+e.RPC.Addr,
+		"--wallet", wall,
+		"--token", h.StringLE())
+
+	// overall balance check: by symbol, ok
+	e.Run(t, append(cmdCheckBalance, "--token", "NFSO")...)
+	checkBalanceResult(t, validatorAddr, "2", nil)
+
+	// particular balance check: by symbol, ok
+	e.Run(t, append(cmdCheckBalance, "--token", "NFSO", "--id", hex.EncodeToString(token1ID))...)
+	checkBalanceResult(t, validatorAddr, "1", token1ID)
+
+	// remove token from wallet
+	e.In.WriteString("y\r")
+	e.Run(t, "neo-go", "wallet", "nep11", "remove",
+		"--wallet", wall, "--token", h.StringLE())
+
+	// ownerOfD: missing contract hash
+	cmdOwnerOf := []string{"neo-go", "wallet", "nep11", "ownerOfD",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+	}
+	e.RunWithError(t, cmdOwnerOf...)
+	cmdOwnerOf = append(cmdOwnerOf, "--token", h.StringLE())
+
+	// ownerOfD: missing token ID
+	e.RunWithError(t, cmdOwnerOf...)
+	cmdOwnerOf = append(cmdOwnerOf, "--id", hex.EncodeToString(token1ID))
+
+	// ownerOfD: good
+	e.Run(t, cmdOwnerOf...)
+	e.checkNextLine(t, validatorAddr)
+
+	// tokensOf: missing contract hash
+	cmdTokensOf := []string{"neo-go", "wallet", "nep11", "tokensOf",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+	}
+	e.RunWithError(t, cmdTokensOf...)
+	cmdTokensOf = append(cmdTokensOf, "--token", h.StringLE())
+
+	// tokensOf: missing owner address
+	e.RunWithError(t, cmdTokensOf...)
+	cmdTokensOf = append(cmdTokensOf, "--address", validatorAddr)
+
+	// tokensOf: good
+	e.Run(t, cmdTokensOf...)
+	require.Equal(t, hex.EncodeToString(token1ID), e.getNextLine(t))
+	require.Equal(t, hex.EncodeToString(token2ID), e.getNextLine(t))
+	e.checkEOF(t)
+
+	// properties: no contract
+	cmdProperties := []string{
+		"neo-go", "wallet", "nep11", "properties",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+	}
+	e.RunWithError(t, cmdProperties...)
+	cmdProperties = append(cmdProperties, "--token", h.StringLE())
+
+	// properties: no token ID
+	e.RunWithError(t, cmdProperties...)
+	cmdProperties = append(cmdProperties, "--id", hex.EncodeToString(token2ID))
+
+	// properties: ok
+	e.Run(t, cmdProperties...)
+	jProps = e.getNextLine(t)
+	props = make(map[string]string)
+	require.NoError(t, json.Unmarshal([]byte(jProps), &props))
+	require.Equal(t, base64.StdEncoding.EncodeToString(container2ID.BytesBE()), props["containerID"])
+	require.Equal(t, base64.StdEncoding.EncodeToString(object2ID.BytesBE()), props["objectID"])
+	e.checkEOF(t)
+
+	// tokensOf: good, several tokens
+	e.Run(t, cmdTokensOf...)
+	fst, snd := token1ID, token2ID
+	if bytes.Compare(token1ID, token2ID) == 1 {
+		fst, snd = snd, fst
+	}
+
+	require.Equal(t, hex.EncodeToString(fst), e.getNextLine(t))
+	require.Equal(t, hex.EncodeToString(snd), e.getNextLine(t))
+
+	// tokens: missing contract hash
+	cmdTokens := []string{"neo-go", "wallet", "nep11", "tokens",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+	}
+	e.RunWithError(t, cmdTokens...)
+	cmdTokens = append(cmdTokens, "--token", h.StringLE())
+
+	// tokens: good, several tokens
+	e.Run(t, cmdTokens...)
+	require.Equal(t, hex.EncodeToString(fst), e.getNextLine(t))
+	require.Equal(t, hex.EncodeToString(snd), e.getNextLine(t))
+
+	// balance check: several tokens, ok
+	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE())...)
+	checkBalanceResult(t, validatorAddr, "2", nil)
+
+	cmdTransfer := []string{
+		"neo-go", "wallet", "nep11", "transfer",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+		"--wallet", wall,
+		"--to", nftOwnerAddr,
+		"--from", validatorAddr,
+		"--force",
+	}
+
+	// transfer: unimported token with symbol id specified
+	e.In.WriteString(validatorPass + "\r")
+	e.RunWithError(t, append(cmdTransfer,
+		"--token", "NFSO")...)
+	cmdTransfer = append(cmdTransfer, "--token", h.StringLE())
+
+	// transfer: no id specified
+	e.In.WriteString(validatorPass + "\r")
+	e.RunWithError(t, cmdTransfer...)
+
+	// transfer: good
+	e.In.WriteString(validatorPass + "\r")
+	e.Run(t, append(cmdTransfer, "--id", hex.EncodeToString(token1ID))...)
+	e.checkTxPersisted(t)
+
+	// check balance after transfer
+	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE())...)
+	checkBalanceResult(t, validatorAddr, "1", nil) // only token2ID expected to be on the balance
+
+	// transfer: good, 1/4 of the balance, to NEP-11-Payable contract, with data
+	verifyH := deployVerifyContract(t, e)
+	cmdTransfer = []string{
+		"neo-go", "wallet", "nep11", "transfer",
+		"--rpc-endpoint", "http://" + e.RPC.Addr,
+		"--wallet", wall,
+		"--to", verifyH.StringLE(),
+		"--from", validatorAddr,
+		"--token", h.StringLE(),
+		"--id", hex.EncodeToString(token2ID),
+		"--amount", "0.25",
+		"--force",
+		"string:some_data",
+	}
+	e.In.WriteString(validatorPass + "\r")
+	e.Run(t, cmdTransfer...)
+	tx, _ := e.checkTxPersisted(t)
+	// check OnNEP11Payment event
+	aer, err := e.Chain.GetAppExecResults(tx.Hash(), trigger.Application)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(aer[0].Events))
+	validatorHash, err := address.StringToUint160(validatorAddr)
+	require.NoError(t, err)
+	require.Equal(t, state.NotificationEvent{
+		ScriptHash: verifyH,
+		Name:       "OnNEP11Payment",
+		Item: stackitem.NewArray([]stackitem.Item{
+			stackitem.NewByteArray(validatorHash.BytesBE()),
+			stackitem.NewBigInteger(big.NewInt(25)),
+			stackitem.NewByteArray(token2ID),
+			stackitem.NewByteArray([]byte("some_data")),
+		}),
+	}, aer[0].Events[1])
+
+	// check balance after transfer
+	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE())...)
+	checkBalanceResult(t, validatorAddr, "0.75", nil)
+}
+
+func deployNFSContract(t *testing.T, e *executor) util.Uint160 {
+	return deployContract(t, e, "../examples/nft-d/nft.go", "../examples/nft-d/nft.yml", validatorWallet, validatorAddr, validatorPass)
+}
+
 func deployNFTContract(t *testing.T, e *executor) util.Uint160 {
 	return deployContract(t, e, "../examples/nft-nd/nft.go", "../examples/nft-nd/nft.yml", nftOwnerWallet, nftOwnerAddr, nftOwnerPass)
 }
 
 func deployNNSContract(t *testing.T, e *executor) util.Uint160 {
-	return deployContract(t, e, "../examples/nft-nd-nns/", "../examples/nft-nd-nns/nns.yml", validatorWallet, validatorAddr, "one")
+	return deployContract(t, e, "../examples/nft-nd-nns/", "../examples/nft-nd-nns/nns.yml", validatorWallet, validatorAddr, validatorPass)
 }
diff --git a/cli/wallet/nep11.go b/cli/wallet/nep11.go
index 5ce8ea7b89..d5adb21c00 100644
--- a/cli/wallet/nep11.go
+++ b/cli/wallet/nep11.go
@@ -1,6 +1,7 @@
 package wallet
 
 import (
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"math/big"
@@ -31,7 +32,7 @@ func newNEP11Commands() []cli.Command {
 	}
 	tokenID := cli.StringFlag{
 		Name:  "id",
-		Usage: "Token ID",
+		Usage: "Hex-encoded token ID",
 	}
 
 	balanceFlags := make([]cli.Flag, len(baseBalanceFlags))
@@ -107,7 +108,17 @@ func newNEP11Commands() []cli.Command {
 			Name:      "ownerOf",
 			Usage:     "print owner of non-divisible NEP-11 token with the specified ID",
 			UsageText: "ownerOf --rpc-endpoint <node> --timeout <time> --token <hash> --id <token-id>",
-			Action:    printNEP11Owner,
+			Action:    printNEP11NDOwner,
+			Flags: append([]cli.Flag{
+				tokenAddressFlag,
+				tokenID,
+			}, options.RPC...),
+		},
+		{
+			Name:      "ownerOfD",
+			Usage:     "print set of owners of divisible NEP-11 token with the specified ID",
+			UsageText: "ownerOfD --rpc-endpoint <node> --timeout <time> --token <hash> --id <token-id>",
+			Action:    printNEP11DOwner,
 			Flags: append([]cli.Flag{
 				tokenAddressFlag,
 				tokenID,
@@ -196,6 +207,10 @@ func getNEP11Balance(ctx *cli.Context) error {
 	}
 
 	tokenID := ctx.String("id")
+	tokenIDBytes, err := hex.DecodeString(tokenID)
+	if err != nil {
+		return cli.NewExitError(fmt.Errorf("invalid tokenID bytes: %w", err), 1)
+	}
 	for k, acc := range accounts {
 		addrHash, err := address.StringToUint160(acc.Address)
 		if err != nil {
@@ -208,10 +223,10 @@ func getNEP11Balance(ctx *cli.Context) error {
 		fmt.Fprintf(ctx.App.Writer, "Account %s\n", acc.Address)
 
 		var amount int64
-		if tokenID == "" {
+		if len(tokenIDBytes) == 0 {
 			amount, err = c.NEP11BalanceOf(token.Hash, addrHash)
 		} else {
-			amount, err = c.NEP11DBalanceOf(token.Hash, addrHash, tokenID)
+			amount, err = c.NEP11DBalanceOf(token.Hash, addrHash, tokenIDBytes)
 		}
 		if err != nil {
 			continue
@@ -220,7 +235,7 @@ func getNEP11Balance(ctx *cli.Context) error {
 
 		format := "%s: %s (%s)\n"
 		formatArgs := []interface{}{token.Symbol, token.Name, token.Hash.StringLE()}
-		if tokenID != "" {
+		if len(tokenIDBytes) != 0 {
 			format = "%s: %s (%s, %s)\n"
 			formatArgs = append(formatArgs, tokenID)
 		}
@@ -234,7 +249,7 @@ func transferNEP11(ctx *cli.Context) error {
 	return transferNEP(ctx, manifest.NEP11StandardName)
 }
 
-func signAndSendNEP11Transfer(ctx *cli.Context, c *client.Client, acc *wallet.Account, token, to util.Uint160, tokenID string, amount *big.Int, data interface{}, cosigners []client.SignerAccount) error {
+func signAndSendNEP11Transfer(ctx *cli.Context, c *client.Client, acc *wallet.Account, token, to util.Uint160, tokenID []byte, amount *big.Int, data interface{}, cosigners []client.SignerAccount) error {
 	gas := flags.Fixed8FromContext(ctx, "gas")
 	sysgas := flags.Fixed8FromContext(ctx, "sysgas")
 
@@ -279,7 +294,15 @@ func signAndSendNEP11Transfer(ctx *cli.Context, c *client.Client, acc *wallet.Ac
 	return nil
 }
 
-func printNEP11Owner(ctx *cli.Context) error {
+func printNEP11NDOwner(ctx *cli.Context) error {
+	return printNEP11Owner(ctx, false)
+}
+
+func printNEP11DOwner(ctx *cli.Context) error {
+	return printNEP11Owner(ctx, true)
+}
+
+func printNEP11Owner(ctx *cli.Context, divisible bool) error {
 	var err error
 	tokenHash := ctx.Generic("token").(*flags.Address)
 	if !tokenHash.IsSet {
@@ -290,6 +313,10 @@ func printNEP11Owner(ctx *cli.Context) error {
 	if tokenID == "" {
 		return cli.NewExitError(errors.New("token ID should be specified"), 1)
 	}
+	tokenIDBytes, err := hex.DecodeString(tokenID)
+	if err != nil {
+		return cli.NewExitError(fmt.Errorf("invalid tokenID bytes: %w", err), 1)
+	}
 
 	gctx, cancel := options.GetTimeoutContext(ctx)
 	defer cancel()
@@ -299,12 +326,22 @@ func printNEP11Owner(ctx *cli.Context) error {
 		return cli.NewExitError(err, 1)
 	}
 
-	result, err := c.NEP11NDOwnerOf(tokenHash.Uint160(), tokenID)
-	if err != nil {
-		return cli.NewExitError(fmt.Sprintf("failed to call NEP-11 `ownerOf` method: %s", err.Error()), 1)
+	if divisible {
+		result, err := c.NEP11DOwnerOf(tokenHash.Uint160(), tokenIDBytes)
+		if err != nil {
+			return cli.NewExitError(fmt.Sprintf("failed to call NEP-11 divisible `ownerOf` method: %s", err.Error()), 1)
+		}
+		for _, h := range result {
+			fmt.Fprintln(ctx.App.Writer, address.Uint160ToString(h))
+		}
+	} else {
+		result, err := c.NEP11NDOwnerOf(tokenHash.Uint160(), tokenIDBytes)
+		if err != nil {
+			return cli.NewExitError(fmt.Sprintf("failed to call NEP-11 non-divisible `ownerOf` method: %s", err.Error()), 1)
+		}
+		fmt.Fprintln(ctx.App.Writer, address.Uint160ToString(result))
 	}
 
-	fmt.Fprintln(ctx.App.Writer, address.Uint160ToString(result))
 	return nil
 }
 
@@ -334,7 +371,7 @@ func printNEP11TokensOf(ctx *cli.Context) error {
 	}
 
 	for i := range result {
-		fmt.Fprintln(ctx.App.Writer, result[i])
+		fmt.Fprintln(ctx.App.Writer, hex.EncodeToString(result[i]))
 	}
 	return nil
 }
@@ -360,7 +397,7 @@ func printNEP11Tokens(ctx *cli.Context) error {
 	}
 
 	for i := range result {
-		fmt.Fprintln(ctx.App.Writer, result[i])
+		fmt.Fprintln(ctx.App.Writer, hex.EncodeToString(result[i]))
 	}
 	return nil
 }
@@ -376,6 +413,10 @@ func printNEP11Properties(ctx *cli.Context) error {
 	if tokenID == "" {
 		return cli.NewExitError(errors.New("token ID should be specified"), 1)
 	}
+	tokenIDBytes, err := hex.DecodeString(tokenID)
+	if err != nil {
+		return cli.NewExitError(fmt.Errorf("invalid tokenID bytes: %w", err), 1)
+	}
 
 	gctx, cancel := options.GetTimeoutContext(ctx)
 	defer cancel()
@@ -385,7 +426,7 @@ func printNEP11Properties(ctx *cli.Context) error {
 		return cli.NewExitError(err, 1)
 	}
 
-	result, err := c.NEP11Properties(tokenHash.Uint160(), tokenID)
+	result, err := c.NEP11Properties(tokenHash.Uint160(), tokenIDBytes)
 	if err != nil {
 		return cli.NewExitError(fmt.Sprintf("failed to call NEP-11 `properties` method: %s", err.Error()), 1)
 	}
diff --git a/cli/wallet/nep17.go b/cli/wallet/nep17.go
index ecb055b3c1..417c488fe1 100644
--- a/cli/wallet/nep17.go
+++ b/cli/wallet/nep17.go
@@ -1,6 +1,7 @@
 package wallet
 
 import (
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"math/big"
@@ -618,14 +619,18 @@ func transferNEP(ctx *cli.Context, standard string) error {
 		if tokenID == "" {
 			return cli.NewExitError(errors.New("token ID should be specified"), 1)
 		}
+		tokenIDBytes, err := hex.DecodeString(tokenID)
+		if err != nil {
+			return cli.NewExitError(fmt.Errorf("invalid token ID: %w", err), 1)
+		}
 		if amountArg == "" {
-			return signAndSendNEP11Transfer(ctx, c, acc, token.Hash, to, tokenID, nil, data, cosignersAccounts)
+			return signAndSendNEP11Transfer(ctx, c, acc, token.Hash, to, tokenIDBytes, nil, data, cosignersAccounts)
 		}
 		amount, err := fixedn.FromString(amountArg, int(token.Decimals))
 		if err != nil {
 			return cli.NewExitError(fmt.Errorf("invalid amount: %w", err), 1)
 		}
-		return signAndSendNEP11Transfer(ctx, c, acc, token.Hash, to, tokenID, amount, data, cosignersAccounts)
+		return signAndSendNEP11Transfer(ctx, c, acc, token.Hash, to, tokenIDBytes, amount, data, cosignersAccounts)
 	default:
 		return cli.NewExitError(fmt.Errorf("unsupported token standard %s", standard), 1)
 	}
diff --git a/examples/nft-d/nft.go b/examples/nft-d/nft.go
index 18d36adc3c..ed238f5285 100644
--- a/examples/nft-d/nft.go
+++ b/examples/nft-d/nft.go
@@ -10,6 +10,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/interop"
 	"github.com/nspcc-dev/neo-go/pkg/interop/contract"
 	"github.com/nspcc-dev/neo-go/pkg/interop/iterator"
+	"github.com/nspcc-dev/neo-go/pkg/interop/native/crypto"
 	"github.com/nspcc-dev/neo-go/pkg/interop/native/gas"
 	"github.com/nspcc-dev/neo-go/pkg/interop/native/management"
 	"github.com/nspcc-dev/neo-go/pkg/interop/native/std"
@@ -30,7 +31,7 @@ const (
 	balancePrefix = "b"
 	// tokenOwnerPrefix contains map from [token id + owner] to token's owner.
 	tokenOwnerPrefix = "t"
-	// tokenPrefix contains map from token id to empty array.
+	// tokenPrefix contains map from token id to its properties (serialised containerID + objectID).
 	tokenPrefix = "i"
 )
 
@@ -231,12 +232,13 @@ func Properties(id []byte) map[string]string {
 	if !isTokenValid(ctx, id) {
 		panic("unknown token")
 	}
-	t := std.Deserialize(id).(ObjectIdentifier)
+	key := mkTokenKey(id)
+	props := storage.Get(ctx, key).([]byte)
+	t := std.Deserialize(props).(ObjectIdentifier)
 	result := map[string]string{
-		"name":        "NFSO " + string(id),
-		"fullName":    "NeoFS Object",
-		"containerID": string(t.ContainerID),
-		"objectID":    string(t.ObjectID),
+		"name":        "NeoFS Object " + std.Base64Encode(id), // Not a hex for contract simplicity.
+		"containerID": std.Base64Encode(t.ContainerID),
+		"objectID":    std.Base64Encode(t.ObjectID),
 	}
 	return result
 }
@@ -360,11 +362,11 @@ func OnNEP17Payment(from interop.Hash160, amount int, data interface{}) {
 		panic("invalid 'data'")
 	}
 	containerID := tokenInfo[0].([]byte)
-	if len(containerID) != 32 {
+	if len(containerID) != interop.Hash256Len {
 		panic("invalid container ID")
 	}
 	objectID := tokenInfo[1].([]byte)
-	if len(objectID) != 32 {
+	if len(objectID) != interop.Hash256Len {
 		panic("invalid object ID")
 	}
 
@@ -372,14 +374,15 @@ func OnNEP17Payment(from interop.Hash160, amount int, data interface{}) {
 		ContainerID: containerID,
 		ObjectID:    objectID,
 	}
-	id := std.Serialize(t)
+	props := std.Serialize(t)
+	id := crypto.Ripemd160(props)
 
 	var ctx = storage.GetContext()
 	if isTokenValid(ctx, id) {
-		panic("NFSO for the specified address is already minted")
+		panic("NFSO for the specified object is already minted")
 	}
 	key := mkTokenKey(id)
-	storage.Put(ctx, key, []byte{})
+	storage.Put(ctx, key, props)
 
 	total := totalSupply(ctx)
 
diff --git a/examples/nft-d/nft.yml b/examples/nft-d/nft.yml
index 04df586814..0253f6705b 100644
--- a/examples/nft-d/nft.yml
+++ b/examples/nft-d/nft.yml
@@ -1,4 +1,4 @@
-name: "NFSO NFT"
+name: "NeoFS Object NFT"
 sourceurl: https://github.com/nspcc-dev/neo-go/
 supportedstandards: ["NEP-11"]
 safemethods: ["balanceOf", "decimals", "symbol", "totalSupply", "tokensOf", "ownerOf", "properties", "tokens"]
diff --git a/examples/nft-nd/nft.go b/examples/nft-nd/nft.go
index ffa1c49568..d544438029 100644
--- a/examples/nft-nd/nft.go
+++ b/examples/nft-nd/nft.go
@@ -273,7 +273,7 @@ func Properties(id []byte) map[string]string {
 		panic("unknown token")
 	}
 	result := map[string]string{
-		"name": "HASHY " + string(id),
+		"name": "HASHY " + std.Base64Encode(id), // Not a hex for contract simplicity.
 	}
 	return result
 }

From 91350c3a481269ad5ebef33d47a5c7dea9ba956c Mon Sep 17 00:00:00 2001
From: Anna Shaleva <shaleva.ann@nspcc.ru>
Date: Fri, 4 Feb 2022 19:20:03 +0300
Subject: [PATCH 3/5] internal: fix contract compilation code

Overloads need to be fetched from config.
---
 internal/testchain/transaction.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/internal/testchain/transaction.go b/internal/testchain/transaction.go
index 30529c73ae..7ce408ba10 100644
--- a/internal/testchain/transaction.go
+++ b/internal/testchain/transaction.go
@@ -68,6 +68,7 @@ func NewDeployTx(bc blockchainer.Blockchainer, name string, sender util.Uint160,
 			return nil, util.Uint160{}, nil, fmt.Errorf("failed to parse configuration: %w", err)
 		}
 		o.Name = conf.Name
+		o.SourceURL = conf.SourceURL
 		o.ContractEvents = conf.Events
 		o.ContractSupportedStandards = conf.SupportedStandards
 		o.Permissions = make([]manifest.Permission, len(conf.Permissions))
@@ -75,6 +76,7 @@ func NewDeployTx(bc blockchainer.Blockchainer, name string, sender util.Uint160,
 			o.Permissions[i] = manifest.Permission(conf.Permissions[i])
 		}
 		o.SafeMethods = conf.SafeMethods
+		o.Overloads = conf.Overloads
 	}
 
 	ne, di, err := compiler.CompileWithOptions(name, r, o)

From 47652643df5e768344658d1fec8db1923bcbf0b6 Mon Sep 17 00:00:00 2001
From: Anna Shaleva <anna@nspcc.ru>
Date: Wed, 9 Feb 2022 11:55:07 +0300
Subject: [PATCH 4/5] rpc: accept NEP11 token IDs as []byte for client methods

Accepting IDs as string is encoding-ambiguous, so make it []byte instead.
---
 pkg/rpc/client/helper.go      |  6 ++++++
 pkg/rpc/client/nep.go         |  6 +++---
 pkg/rpc/client/nep11.go       | 34 +++++++++++++++++-----------------
 pkg/rpc/server/client_test.go |  4 ++--
 4 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/pkg/rpc/client/helper.go b/pkg/rpc/client/helper.go
index ed06747863..e4bc74b790 100644
--- a/pkg/rpc/client/helper.go
+++ b/pkg/rpc/client/helper.go
@@ -110,6 +110,12 @@ func topIterableFromStack(st []stackitem.Item, resultItemType interface{}) ([]in
 	result := make([]interface{}, len(iter.Values))
 	for i := range iter.Values {
 		switch resultItemType.(type) {
+		case []byte:
+			bytes, err := iter.Values[i].TryBytes()
+			if err != nil {
+				return nil, fmt.Errorf("failed to deserialize []byte from stackitem #%d: %w", i, err)
+			}
+			result[i] = bytes
 		case string:
 			bytes, err := iter.Values[i].TryBytes()
 			if err != nil {
diff --git a/pkg/rpc/client/nep.go b/pkg/rpc/client/nep.go
index 8fb07db1b9..56dc65f3bb 100644
--- a/pkg/rpc/client/nep.go
+++ b/pkg/rpc/client/nep.go
@@ -51,15 +51,15 @@ func (c *Client) nepTotalSupply(tokenHash util.Uint160) (int64, error) {
 }
 
 // nepBalanceOf invokes `balanceOf` NEP* method on a specified contract.
-func (c *Client) nepBalanceOf(tokenHash, acc util.Uint160, tokenID *string) (int64, error) {
+func (c *Client) nepBalanceOf(tokenHash, acc util.Uint160, tokenID []byte) (int64, error) {
 	params := []smartcontract.Parameter{{
 		Type:  smartcontract.Hash160Type,
 		Value: acc,
 	}}
 	if tokenID != nil {
 		params = append(params, smartcontract.Parameter{
-			Type:  smartcontract.StringType,
-			Value: *tokenID,
+			Type:  smartcontract.ByteArrayType,
+			Value: tokenID,
 		})
 	}
 	result, err := c.InvokeFunction(tokenHash, "balanceOf", params, nil)
diff --git a/pkg/rpc/client/nep11.go b/pkg/rpc/client/nep11.go
index 32c7c13c4d..1a744e435e 100644
--- a/pkg/rpc/client/nep11.go
+++ b/pkg/rpc/client/nep11.go
@@ -86,7 +86,7 @@ func (c *Client) CreateNEP11TransferTx(acc *wallet.Account, tokenHash util.Uint1
 }
 
 // NEP11TokensOf returns an array of token IDs for the specified owner of the specified NFT token.
-func (c *Client) NEP11TokensOf(tokenHash util.Uint160, owner util.Uint160) ([]string, error) {
+func (c *Client) NEP11TokensOf(tokenHash util.Uint160, owner util.Uint160) ([][]byte, error) {
 	result, err := c.InvokeFunction(tokenHash, "tokensOf", []smartcontract.Parameter{
 		{
 			Type:  smartcontract.Hash160Type,
@@ -101,13 +101,13 @@ func (c *Client) NEP11TokensOf(tokenHash util.Uint160, owner util.Uint160) ([]st
 		return nil, err
 	}
 
-	arr, err := topIterableFromStack(result.Stack, string(""))
+	arr, err := topIterableFromStack(result.Stack, []byte{})
 	if err != nil {
 		return nil, fmt.Errorf("failed to get token IDs from stack: %w", err)
 	}
-	ids := make([]string, len(arr))
+	ids := make([][]byte, len(arr))
 	for i := range ids {
-		ids[i] = arr[i].(string)
+		ids[i] = arr[i].([]byte)
 	}
 	return ids, nil
 }
@@ -116,10 +116,10 @@ func (c *Client) NEP11TokensOf(tokenHash util.Uint160, owner util.Uint160) ([]st
 
 // NEP11NDOwnerOf invokes `ownerOf` non-devisible NEP-11 method with the
 // specified token ID on a specified contract.
-func (c *Client) NEP11NDOwnerOf(tokenHash util.Uint160, tokenID string) (util.Uint160, error) {
+func (c *Client) NEP11NDOwnerOf(tokenHash util.Uint160, tokenID []byte) (util.Uint160, error) {
 	result, err := c.InvokeFunction(tokenHash, "ownerOf", []smartcontract.Parameter{
 		{
-			Type:  smartcontract.StringType,
+			Type:  smartcontract.ByteArrayType,
 			Value: tokenID,
 		},
 	}, nil)
@@ -143,7 +143,7 @@ func (c *Client) NEP11NDOwnerOf(tokenHash util.Uint160, tokenID string) (util.Ui
 // (in FixedN format using contract's number of decimals) to given account and
 // sends it to the network returning just a hash of it.
 func (c *Client) TransferNEP11D(acc *wallet.Account, to util.Uint160,
-	tokenHash util.Uint160, amount int64, tokenID string, data interface{}, gas int64, cosigners []SignerAccount) (util.Uint256, error) {
+	tokenHash util.Uint160, amount int64, tokenID []byte, data interface{}, gas int64, cosigners []SignerAccount) (util.Uint256, error) {
 	if !c.initDone {
 		return util.Uint256{}, errNetworkNotInitialized
 	}
@@ -161,15 +161,15 @@ func (c *Client) TransferNEP11D(acc *wallet.Account, to util.Uint160,
 
 // NEP11DBalanceOf invokes `balanceOf` divisible NEP-11 method on a
 // specified contract.
-func (c *Client) NEP11DBalanceOf(tokenHash, owner util.Uint160, tokenID string) (int64, error) {
-	return c.nepBalanceOf(tokenHash, owner, &tokenID)
+func (c *Client) NEP11DBalanceOf(tokenHash, owner util.Uint160, tokenID []byte) (int64, error) {
+	return c.nepBalanceOf(tokenHash, owner, tokenID)
 }
 
 // NEP11DOwnerOf returns list of the specified NEP-11 divisible token owners.
-func (c *Client) NEP11DOwnerOf(tokenHash util.Uint160, tokenID string) ([]util.Uint160, error) {
+func (c *Client) NEP11DOwnerOf(tokenHash util.Uint160, tokenID []byte) ([]util.Uint160, error) {
 	result, err := c.InvokeFunction(tokenHash, "ownerOf", []smartcontract.Parameter{
 		{
-			Type:  smartcontract.StringType,
+			Type:  smartcontract.ByteArrayType,
 			Value: tokenID,
 		},
 	}, nil)
@@ -198,9 +198,9 @@ func (c *Client) NEP11DOwnerOf(tokenHash util.Uint160, tokenID string) ([]util.U
 
 // NEP11Properties invokes `properties` optional NEP-11 method on a
 // specified contract.
-func (c *Client) NEP11Properties(tokenHash util.Uint160, tokenID string) (*stackitem.Map, error) {
+func (c *Client) NEP11Properties(tokenHash util.Uint160, tokenID []byte) (*stackitem.Map, error) {
 	result, err := c.InvokeFunction(tokenHash, "properties", []smartcontract.Parameter{{
-		Type:  smartcontract.StringType,
+		Type:  smartcontract.ByteArrayType,
 		Value: tokenID,
 	}}, nil)
 	if err != nil {
@@ -215,7 +215,7 @@ func (c *Client) NEP11Properties(tokenHash util.Uint160, tokenID string) (*stack
 }
 
 // NEP11Tokens returns list of the tokens minted by the contract.
-func (c *Client) NEP11Tokens(tokenHash util.Uint160) ([]string, error) {
+func (c *Client) NEP11Tokens(tokenHash util.Uint160) ([][]byte, error) {
 	result, err := c.InvokeFunction(tokenHash, "tokens", []smartcontract.Parameter{}, nil)
 	if err != nil {
 		return nil, err
@@ -225,13 +225,13 @@ func (c *Client) NEP11Tokens(tokenHash util.Uint160) ([]string, error) {
 		return nil, err
 	}
 
-	arr, err := topIterableFromStack(result.Stack, string(""))
+	arr, err := topIterableFromStack(result.Stack, []byte{})
 	if err != nil {
 		return nil, fmt.Errorf("failed to get token IDs from stack: %w", err)
 	}
-	tokens := make([]string, len(arr))
+	tokens := make([][]byte, len(arr))
 	for i := range tokens {
-		tokens[i] = arr[i].(string)
+		tokens[i] = arr[i].([]byte)
 	}
 	return tokens, nil
 }
diff --git a/pkg/rpc/server/client_test.go b/pkg/rpc/server/client_test.go
index 8cc48633c8..2baf7b00ea 100644
--- a/pkg/rpc/server/client_test.go
+++ b/pkg/rpc/server/client_test.go
@@ -846,12 +846,12 @@ func TestClient_NEP11(t *testing.T) {
 		require.EqualValues(t, 1, b)
 	})
 	t.Run("OwnerOf", func(t *testing.T) {
-		b, err := c.NEP11NDOwnerOf(h, "neo.com")
+		b, err := c.NEP11NDOwnerOf(h, []byte("neo.com"))
 		require.NoError(t, err)
 		require.EqualValues(t, acc, b)
 	})
 	t.Run("Properties", func(t *testing.T) {
-		p, err := c.NEP11Properties(h, "neo.com")
+		p, err := c.NEP11Properties(h, []byte("neo.com"))
 		require.NoError(t, err)
 		blockRegisterDomain, err := chain.GetBlock(chain.GetHeaderHash(14)) // `neo.com` domain was registered in 14th block
 		require.NoError(t, err)

From e306a90554625132231f3d9bf580b119254d3789 Mon Sep 17 00:00:00 2001
From: Anna Shaleva <shaleva.ann@nspcc.ru>
Date: Fri, 4 Feb 2022 19:21:12 +0300
Subject: [PATCH 5/5] rpc: add NEP11-D tests to server and client

Also refactor basic chain creation.
---
 pkg/core/helper_test.go                | 180 ++++++++++-----
 pkg/core/statesync_test.go             |   7 +-
 pkg/rpc/server/client_test.go          |  91 ++++++--
 pkg/rpc/server/server_helper_test.go   |   2 +-
 pkg/rpc/server/server_test.go          | 300 ++++++++++++++++++++-----
 pkg/rpc/server/testdata/testblocks.acc | Bin 24765 -> 33175 bytes
 6 files changed, 446 insertions(+), 134 deletions(-)

diff --git a/pkg/core/helper_test.go b/pkg/core/helper_test.go
index f915d9264c..23ecede291 100644
--- a/pkg/core/helper_test.go
+++ b/pkg/core/helper_test.go
@@ -279,16 +279,34 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 
 	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
-	// Move some NEO to one simple account.
+
+	// 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())
@@ -322,25 +340,15 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 	b.Header.EncodeBinary(buf.BinWriter)
 	t.Logf("header: %s", hex.EncodeToString(buf.Bytes()))
 
-	acc0 := wallet.NewAccountFromPrivateKey(priv0)
-
-	// Push some contract into the chain.
+	// Block #2: deploy test_contract.
 	cfgPath := prefix + "test_contract.yml"
-	txDeploy, cHash := newDeployTx(t, bc, priv0ScriptHash, prefix+"test_contract.go", "Rubl", &cfgPath)
-	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))
-	checkTxHalt(t, bc, txDeploy.Hash())
-	t.Logf("txDeploy: %s", txDeploy.Hash().StringLE())
-	t.Logf("Block2 hash: %s", b.Hash().StringLE())
+	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())
 
-	// Now invoke this contract.
+	// 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
@@ -352,8 +360,8 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 	checkTxHalt(t, bc, txInv.Hash())
 	t.Logf("txInv: %s", txInv.Hash().StringLE())
 
-	priv1 := testchain.PrivateKeyByID(1)
-	txNeo0to1 := newNEP17Transfer(neoHash, priv0ScriptHash, priv1.GetScriptHash(), 1000)
+	// 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{
@@ -370,6 +378,7 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 	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)
@@ -378,7 +387,7 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 	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, priv0.GetScriptHash(), 1000)
+	transferTx := newNEP17Transfer(cHash, cHash, priv0ScriptHash, 1000)
 	transferTx.Nonce = getNextNonce()
 	transferTx.ValidUntilBlock = validUntilBlock
 	transferTx.Signers = []transaction.Signer{
@@ -392,14 +401,14 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 	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())
 
-	transferTx = newNEP17Transfer(cHash, priv0.GetScriptHash(), priv1.GetScriptHash(), 123)
+	// 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{
@@ -413,24 +422,16 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 	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())
 
-	// Push verification contract into the chain.
+	// Block #7: push verification contract into the chain.
 	verifyPath := filepath.Join(prefix, "verify", "verification_contract.go")
-	txDeploy2, _ := newDeployTx(t, bc, priv0ScriptHash, verifyPath, "Verify", nil)
-	txDeploy2.Nonce = getNextNonce()
-	txDeploy2.ValidUntilBlock = validUntilBlock
-	require.NoError(t, addNetworkFee(bc, txDeploy2, acc0))
-	require.NoError(t, acc0.SignTx(testchain.Network(), txDeploy2))
-	b = bc.newBlock(txDeploy2)
-	require.NoError(t, bc.AddBlock(b))
-	checkTxHalt(t, bc, txDeploy2.Hash())
+	_, _, _ = deployContractFromPriv0(t, verifyPath, "Verify", nil, 2)
 
-	// Deposit some GAS to notary contract for priv0
+	// 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
@@ -443,68 +444,59 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 	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())
 
-	// Designate new Notary node
+	// 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()))
 
-	// Push verification contract with arguments into the chain.
+	// Block #10: push verification contract with arguments into the chain.
 	verifyPath = filepath.Join(prefix, "verify_args", "verification_with_args_contract.go")
-	txDeploy3, _ := newDeployTx(t, bc, priv0ScriptHash, verifyPath, "VerifyWithArgs", nil)
-	txDeploy3.Nonce = getNextNonce()
-	txDeploy3.ValidUntilBlock = validUntilBlock
-	require.NoError(t, addNetworkFee(bc, txDeploy3, acc0))
-	require.NoError(t, acc0.SignTx(testchain.Network(), txDeploy3))
-	b = bc.newBlock(txDeploy3)
-	require.NoError(t, bc.AddBlock(b)) // block #10
-	checkTxHalt(t, bc, txDeploy3.Hash())
-
-	// Push NameService contract into the chain.
+	_, _, _ = 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"
-	txDeploy4, _ := newDeployTx(t, bc, priv0ScriptHash, nsPath, nsPath, &nsConfigPath)
-	txDeploy4.Nonce = getNextNonce()
-	txDeploy4.ValidUntilBlock = validUntilBlock
-	require.NoError(t, addNetworkFee(bc, txDeploy4, acc0))
-	require.NoError(t, acc0.SignTx(testchain.Network(), txDeploy4))
-	b = bc.newBlock(txDeploy4)
-	require.NoError(t, bc.AddBlock(b)) // block #11
-	checkTxHalt(t, bc, txDeploy4.Hash())
-	nsHash, err := bc.GetContractScriptHash(4)
-	require.NoError(t, err)
-	t.Logf("contract (%s): \n\tHash: %s\n", nsPath, nsHash.StringLE())
+	_, _, nsHash := deployContractFromPriv0(t, nsPath, nsPath, &nsConfigPath, 4) // block #11
 
-	// register `neo.com` with A record type and priv0 owner via NS
+	// 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{})
 
-	// Invoke `test_contract.go`: put new value with the same key to check `getstate` RPC call
+	// 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
@@ -512,9 +504,75 @@ func initBasicChain(t *testing.T, bc *Blockchain) {
 	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))
+	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")
diff --git a/pkg/core/statesync_test.go b/pkg/core/statesync_test.go
index 9d62088a0e..9da8e5f2b4 100644
--- a/pkg/core/statesync_test.go
+++ b/pkg/core/statesync_test.go
@@ -280,7 +280,7 @@ func TestStateSyncModule_RestoreBasicChain(t *testing.T) {
 	var (
 		stateSyncInterval        = 4
 		maxTraceable      uint32 = 6
-		stateSyncPoint           = 16
+		stateSyncPoint           = 20
 	)
 	spoutCfg := func(c *config.Config) {
 		c.ProtocolConfiguration.StateRootInHeader = true
@@ -291,10 +291,9 @@ func TestStateSyncModule_RestoreBasicChain(t *testing.T) {
 	bcSpout := newTestChainWithCustomCfg(t, spoutCfg)
 	initBasicChain(t, bcSpout)
 
-	// make spout chain higher that latest state sync point
+	// make spout chain higher that latest state sync point (add several blocks up to stateSyncPoint+2)
 	require.NoError(t, bcSpout.AddBlock(bcSpout.newBlock()))
-	require.NoError(t, bcSpout.AddBlock(bcSpout.newBlock()))
-	require.Equal(t, uint32(stateSyncPoint+2), bcSpout.BlockHeight())
+	require.Equal(t, stateSyncPoint+2, int(bcSpout.BlockHeight()))
 
 	boltCfg := func(c *config.Config) {
 		spoutCfg(c)
diff --git a/pkg/rpc/server/client_test.go b/pkg/rpc/server/client_test.go
index 2baf7b00ea..18c2b418d7 100644
--- a/pkg/rpc/server/client_test.go
+++ b/pkg/rpc/server/client_test.go
@@ -3,6 +3,7 @@ package server
 import (
 	"context"
 	"encoding/base64"
+	"encoding/hex"
 	"testing"
 
 	"github.com/nspcc-dev/neo-go/internal/testchain"
@@ -107,7 +108,7 @@ func TestAddNetworkFeeCalculateNetworkFee(t *testing.T) {
 		acc0 := wallet.NewAccountFromPrivateKey(testchain.PrivateKeyByID(0))
 		check := func(t *testing.T, extraFee int64) {
 			tx := transaction.New([]byte{byte(opcode.PUSH1)}, 0)
-			tx.ValidUntilBlock = 20
+			tx.ValidUntilBlock = 25
 			tx.Signers = []transaction.Signer{{
 				Account: acc0.PrivateKey().GetScriptHash(),
 				Scopes:  transaction.CalledByEntry,
@@ -165,7 +166,7 @@ func TestAddNetworkFeeCalculateNetworkFee(t *testing.T) {
 		require.NoError(t, err)
 		check := func(t *testing.T, extraFee int64) {
 			tx := transaction.New([]byte{byte(opcode.PUSH1)}, 0)
-			tx.ValidUntilBlock = 20
+			tx.ValidUntilBlock = 25
 			tx.Signers = []transaction.Signer{
 				{
 					Account: acc0.PrivateKey().GetScriptHash(),
@@ -801,7 +802,7 @@ func TestClient_GetNativeContracts(t *testing.T) {
 	require.Equal(t, chain.GetNatives(), cs)
 }
 
-func TestClient_NEP11(t *testing.T) {
+func TestClient_NEP11_ND(t *testing.T) {
 	chain, rpcSrv, httpSrv := initServerWithInMemoryChain(t)
 	defer chain.Close()
 	defer func() { _ = rpcSrv.Shutdown() }()
@@ -810,7 +811,7 @@ func TestClient_NEP11(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, c.Init())
 
-	h, err := util.Uint160DecodeStringLE(nameServiceContractHash)
+	h, err := util.Uint160DecodeStringLE(nnsContractHash)
 	require.NoError(t, err)
 	acc := testchain.PrivateKeyByID(0).GetScriptHash()
 
@@ -867,7 +868,7 @@ func TestClient_NEP11(t *testing.T) {
 	})
 }
 
-func TestClient_NNS(t *testing.T) {
+func TestClient_NEP11_D(t *testing.T) {
 	chain, rpcSrv, httpSrv := initServerWithInMemoryChain(t)
 	defer chain.Close()
 	defer func() { _ = rpcSrv.Shutdown() }()
@@ -876,34 +877,98 @@ func TestClient_NNS(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, c.Init())
 
-	nsHash, err := util.Uint160DecodeStringLE(nameServiceContractHash)
+	priv0 := testchain.PrivateKeyByID(0).GetScriptHash()
+	priv1 := testchain.PrivateKeyByID(1).GetScriptHash()
+	token1ID, err := hex.DecodeString(nfsoToken1ID)
 	require.NoError(t, err)
 
+	t.Run("Decimals", func(t *testing.T) {
+		d, err := c.NEP11Decimals(nfsoHash)
+		require.NoError(t, err)
+		require.EqualValues(t, 2, d) // Divisible.
+	})
+	t.Run("TotalSupply", func(t *testing.T) {
+		s, err := c.NEP11TotalSupply(nfsoHash)
+		require.NoError(t, err)
+		require.EqualValues(t, 1, s) // the only NFSO of acc0
+	})
+	t.Run("Symbol", func(t *testing.T) {
+		sym, err := c.NEP11Symbol(nfsoHash)
+		require.NoError(t, err)
+		require.Equal(t, "NFSO", sym)
+	})
+	t.Run("TokenInfo", func(t *testing.T) {
+		tok, err := c.NEP11TokenInfo(nfsoHash)
+		require.NoError(t, err)
+		require.Equal(t, &wallet.Token{
+			Name:     "NeoFS Object NFT",
+			Hash:     nfsoHash,
+			Decimals: 2,
+			Symbol:   "NFSO",
+			Standard: manifest.NEP11StandardName,
+		}, tok)
+	})
+	t.Run("BalanceOf", func(t *testing.T) {
+		b, err := c.NEP11BalanceOf(nfsoHash, priv0)
+		require.NoError(t, err)
+		require.EqualValues(t, 80, b)
+	})
+	t.Run("OwnerOf", func(t *testing.T) {
+		b, err := c.NEP11DOwnerOf(nfsoHash, token1ID)
+		require.NoError(t, err)
+		require.Equal(t, []util.Uint160{priv1, priv0}, b)
+	})
+	t.Run("Properties", func(t *testing.T) {
+		p, err := c.NEP11Properties(nfsoHash, token1ID)
+		require.NoError(t, err)
+		expected := stackitem.NewMap()
+		expected.Add(stackitem.Make([]byte("name")), stackitem.NewBuffer([]byte("NeoFS Object "+base64.StdEncoding.EncodeToString(token1ID))))
+		expected.Add(stackitem.Make([]byte("containerID")), stackitem.Make([]byte(base64.StdEncoding.EncodeToString(nfsoToken1ContainerID.BytesBE()))))
+		expected.Add(stackitem.Make([]byte("objectID")), stackitem.Make([]byte(base64.StdEncoding.EncodeToString(nfsoToken1ObjectID.BytesBE()))))
+		require.EqualValues(t, expected, p)
+	})
+	t.Run("Transfer", func(t *testing.T) {
+		_, err := c.TransferNEP11D(wallet.NewAccountFromPrivateKey(testchain.PrivateKeyByID(0)),
+			testchain.PrivateKeyByID(1).GetScriptHash(),
+			nfsoHash, 20, token1ID, nil, 0, nil)
+		require.NoError(t, err)
+	})
+}
+
+func TestClient_NNS(t *testing.T) {
+	chain, rpcSrv, httpSrv := initServerWithInMemoryChain(t)
+	defer chain.Close()
+	defer func() { _ = rpcSrv.Shutdown() }()
+
+	c, err := client.New(context.Background(), httpSrv.URL, client.Options{})
+	require.NoError(t, err)
+	require.NoError(t, c.Init())
+
 	t.Run("NNSIsAvailable, false", func(t *testing.T) {
-		b, err := c.NNSIsAvailable(nsHash, "neo.com")
+		b, err := c.NNSIsAvailable(nnsHash, "neo.com")
 		require.NoError(t, err)
 		require.Equal(t, false, b)
 	})
 	t.Run("NNSIsAvailable, true", func(t *testing.T) {
-		b, err := c.NNSIsAvailable(nsHash, "neogo.com")
+		b, err := c.NNSIsAvailable(nnsHash, "neogo.com")
 		require.NoError(t, err)
 		require.Equal(t, true, b)
 	})
 	t.Run("NNSResolve, good", func(t *testing.T) {
-		b, err := c.NNSResolve(nsHash, "neo.com", nns.A)
+		b, err := c.NNSResolve(nnsHash, "neo.com", nns.A)
 		require.NoError(t, err)
 		require.Equal(t, "1.2.3.4", b)
 	})
 	t.Run("NNSResolve, bad", func(t *testing.T) {
-		_, err := c.NNSResolve(nsHash, "neogo.com", nns.A)
+		_, err := c.NNSResolve(nnsHash, "neogo.com", nns.A)
 		require.Error(t, err)
 	})
 	t.Run("NNSResolve, forbidden", func(t *testing.T) {
-		_, err := c.NNSResolve(nsHash, "neogo.com", nns.CNAME)
+		_, err := c.NNSResolve(nnsHash, "neogo.com", nns.CNAME)
 		require.Error(t, err)
 	})
 	t.Run("NNSGetAllRecords, good", func(t *testing.T) {
-		rss, err := c.NNSGetAllRecords(nsHash, "neo.com")
+		rss, err := c.NNSGetAllRecords(nnsHash, "neo.com")
 		require.NoError(t, err)
 		require.Equal(t, []nns.RecordState{
 			{
@@ -914,7 +979,7 @@ func TestClient_NNS(t *testing.T) {
 		}, rss)
 	})
 	t.Run("NNSGetAllRecords, bad", func(t *testing.T) {
-		_, err := c.NNSGetAllRecords(nsHash, "neopython.com")
+		_, err := c.NNSGetAllRecords(nnsHash, "neopython.com")
 		require.Error(t, err)
 	})
 }
diff --git a/pkg/rpc/server/server_helper_test.go b/pkg/rpc/server/server_helper_test.go
index 0baa864113..0c535ca715 100644
--- a/pkg/rpc/server/server_helper_test.go
+++ b/pkg/rpc/server/server_helper_test.go
@@ -75,7 +75,7 @@ func getUnitTestChain(t testing.TB, enableOracle bool, enableNotary bool) (*core
 }
 
 func getTestBlocks(t *testing.T) []*block.Block {
-	// File "./testdata/testblocks.acc" was generated by function core._
+	// File "./testdata/testblocks.acc" was generated by function core.TestCreateBasicChain
 	// ("neo-go/pkg/core/helper_test.go").
 	// To generate new "./testdata/testblocks.acc", follow the steps:
 	// 		1. Rename the function
diff --git a/pkg/rpc/server/server_test.go b/pkg/rpc/server/server_test.go
index cebad1bb7e..6bc84ee8b8 100644
--- a/pkg/rpc/server/server_test.go
+++ b/pkg/rpc/server/server_test.go
@@ -61,30 +61,27 @@ type rpcTestCase struct {
 	check  func(t *testing.T, e *executor, result interface{})
 }
 
-const testContractHash = "5c9e40a12055c6b9e3f72271c9779958c842135d"
-const deploymentTxHash = "8de63ea12ca8a9c5233ebf8664a442c881ae1bb83708d82da7fa1da2305ecf14"
-const genesisBlockHash = "0f8fb4e17d2ab9f3097af75ca7fd16064160fb8043db94909e00dd4e257b9dc4"
-
-const verifyContractHash = "f68822e4ecd93de334bdf1f7c409eda3431bcbd0"
-const verifyContractAVM = "VwIAQS1RCDAhcAwU7p6iLCfjS9AUj8QQjgj3To9QSLLbMHFoE87bKGnbKJdA"
-const verifyWithArgsContractHash = "947c780f45b2a3d32e946355ee5cb57faf4decb7"
-const invokescriptContractAVM = "VwIADBQBDAMOBQYMDQIODw0DDgcJAAAAANswcGhB+CfsjCGqJgQRQAwUDQ8DAgkAAgEDBwMEBQIBAA4GDAnbMHFpQfgn7IwhqiYEEkATQA=="
-
-const nameServiceContractHash = "3a602b3e7cfd760850bfac44f4a9bb0ebad3e2dc"
-
-var NNSHash = util.Uint160{0xdc, 0xe2, 0xd3, 0xba, 0x0e, 0xbb, 0xa9, 0xf4, 0x44, 0xac, 0xbf, 0x50, 0x08, 0x76, 0xfd, 0x7c, 0x3e, 0x2b, 0x60, 0x3a}
-
-var nep11Reg = &result.NEP11Balances{
-	Address: "Nhfg3TbpwogLvDGVvAvqyThbsHgoSUKwtn",
-	Balances: []result.NEP11AssetBalance{{
-		Asset: NNSHash,
-		Tokens: []result.NEP11TokenBalance{{
-			ID:          "6e656f2e636f6d",
-			Amount:      "1",
-			LastUpdated: 14,
-		}},
-	}},
-}
+const genesisBlockHash = "a4ae00f6ac7496cac14e709fbf8b8ecb4c9831d8a6ee396056af9350fcf22671"
+const testContractHash = "1ab08f5508edafa6f28e3db3227442a9e70aac52"
+const deploymentTxHash = "017c9edb217477aeb3e0c35462361209fdb7bf104dc8e285e2385af8713926b4"
+
+const (
+	verifyContractHash         = "7deef31e5c616e157cdf02a5446f36d0a4eead52"
+	verifyContractAVM          = "VwIAQS1RCDBwDBTunqIsJ+NL0BSPxBCOCPdOj1BIskrZMCQE2zBxaBPOStkoJATbKGlK2SgkBNsol0A="
+	verifyWithArgsContractHash = "6df009754ce475a6a5730c9e488f80e8e47bc1f1"
+	nnsContractHash            = "1a7530a4c6cfdd40ffed40775aa5453febab24c0"
+	nnsToken1ID                = "6e656f2e636f6d"
+	nfsoContractHash           = "aaf8913c501e25c42877e79f04cb7c2c1ab47e57"
+	nfsoToken1ID               = "7e244ffd6aa85fb1579d2ed22e9b761ab62e3486"
+	invokescriptContractAVM    = "VwIADBQBDAMOBQYMDQIODw0DDgcJAAAAAErZMCQE2zBwaEH4J+yMqiYEEUAMFA0PAwIJAAIBAwcDBAUCAQAOBgwJStkwJATbMHFpQfgn7IyqJgQSQBNA"
+)
+
+var (
+	nnsHash, _            = util.Uint160DecodeStringLE(nnsContractHash)
+	nfsoHash, _           = util.Uint160DecodeStringLE(nfsoContractHash)
+	nfsoToken1ContainerID = util.Uint256{1, 2, 3}
+	nfsoToken1ObjectID    = util.Uint256{4, 5, 6}
+)
 
 var rpcTestCases = map[string][]rpcTestCase{
 	"getapplicationlog": {
@@ -245,12 +242,14 @@ var rpcTestCases = map[string][]rpcTestCase{
 		{
 			name:   "positive",
 			params: `["` + testchain.PrivateKeyByID(0).GetScriptHash().StringLE() + `"]`,
-			result: func(e *executor) interface{} { return nep11Reg },
+			result: func(e *executor) interface{} { return &result.NEP11Balances{} },
+			check:  checkNep11Balances,
 		},
 		{
 			name:   "positive_address",
 			params: `["` + address.Uint160ToString(testchain.PrivateKeyByID(0).GetScriptHash()) + `"]`,
-			result: func(e *executor) interface{} { return nep11Reg },
+			result: func(e *executor) interface{} { return &result.NEP11Balances{} },
+			check:  checkNep11Balances,
 		},
 	},
 	"getnep11properties": {
@@ -266,21 +265,21 @@ var rpcTestCases = map[string][]rpcTestCase{
 		},
 		{
 			name:   "no token",
-			params: `["` + NNSHash.StringLE() + `"]`,
+			params: `["` + nnsContractHash + `"]`,
 			fail:   true,
 		},
 		{
 			name:   "bad token",
-			params: `["` + NNSHash.StringLE() + `", "abcdef"]`,
+			params: `["` + nnsContractHash + `", "abcdef"]`,
 			fail:   true,
 		},
 		{
 			name:   "positive",
-			params: `["` + NNSHash.StringLE() + `", "6e656f2e636f6d"]`,
+			params: `["` + nnsContractHash + `", "6e656f2e636f6d"]`,
 			result: func(e *executor) interface{} {
 				return &map[string]interface{}{
 					"name":       "neo.com",
-					"expiration": "bhORxoMB",
+					"expiration": "HrL+G4YB",
 				}
 			},
 		},
@@ -309,9 +308,8 @@ var rpcTestCases = map[string][]rpcTestCase{
 		{
 			name:   "positive",
 			params: `["` + testchain.PrivateKeyByID(0).Address() + `", 0]`,
-			result: func(e *executor) interface{} {
-				return &result.NEP11Transfers{Sent: []result.NEP11Transfer{}, Received: []result.NEP11Transfer{{Timestamp: 0x17c6edfe76e, Asset: util.Uint160{0xdc, 0xe2, 0xd3, 0xba, 0xe, 0xbb, 0xa9, 0xf4, 0x44, 0xac, 0xbf, 0x50, 0x8, 0x76, 0xfd, 0x7c, 0x3e, 0x2b, 0x60, 0x3a}, Address: "", ID: "6e656f2e636f6d", Amount: "1", Index: 0xe, NotifyIndex: 0x0, TxHash: util.Uint256{0x5b, 0x5a, 0x5b, 0xae, 0xf2, 0xc5, 0x63, 0x8a, 0x2e, 0xcc, 0x77, 0x27, 0xd9, 0x6b, 0xb9, 0xda, 0x3a, 0x7f, 0x30, 0xaa, 0xcf, 0xda, 0x7f, 0x8a, 0x10, 0xd3, 0x23, 0xbf, 0xd, 0x1f, 0x28, 0x69}}}, Address: "Nhfg3TbpwogLvDGVvAvqyThbsHgoSUKwtn"}
-			},
+			result: func(e *executor) interface{} { return &result.NEP11Transfers{} },
+			check:  checkNep11Transfers,
 		},
 	},
 	"getnep17balances": {
@@ -812,7 +810,7 @@ var rpcTestCases = map[string][]rpcTestCase{
 				require.True(t, ok)
 				expected := result.UnclaimedGas{
 					Address:   testchain.MultisigScriptHash(),
-					Unclaimed: *big.NewInt(8000),
+					Unclaimed: *big.NewInt(10500),
 				}
 				assert.Equal(t, expected, *actual)
 			},
@@ -882,16 +880,16 @@ var rpcTestCases = map[string][]rpcTestCase{
 		},
 		{
 			name:   "positive, with notifications",
-			params: `["` + NNSHash.StringLE() + `", "transfer", [{"type":"Hash160", "value":"0x0bcd2978634d961c24f5aea0802297ff128724d6"},{"type":"String", "value":"neo.com"},{"type":"Any", "value":null}],["0xb248508f4ef7088e10c48f14d04be3272ca29eee"]]`,
+			params: `["` + nnsContractHash + `", "transfer", [{"type":"Hash160", "value":"0x0bcd2978634d961c24f5aea0802297ff128724d6"},{"type":"String", "value":"neo.com"},{"type":"Any", "value":null}],["0xb248508f4ef7088e10c48f14d04be3272ca29eee"]]`,
 			result: func(e *executor) interface{} {
-				script := []byte{0x0b, 0x0c, 0x07, 0x6e, 0x65, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x0c, 0x14, 0xd6, 0x24, 0x87, 0x12, 0xff, 0x97, 0x22, 0x80, 0xa0, 0xae, 0xf5, 0x24, 0x1c, 0x96, 0x4d, 0x63, 0x78, 0x29, 0xcd, 0x0b, 0x13, 0xc0, 0x1f, 0x0c, 0x08, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x0c, 0x14, 0xdc, 0xe2, 0xd3, 0xba, 0x0e, 0xbb, 0xa9, 0xf4, 0x44, 0xac, 0xbf, 0x50, 0x08, 0x76, 0xfd, 0x7c, 0x3e, 0x2b, 0x60, 0x3a, 0x41, 0x62, 0x7d, 0x5b, 0x52}
+				script := []byte{0x0b, 0x0c, 0x07, 0x6e, 0x65, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x0c, 0x14, 0xd6, 0x24, 0x87, 0x12, 0xff, 0x97, 0x22, 0x80, 0xa0, 0xae, 0xf5, 0x24, 0x1c, 0x96, 0x4d, 0x63, 0x78, 0x29, 0xcd, 0x0b, 0x13, 0xc0, 0x1f, 0x0c, 0x08, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x0c, 0x14, 0xc0, 0x24, 0xab, 0xeb, 0x3f, 0x45, 0xa5, 0x5a, 0x77, 0x40, 0xed, 0xff, 0x40, 0xdd, 0xcf, 0xc6, 0xa4, 0x30, 0x75, 0x1a, 0x41, 0x62, 0x7d, 0x5b, 0x52}
 				return &result.Invoke{
 					State:       "HALT",
-					GasConsumed: 33767940,
+					GasConsumed: 32167260,
 					Script:      script,
 					Stack:       []stackitem.Item{stackitem.Make(true)},
 					Notifications: []state.NotificationEvent{{
-						ScriptHash: NNSHash,
+						ScriptHash: nnsHash,
 						Name:       "Transfer",
 						Item: stackitem.NewArray([]stackitem.Item{
 							stackitem.Make([]byte{0xee, 0x9e, 0xa2, 0x2c, 0x27, 0xe3, 0x4b, 0xd0, 0x14, 0x8f, 0xc4, 0x10, 0x8e, 0x08, 0xf7, 0x4e, 0x8f, 0x50, 0x48, 0xb2}),
@@ -917,19 +915,19 @@ var rpcTestCases = map[string][]rpcTestCase{
 				chg := []storage.Operation{{
 					State: "Changed",
 					Key:   []byte{0xfa, 0xff, 0xff, 0xff, 0xb},
-					Value: []byte{0xbc, 0xf8, 0x8b, 0xa, 0x56, 0x79, 0x12},
+					Value: []byte{0xe8, 0x80, 0x64, 0xcb, 0x53, 0x79, 0x12},
 				}, {
 					State: "Added",
 					Key:   []byte{0xfb, 0xff, 0xff, 0xff, 0x14, 0xd6, 0x24, 0x87, 0x12, 0xff, 0x97, 0x22, 0x80, 0xa0, 0xae, 0xf5, 0x24, 0x1c, 0x96, 0x4d, 0x63, 0x78, 0x29, 0xcd, 0xb},
-					Value: []byte{0x41, 0x3, 0x21, 0x1, 0x1, 0x21, 0x1, 0x11, 0x0},
+					Value: []byte{0x41, 0x3, 0x21, 0x1, 0x1, 0x21, 0x1, 0x16, 0},
 				}, {
 					State: "Changed",
 					Key:   []byte{0xfb, 0xff, 0xff, 0xff, 0x14, 0xee, 0x9e, 0xa2, 0x2c, 0x27, 0xe3, 0x4b, 0xd0, 0x14, 0x8f, 0xc4, 0x10, 0x8e, 0x8, 0xf7, 0x4e, 0x8f, 0x50, 0x48, 0xb2},
-					Value: []byte{0x41, 0x3, 0x21, 0x4, 0x2f, 0xd9, 0xf5, 0x5, 0x21, 0x1, 0x11, 0x0},
+					Value: []byte{0x41, 0x3, 0x21, 0x4, 0x2f, 0xd9, 0xf5, 0x5, 0x21, 0x1, 0x16, 0},
 				}, {
 					State: "Changed",
 					Key:   []byte{0xfa, 0xff, 0xff, 0xff, 0x14, 0xee, 0x9e, 0xa2, 0x2c, 0x27, 0xe3, 0x4b, 0xd0, 0x14, 0x8f, 0xc4, 0x10, 0x8e, 0x8, 0xf7, 0x4e, 0x8f, 0x50, 0x48, 0xb2},
-					Value: []byte{0x41, 0x1, 0x21, 0x5, 0x4, 0xfa, 0xb2, 0x9b, 0xd},
+					Value: []byte{0x41, 0x01, 0x21, 0x05, 0x9e, 0x0b, 0x0b, 0x18, 0x0b},
 				}}
 				// Can be returned in any order.
 				assert.ElementsMatch(t, chg, res.Diagnostics.Changes)
@@ -937,14 +935,14 @@ var rpcTestCases = map[string][]rpcTestCase{
 		},
 		{
 			name:   "positive, verbose",
-			params: `["` + NNSHash.StringLE() + `", "resolve", [{"type":"String", "value":"neo.com"},{"type":"Integer","value":1}], [], true]`,
+			params: `["` + nnsContractHash + `", "resolve", [{"type":"String", "value":"neo.com"},{"type":"Integer","value":1}], [], true]`,
 			result: func(e *executor) interface{} {
-				script := []byte{0x11, 0xc, 0x7, 0x6e, 0x65, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x12, 0xc0, 0x1f, 0xc, 0x7, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0xc, 0x14, 0xdc, 0xe2, 0xd3, 0xba, 0xe, 0xbb, 0xa9, 0xf4, 0x44, 0xac, 0xbf, 0x50, 0x8, 0x76, 0xfd, 0x7c, 0x3e, 0x2b, 0x60, 0x3a, 0x41, 0x62, 0x7d, 0x5b, 0x52}
+				script := []byte{0x11, 0xc, 0x7, 0x6e, 0x65, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x12, 0xc0, 0x1f, 0xc, 0x7, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0xc, 0x14, 0xc0, 0x24, 0xab, 0xeb, 0x3f, 0x45, 0xa5, 0x5a, 0x77, 0x40, 0xed, 0xff, 0x40, 0xdd, 0xcf, 0xc6, 0xa4, 0x30, 0x75, 0x1a, 0x41, 0x62, 0x7d, 0x5b, 0x52}
 				stdHash, _ := e.chain.GetNativeContractScriptHash(nativenames.StdLib)
 				cryptoHash, _ := e.chain.GetNativeContractScriptHash(nativenames.CryptoLib)
 				return &result.Invoke{
 					State:         "HALT",
-					GasConsumed:   17958510,
+					GasConsumed:   15928320,
 					Script:        script,
 					Stack:         []stackitem.Item{stackitem.Make("1.2.3.4")},
 					Notifications: []state.NotificationEvent{},
@@ -954,7 +952,7 @@ var rpcTestCases = map[string][]rpcTestCase{
 							Current: hash.Hash160(script),
 							Calls: []*vm.InvocationTree{
 								{
-									Current: NNSHash,
+									Current: nnsHash,
 									Calls: []*vm.InvocationTree{
 										{
 											Current: stdHash,
@@ -1834,7 +1832,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, 17, actual.Confirmations)
+		assert.Equal(t, 22, actual.Confirmations)
 		assert.Equal(t, TXHash, actual.Transaction.Hash())
 	})
 
@@ -1947,12 +1945,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{10, 11, 12, 13}, []int{2, 3}) })
+		t.Run("time frame only", func(t *testing.T) { testNEP17T(t, 4, 5, 0, 0, []int{14, 15, 16, 17}, []int{3, 4}) })
 		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{7, 8}, []int{1}) })
-		t.Run("limit 2", func(t *testing.T) { testNEP17T(t, 4, 5, 2, 0, []int{10}, []int{2}) })
-		t.Run("limit with page", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 1, []int{9, 10}, []int{2}) })
-		t.Run("limit with page 2", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 2, []int{11, 12}, []int{3}) })
+		t.Run("limit", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 0, []int{11, 12}, []int{2}) })
+		t.Run("limit 2", func(t *testing.T) { testNEP17T(t, 4, 5, 2, 0, []int{14}, []int{3}) })
+		t.Run("limit with page", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 1, []int{13, 14}, []int{3}) })
+		t.Run("limit with page 2", func(t *testing.T) { testNEP17T(t, 1, 7, 3, 2, []int{15, 16}, []int{4}) })
 	})
 }
 
@@ -2036,6 +2034,39 @@ func doRPCCallOverHTTP(rpcCall string, url string, t *testing.T) []byte {
 	return bytes.TrimSpace(body)
 }
 
+func checkNep11Balances(t *testing.T, e *executor, acc interface{}) {
+	res, ok := acc.(*result.NEP11Balances)
+	require.True(t, ok)
+
+	expected := result.NEP11Balances{
+		Balances: []result.NEP11AssetBalance{
+			{
+				Asset: nnsHash,
+				Tokens: []result.NEP11TokenBalance{
+					{
+						ID:          nnsToken1ID,
+						Amount:      "1",
+						LastUpdated: 14,
+					},
+				},
+			},
+			{
+				Asset: nfsoHash,
+				Tokens: []result.NEP11TokenBalance{
+					{
+						ID:          nfsoToken1ID,
+						Amount:      "80",
+						LastUpdated: 21,
+					},
+				},
+			},
+		},
+		Address: testchain.PrivateKeyByID(0).GetScriptHash().StringLE(),
+	}
+	require.Equal(t, testchain.PrivateKeyByID(0).Address(), res.Address)
+	require.ElementsMatch(t, expected.Balances, res.Balances)
+}
+
 func checkNep17Balances(t *testing.T, e *executor, acc interface{}) {
 	res, ok := acc.(*result.NEP17Balances)
 	require.True(t, ok)
@@ -2055,8 +2086,8 @@ func checkNep17Balances(t *testing.T, e *executor, acc interface{}) {
 			},
 			{
 				Asset:       e.chain.UtilityTokenHash(),
-				Amount:      "57796785740",
-				LastUpdated: 16,
+				Amount:      "46748035310",
+				LastUpdated: 19,
 			}},
 		Address: testchain.PrivateKeyByID(0).GetScriptHash().StringLE(),
 	}
@@ -2064,8 +2095,110 @@ func checkNep17Balances(t *testing.T, e *executor, acc interface{}) {
 	require.ElementsMatch(t, expected.Balances, res.Balances)
 }
 
+func checkNep11Transfers(t *testing.T, e *executor, acc interface{}) {
+	checkNep11TransfersAux(t, e, acc, []int{0}, []int{0, 1, 2})
+}
+
+func checkNep11TransfersAux(t *testing.T, e *executor, acc interface{}, sent, rcvd []int) {
+	res, ok := acc.(*result.NEP11Transfers)
+	require.True(t, ok)
+
+	blockReceiveNFSO, err := e.chain.GetBlock(e.chain.GetHeaderHash(21)) // transfer 0.05 NFSO from priv1 back to priv0.
+	require.NoError(t, err)
+	require.Equal(t, 1, len(blockReceiveNFSO.Transactions))
+	txReceiveNFSO := blockReceiveNFSO.Transactions[0]
+
+	blockSendNFSO, err := e.chain.GetBlock(e.chain.GetHeaderHash(19)) // transfer 0.25 NFSO from priv0 to priv1.
+	require.NoError(t, err)
+	require.Equal(t, 1, len(blockSendNFSO.Transactions))
+	txSendNFSO := blockSendNFSO.Transactions[0]
+
+	blockMintNFSO, err := e.chain.GetBlock(e.chain.GetHeaderHash(18)) // mint 1.00 NFSO token by transferring 10 GAS to NFSO contract.
+	require.NoError(t, err)
+	require.Equal(t, 1, len(blockMintNFSO.Transactions))
+	txMintNFSO := blockMintNFSO.Transactions[0]
+
+	blockRegisterNSRecordA, err := e.chain.GetBlock(e.chain.GetHeaderHash(14)) // register `neo.com` with A record type and priv0 owner via NS
+	require.NoError(t, err)
+	require.Equal(t, 1, len(blockRegisterNSRecordA.Transactions))
+	txRegisterNSRecordA := blockRegisterNSRecordA.Transactions[0]
+
+	// These are laid out here explicitly for 2 purposes:
+	//  * to be able to reference any particular event for paging
+	//  * to check chain events consistency
+	// Technically these could be retrieved from application log, but that would almost
+	// duplicate the Server method.
+	expected := result.NEP11Transfers{
+		Sent: []result.NEP11Transfer{
+			{
+				Timestamp: blockSendNFSO.Timestamp,
+				Asset:     nfsoHash,
+				Address:   testchain.PrivateKeyByID(1).Address(), // to priv1
+				ID:        nfsoToken1ID,                          // NFSO ID
+				Amount:    big.NewInt(25).String(),
+				Index:     19,
+				TxHash:    txSendNFSO.Hash(),
+			},
+		},
+		Received: []result.NEP11Transfer{
+			{
+				Timestamp: blockReceiveNFSO.Timestamp,
+				Asset:     nfsoHash,
+				ID:        nfsoToken1ID,
+				Address:   testchain.PrivateKeyByID(1).Address(), // from priv1
+				Amount:    "5",
+				Index:     21,
+				TxHash:    txReceiveNFSO.Hash(),
+			},
+			{
+				Timestamp: blockMintNFSO.Timestamp,
+				Asset:     nfsoHash,
+				ID:        nfsoToken1ID,
+				Address:   "", // minting
+				Amount:    "100",
+				Index:     18,
+				TxHash:    txMintNFSO.Hash(),
+			},
+			{
+				Timestamp: blockRegisterNSRecordA.Timestamp,
+				Asset:     nnsHash,
+				ID:        nnsToken1ID,
+				Address:   "", // minting
+				Amount:    "1",
+				Index:     14,
+				TxHash:    txRegisterNSRecordA.Hash(),
+			},
+		},
+		Address: testchain.PrivateKeyByID(0).Address(),
+	}
+
+	require.Equal(t, expected.Address, res.Address)
+
+	arr := make([]result.NEP11Transfer, 0, len(expected.Sent))
+	for i := range expected.Sent {
+		for _, j := range sent {
+			if i == j {
+				arr = append(arr, expected.Sent[i])
+				break
+			}
+		}
+	}
+	require.Equal(t, arr, res.Sent)
+
+	arr = arr[:0]
+	for i := range expected.Received {
+		for _, j := range rcvd {
+			if i == j {
+				arr = append(arr, expected.Received[i])
+				break
+			}
+		}
+	}
+	require.Equal(t, arr, res.Received)
+}
+
 func checkNep17Transfers(t *testing.T, e *executor, acc interface{}) {
-	checkNep17TransfersAux(t, e, acc, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, []int{0, 1, 2, 3, 4, 5, 6, 7})
+	checkNep17TransfersAux(t, e, acc, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}, []int{0, 1, 2, 3, 4, 5, 6, 7, 8})
 }
 
 func checkNep17TransfersAux(t *testing.T, e *executor, acc interface{}, sent, rcvd []int) {
@@ -2074,6 +2207,21 @@ func checkNep17TransfersAux(t *testing.T, e *executor, acc interface{}, sent, rc
 	rublesHash, err := util.Uint160DecodeStringLE(testContractHash)
 	require.NoError(t, err)
 
+	blockTransferNFSO, err := e.chain.GetBlock(e.chain.GetHeaderHash(19)) // transfer 0.25 NFSO from priv0 to priv1.
+	require.NoError(t, err)
+	require.Equal(t, 1, len(blockTransferNFSO.Transactions))
+	txTransferNFSO := blockTransferNFSO.Transactions[0]
+
+	blockMintNFSO, err := e.chain.GetBlock(e.chain.GetHeaderHash(18)) // mint 1.00 NFSO token for priv0 by transferring 10 GAS to NFSO contract.
+	require.NoError(t, err)
+	require.Equal(t, 1, len(blockMintNFSO.Transactions))
+	txMintNFSO := blockMintNFSO.Transactions[0]
+
+	blockDeploy5, err := e.chain.GetBlock(e.chain.GetHeaderHash(17)) // deploy NeoFS Object contract (NEP11-Divisible)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(blockDeploy5.Transactions))
+	txDeploy5 := blockDeploy5.Transactions[0]
+
 	blockPutNewTestValue, err := e.chain.GetBlock(e.chain.GetHeaderHash(16)) // invoke `put` method of `test_contract.go` with `testkey`, `newtestvalue` args
 	require.NoError(t, err)
 	require.Equal(t, 1, len(blockPutNewTestValue.Transactions))
@@ -2155,6 +2303,39 @@ func checkNep17TransfersAux(t *testing.T, e *executor, acc interface{}, sent, rc
 	// duplicate the Server method.
 	expected := result.NEP17Transfers{
 		Sent: []result.NEP17Transfer{
+			{
+				Timestamp: blockTransferNFSO.Timestamp,
+				Asset:     e.chain.UtilityTokenHash(),
+				Address:   "", // burn
+				Amount:    big.NewInt(txTransferNFSO.SystemFee + txTransferNFSO.NetworkFee).String(),
+				Index:     19,
+				TxHash:    blockTransferNFSO.Hash(),
+			},
+			{
+				Timestamp:   blockMintNFSO.Timestamp,
+				Asset:       e.chain.UtilityTokenHash(),
+				Address:     address.Uint160ToString(nfsoHash),
+				Amount:      "1000000000",
+				Index:       18,
+				NotifyIndex: 0,
+				TxHash:      txMintNFSO.Hash(),
+			},
+			{
+				Timestamp: blockMintNFSO.Timestamp,
+				Asset:     e.chain.UtilityTokenHash(),
+				Address:   "", // burn
+				Amount:    big.NewInt(txMintNFSO.SystemFee + txMintNFSO.NetworkFee).String(),
+				Index:     18,
+				TxHash:    blockMintNFSO.Hash(),
+			},
+			{
+				Timestamp: blockDeploy5.Timestamp,
+				Asset:     e.chain.UtilityTokenHash(),
+				Address:   "", // burn
+				Amount:    big.NewInt(txDeploy5.SystemFee + txDeploy5.NetworkFee).String(),
+				Index:     17,
+				TxHash:    blockDeploy5.Hash(),
+			},
 			{
 				Timestamp: blockPutNewTestValue.Timestamp,
 				Asset:     e.chain.UtilityTokenHash(),
@@ -2288,6 +2469,15 @@ func checkNep17TransfersAux(t *testing.T, e *executor, acc interface{}, sent, rc
 			},
 		},
 		Received: []result.NEP17Transfer{
+			{
+				Timestamp:   blockMintNFSO.Timestamp, // GAS bounty
+				Asset:       e.chain.UtilityTokenHash(),
+				Address:     "",
+				Amount:      "50000000",
+				Index:       18,
+				NotifyIndex: 0,
+				TxHash:      blockMintNFSO.Hash(),
+			},
 			{
 				Timestamp:   blockGASBounty2.Timestamp,
 				Asset:       e.chain.UtilityTokenHash(),
diff --git a/pkg/rpc/server/testdata/testblocks.acc b/pkg/rpc/server/testdata/testblocks.acc
index 7ce922f592c084939459ac961f13d141e4efb313..f004f9cf5d6862b9662098837dc7f761b9a6a9c1 100644
GIT binary patch
literal 33175
zcmeIb2{@Er8$Ui{mq*5uJto<bov{`}sYv!U6@y{MGBaidGo(^dqLPYAXjhhKrwxf#
zOPi=9DO;=3p8U=;W{^htzVG+<{=0tHzpKm4JkNRVbDw)V+vh&d6a)g1%Mbp5f0uLO
z)tp)px#`;;&RO*>z(zoNAb-iHIN|r@S_$nZH;a9|hwXUot*4!)ur$%lsz8vk^K%A&
zRlsh@e*<4szo+Jm)r&5#Kn~G@|FXUk%Da`)CP$<*PnO@}?`GsjTB}$iYa#5Qzqoi|
zQ$*73Wh>2H4Ierul5UY=LVIL!ADIpYnn%+dTjrHSOI``G)&5YxSgI3n#BRf*<a95d
z%e(?s)6d>(hp=x%q1Y?fW8QbQVm{CO6m0uaZSA{;Wf#wjSoh@~)wj-;e6%lJ&91pD
zl~4auJEh9Hy!fGru7~L58%tz5oHi%Efv}yc<_sJ;Wtn;A#<6(s+5j2zS=$Un{IriN
z#l1~_EHs@WVdZedDgR39^CcUZxye<MpBmcE?ov3|;V@wN*5k=i%vMQg8V|~1WkRF0
z=i01KnW7ps(g)0)TL|TyuAVOzBCW7kED03JKkxY?Iq8Xb7U34(S$(G8qpKlu-ND7T
zab8rbTWjkAL6H-IGy9S8Z5=W-8(#T4Mq8u96Us9A$oco_=Pp;Q+;|C^#@hl3wgq*j
z*T-(rMHRXhU7LHF5HLMHAkBI68sRRb&Ye;=xs8u3cn~~5^p(x|EImNXIjql8KA;Y+
zszCUO@W{4);D@AM=kC+i=vde&wfQn?lh7xp%`OX$LsHxxlB!gOgy>Wpi57yVLQ)@s
zda>s<XD^z}e|gh>{uA%^(6Dc80u%h)%wa{JSBc*9?xf&ibG3QvyGgH~<!$J%$uy}6
z(Z0U}?YTm1&NRUTcklLoobMcb-|o(R#M5=j{HspiIl0%e``bNV9>XaR*6wy;m7!l}
zK!&XDfy0x`Y_89jFs+bURvKiP?x0smRJy<4XU5Wd9$!Ptn~Sgu*Ql=Pj!mQHwS^b<
zDq~C@&aZ&5S*J-@UY~dUIPB{-sh*NkWnUYmoupReNL`E9&71Sabk5S`V~^U-hrDz4
zz16t<x&JqxbHN7tZd}JK@>soohwj(EQPBwAQF<;~|3^Lhi|``4V;0DOr~V6FH^e+m
zZ4}UUn7^sR6Ni+Pd*5*2_K2>ZZ0=8YuIGyk_HEDDd)?5z?EI8jW>dEFo)IGMAzsqC
z$heSamU3YhEoFO^!hm4G!moYz-R{~9v@3XJ?rZc#?T4_^`1u)gE)}J(zI}1+X493X
zFXRITOpMG3YrWQOu4uKDjyclaZ&%aQv#&HDC-0@()tb<YQhkGkx62Anf0?R(Ga176
zb!rmcJmB?Qv$}HCl}E)M46{n-y}ch&c|V}@)TUvI6%h2T?JYBXYMK+&4o7Dpv;FL>
z7Qa4m@RZ%k^o*XqC4Zx?e~7TW7!jrZ?z_v@60ZRB*N2)7b~xVHlv<HTajLqWNiX_{
zIC|iux_Q*+#b!^}KE1jKRdHrOSi&UGqx#8-qp|d94|A6zwZ=qfI8-3Gc{uF2Z#8b!
zy)V?ceoQ^M#q?pJ|LPCXdD&Ma1w?L8tTrhpPjPyR)oq>peNvv=EXh>YOJ5`kmDgA;
z@Qr?KESbi@_Jl%MG)3T+<y?asLU97OJUiapd$akV)P`<)uu7e{`BbA8V}94=dSt&!
z1Mk9JF(FYJN~(*sl(b$H2^~LuzPn&~XfTA0n|)4ir3DEsEt~be<(?f6mDgnH{{3g^
z5Al}<vAu#AJBx%Ospz?<jnbO~Dh4xONQoTCI4EG)>7seH=1s%;+`mzoNCXJR2*fiH
z50>~_P2gV$R)ppjf)R*;ZNj4J0`V#&TqIt_Ld7jQFhWIJ1s6zEv4~fR#M24nV48}B
z-*5qcB8f;R;v$G~cu<ZU5<<h%RV?(iRVX+rAVJ4d;o?iRRj7D+G?heWQed)PWMVKV
zPQ!(OUm>^%8a_dLm?S6IkD_O&Z!(7BaOn^#ITDm)6JCI$5e!W9RYsE||MoU6k{nH<
zj});d(ea^p>SzkVI67{mfDMVMk}$SGwq$Yy9!CPDxVI?=PbG#h!EKI&4D}7iwCJCb
z48{i$BZ25f5yhAp|A8o{bsRqF)acQor$p1ea1qg?Rf#bl%jmG^!|`y7*pjzp((yJ_
zDh>!|M3pgYV!xL8r>%v}Y*b5)jQ-HjKPiO9j0_~hrp-|Z#?<T&B;Dy$A}JI+GNj@$
zqN9`PxCr-X3MFE+nlWZ$4R>tA|DX{v$;r;ez|;lDjKs6dl*6yVf8i4Uj?Mqpi34#F
zI8qSaIb^hm4GhMJc-WM1K|w#e;jkl5NM4{2J_g9=r_kiV9y9_DehNmzmHuA~9ZM6I
zCTOdK;Bg@2;Q>$a;8!S>98F=zLJFQ5Nu<$;WYQ4BL1YpLdO;v?s^~NDA;$WqMmYTt
z!$2c_49>_5A7reL(Z?GH8wDGh1%e-VoQY8g1~h9V9;*xoO;B^Z$|!<bKbIS0Pk>Wk
z&%kQQR60JGM#qtYaa2}>R{?gXV_>QR?gLAwu|x~L;~AhP6$?^yL_~t9Ew7W^JR=gG
ztP@Js(bqNC*VWgd<7sqOC-V>f@NpZ}3lEzR5`jcse8*>iHPMQ#a@l#M(^29R;xzsN
z6ckOR0<GJVg7FM6=Rk5JGdy?TLm<Tl_J5r-uh(5mZS&=<*5Zf3rq>1rMMClPIcx>M
zHGw`bgvSdBNgZu|Xt^}RanHim_*bSo^}hIciP$)_=&SNQ)DOUV^C4`qKZe#*Y##nN
zOpoHh+KM5l1Y(%GO{cYN5`<tEbZF58<u$=|$x0d|#4*Wm7n|)!GEV#<8tcu=%OXJ`
zm?98Srl9&@eMf>1QN+WP2SE)hP?v|MkYh=BDw?BWbO??Zfe*GI_@Mq=2+OKNfNzLd
zhC{O||8*5UI}}1nb2=nVB!LJ`3`T3fuAqU&1qTCrrP(xe&Cf&u-k76{PlKd}i_^)!
z7LG&dDnOGtMTSDmFeOwJf#G74v9#NO8rG~T66Vk{4aj9$6fsU$8ImB9Xwe}d#2_M2
zCORaV6g<KLF)j~0N*od^ibh~^p+XCf%LRABhYB&6aX{Gg5n)FR37cuki)dDz&WMW#
zx1*WR<eyzZInskQx3C*h3X+S!q#&{3<_$^8V%&CNAzn96TdV|@Wf@p+B+n2*0)sik
zCR|MgE@Y(ynBNKn<0%njCM3npK3QBLZ6WOHp8OvRD%_-#_+Q*vd(z4|-Tae^f8%G{
zMHL@a#EvJF2=8xv9o^X;LL)xTeK0xUR?(_g<@zr-6u4LOWPkHqK-8ST)ZfOd>x9Mu
z)>sjNxbdyVD?*VV9ui!NbawHXbM&OGiR#9#GdJ6pK<9Z^u3Gt2kS4pu>E4ETd}ff~
zKyHue`oatAY*%=r0&Qv1k0oc0nE}9)$Z=-?hPgSa&P!%S9qdaE-0oEqtx)2g9HM>G
zQ(@nM&Nh>+$$97btF`+B_d9P#Bz>E-#N)y9SuX{*ZAvN;jw@YYjlKn8#SU(E^a;xB
z37k{2ZPT~f6FY657eDwM88N4DFqHTGMjzyUFY{J+2aj3)VT0Ru1Z%ZDN?6pTv2xO8
zOvTh~Q}UKTSl%aE=_|ITL?+D?!5%8Il0B*I`*>%7%eCA&u9r=0CP#{2tGb9xI9%L#
zNPp$F_gHy3Mc%;`3U&b^M6WVy@vd)w=L~?g;@19w^+EBJV8!L%%m8LV!f*^{4c#C?
z_$wIa!B#578684WZbg&2j@Z&wPR!o)?oi1qA<xaF^22sIb-sI##r_K~6W)lX^)>j)
z#LAa;+3%J=l<u%<%1R}JHr>{(p)*KwZ&DUtdlgEko~37zne?u}?*`84{G!EoT&7Ie
zPOI2<s?+{#IqI(1^N(5EL)P(<ug8}eTsckG;IG%>-=3^g^+D|MsZXyLz9!9lrE@;%
zt?f<Ym&SbqdHUgg@uWin{+>+jF?PzDGL1J=efntO_kBlJ^=#i%{}gRm^L53y%E~fz
z^?+ta-`<rcNNHjDl6HexZ&5OKTQoJHMdGn)$krBva1-e9VS4XC_<abgcFZc*A?sM(
zKC?@Ya|e1>7=JY@Ddl}r_JZfMFa~XZlR9|1rE7JYRa9PyU9-Wbx;({beC#ewb2<F2
zq)phINf1^?_^VZX=$YyKFYk3JS{r45)?TKzbYTAd!4$raj^=ll*(j}Ss<rYzv25j1
z7cH~KJFjX*R_ckTDl3UswflSX6aP*-6#$mWSxYRd{ezt%5x$p@-Mo;LxVqm-88w8>
zMZWH@s*}w=ELZZ%=Dy}M@s&gnY#+4x9Mq^%Pj8mk>sT~Je{K5S^<G*~AhhX*fN`Br
zfN0{@qTQR)#J`BiT_=kZpRTbpb~qpASjHqhA)d|jF0God5wB)NMFhgkaE^H2`UdFQ
zlBIfj%*_D~E4L}mvNeBlN-@u=J9<Z;_KR-;d#WGmY6mN6^mlDFFgBXav$FcxvR!G{
zkwuG~RCUG}G0WY@GvZw{aM-PnZxhS+_-tbqoaWh|UAFknsjEj9rp>AQ+%9xYV0NC>
zr_Y&~rY#?(8s9`(pGuZ6I+(Qcc=VdQ#+!CuIv_0lLr&ItyX>P9k9$=6Pq*mP#XoI+
za{G|rmsNq+Uz;^`n_otG^L6g{ekK9=3V%oIo%#F*+4aQkFOn@9sr!95KoHi!LS}8+
zp2#h8QeqVcTZ7L`J)9kMb}F>ipMmF-%P2c<dek>kHl`}`3<+VJqiT4&bkhq9y$s93
zu!6H6tkP_z{*6Y=gAjznD?8X;eJ}o}U_1SiGQ<bZZT}EcRW)aPT~1L<b9J?wc`NDO
zyE;2kLeG|y<%yP|V(S+KZtq2GT2J%1es@X#GO~@+(fH=jI}e&XbM?J>mgsrB&)qm-
zb3_QiEGwL0F+OoG<hGc^y-8!daNM5693Ju<Bp=Os<`^vOVtUjx(@afMbEi#5Ny%+f
z;{`Q?F?kXS6t|-$mv`i~?C6V^thG-OP8Ctqn{+}cd=K?qjOTOR(g`=alHHZqR_71;
z?_MWa>A!_Xse16<b87jQZv~V5Jyt3vQO{`-bzYH$F1I0OwqwnbcfUV}4PEwCZSU*7
zA^5dRjW#nZFX)c(LO7<4JLGABPU<WCs5v=1)T2g?X*fB(Z+6VG2<N~SQREZ7uFFRA
z{X{nQHLR_AGPx<~Tzzik!9(XHY(5=)k#DU|^_`)p0bwtJav9&Hs`qO>c#|G<%3nKv
z=Jo>O)ae;5^JQ0>;I@_3+{Sy)*;?}0!w=sCTv#do&hb^x?%hr-ywLK{W9MlIo43Pg
zZlU0s?nIqE*Gks~GM|*VrIR}jl{3!0?KxiG>4Lha84$%({BCmbJkiWHLaFW0>2G%S
z1eK4yTc4jZ+*9^9dLa@a42zv@#EqB!*p>KPLd5?UJ<0EF*k#M7(|OLH=WoekQl@v7
zV`D5|oXqYU{B-<F{>-#HE6R4sf3RO;nbyzb*_M`7p@^AZj!!N%R>pjrs(6a`&E0hq
zw&9tqaSH<Bniybpoosk2-h<p#QYiIfb9t%c<16v;bNv>jUWu-oH{*y+O0mhTyYy3r
z_l~^4m2@1Q8Wbi^JN3=-()(j(Wmvs2Hp~iX<Mkxiyd%fvH|3`Cl>05H(jS!Yc(UXR
zvos|&^zz<!k8I}D+E2#{J#qC6yW#J<KrK<{0AlB(>dMwRi)VyCY;oU)(}l3}o)yh?
zzai<rckt%Sd5YqP>N|E`_+%42jdyWV?7ZClWryqvJJ#Geowvn0)GruCXi+<>rX%~I
zdDC&?JWWdAV*?25ZF0PG>5J4EbC;h@`tGPyn0?OsXjP%Wb<vK=KEXY)0Sjg-N?9Ha
zywe<G^06^q`vp;<bzPkPIrqF*YBML#6N>yhZFmxF!|a9otB$hpuiq}*S0P13k;7|S
zy1IH)N{}86PX$ZQdhjS7Ud7fMT8AF`AO_*+U<t~9c(Ler>-@hgVE<`}pZfwVyn@78
zsQU+NWbks+IO|luS)YPZ{+;D1Ab3k}9)yjKtB^j0``D7b+!IBRtmiEGus^e~7jCv~
zoA@mM)<w+vuV)b*Q{LU%bh&8tuJ!#3USU*YWFrO><(9l{>8BUTLHkv^O%zMzdV+WB
z@<`q~JFqeQP#W&Tj5X7@E=r$pxM*c}d7ttV5AO-B(cE<-;FVbZ{^GFtfdk2l)7?bm
zQLnQ_CXsqow^(fF+Y<CNc-dU!Qt9$VN!^8J4jUGdW40eX*S}Oqe@wVw4Ist~7qg}7
z?JeIGD=t!dYx_wL)4v+KU%^f1?1lu{#&03X9`&Lj<)!A#lPbpqtan}!^fJ@l)-7CI
zSGJ_{`;|UKmhE;3E4kFo{oJ$5dk=l_a8wj3IA;67M!P=l%=3eDGM%!+rXN|+khX4H
zmu$}9?xpy_L7#x$)YKlyU13KPkV+vU8;lM@*!XpRh^fBSA~VI5ZTEQXm>feCyI-K~
z6g|Ik&)f#{^Vg_J5i4F5J>LmAw^BXTX}t+{`iCf`X-nKbXdADw#~%DU!v(x+8{mHg
zjuHr2V@cNMxU+mDA{zMyOrE$6+a$nP==v^8NXqgh#y~v#?ET2bxfvp&oz-&A?N!_#
z88fE)&AvSt)7>oV!bx-;Yo;pS)jr+(nb7AJ)YkfWO=7Hfk<4IZCOKZFuW1F+(kse6
zQ}wNO`;r}<kCi^YMTJh1498u5tH(EC13%1$8adule(U})Jq{{9vFS;#wUnW)#QlgZ
zHC>I??*|n=&dPUt8$7wbP5=rO@%FkTZ>XpoKlt!_yW7F+iyNvI&2zLi7-Qh9!Nqt6
zp0Ko*SDgGA>3|5kc%#qv6ThEJysUXq<H-mF3F;Mi+^bM?BhDp6P-Fh=@<Ym2eHgR;
zCqf&#!uCb`rfM{Ooe5!It`7E5Y<^=QRkKc0<0XM-dO&WJ=RIm-QsP3K2z`DN(R*XV
z3LU5P_IKaoI^CT%-Px=Kp}*S1m8ot!yVH4Z4}{fwI47mO&)RB30XDRwY#Wrj=yiM7
zj+iG`pFio2AjF^)QykAtds@Lyrcls%Zwj*yr!B7YSn_3{stt$IXsdAeI}Kb>az*T_
z%pEMl?st8}`V0ntdAO+p;pV1U942|=TU4Imr^b`(8Q1FM9w8Cl0NRwjwKJmYo>hp<
zA~mm1i|+64#u-b!lzG6r-AlJLaqz5;cqMWb0*=>W!FU=ml!OEOnlv}Cy$eY_-QKaq
z!%=2Ki!<-bMRkJ=cc%t>*0L85fH353?|fLGJ>~9uzKZS3zRt8flW7WuTOSXF67MQG
z6z}ZxxcY?pobFXnDTio$cvtE9+)A}Oj4YG&(W~e&<-KWNA*_{du=<7U040x>mrd^+
z>pW8430Ie53p97ROFvlbX?8E^i}UVjivCEPk^G%YxnCN?)L*oQzinz0^i|a(MC@lm
z*hw!h9H@N0SSMLtxP%xTvnLo8xLR*hlL5bZIDguiMYC`<@8>hFzt7kHtm%=U)?9qP
zAoj_<F0JCM4>P*_>v9|ZM$HchA^+bHE`-&<=(|ei5{V6zk4L&sh1g4F72oLKNhpud
z&F^ax6(HU0r%N&tZbn>_&Q{71COvh-)mH8olgKz%VA+b#`>NI=^*_V_@?4&AqF4Sv
z@(ta#rk<Qto>iZf<ue3AoV2kAlW(n4iw3^LbNR8MnzqYVnW-1mOmm%dJnO3Th#jk|
z^L!83(OwSf<xBucD9u6=Zf4J2s7VgFMvtRZ4tr@eQOt6BZui8KsHidt=h?@mmE64e
zp_Qml%f6hsyR0pRU-?0tq2ufy7J{>zbdP+!@z8qSqQ~;dKf^*<gJ^C60tOu|Rt|e-
zZyIz~blb`ompXss@_lQ}Q}nq&`+T})rm_B<Q@CpZG-<iV>$W>w6hl+2Q#LF|>d1Yu
z+jf$E<Y3z~&v*zs>x^oy-7}x%!C(CQ!(u{mvKJQ+=D!Tyx4kx~@T6deq;~7UhUnYV
z7c^R2?g|dJ$#rZCdm;UGP$c|3@<i>PyH6l&|9w8`tNyzKd~dHlZwVRqK030XzSh>?
zTI%9ro$qA7lC#>glWv*~b_nkGjUughKS`=ZpYrTm$s-4B&virn#=U=|$089B9G%&7
z7s4GmR;(U(FakDQ)p$hLO>pkwkE4dtexAU@66pli<$q}^Gdzg`RSkna*bo->?@<^R
zPzYc+z%Dzx1P9RZa}jttG*X5$Ihr7j=zlwFqWx>LCN*y)F9Q+@C6j~wX)N?imZ~Uo
zil%TJ*!|2>;Rk;y1gt9N?7oT5k2W6tPTkgg|EqInTexoLzUj*rs=Q3izUOW{d*_zI
ztA0wsMOHSl4#{aBw5<D6w;S8XWKaghoCk0Dm<1@Vve~<2!ox>_X)Lovm<lA_zJ1=W
zZRs|ZQs~UXGe&0KCmYPxbz6Gm78QT?oBeGtN5;{z?r6tnsX9ie;CWA;)_tbyWo8$z
z+Whr4D%V+IOh{tEE5{2-Mr%@LX)}0m2Mj;ku9l}Aee>=8JZRUEdHx$ka$0h4UtN06
zavm+@ap}gF)~{yz?(Vae`(~B?s8I7bc5g#Gmc#>LFS{L(?a_MoHt|)xVaC0A{*Uz$
zUlQ8SFiQOM8)pn6JwLYVd6fJ2KdQC8km&wS*)U$F{sUuqSW(1-xhXq7+BiYjAlGQu
z8+T&c4Fsl7RxwRG7hi*EaV@KodusJjV45+p;A)J+S>EW+<nm83UHOZz1a#(X_)bsl
zTD5G4K;i89JA3}lkR&=PBw_hd{uq*WD~X1S4o3nffMs+CYbnGa7#sH+IONbyJ}AS%
zX^mYc879dERX75iBhox6pa5JM2Rp|`82%D6{xJ;85Mw?bB8mkx8L9K1fv`rn2Z$P*
zhzK`)5E;f2jmW~leEh0efYagDa>6W#d_Mt4;owRoQ&=A%IF>TFqVWI<)rC5wERG^f
z^~VDIhE+jf7abeH$JYK^QB%oe0FoMMtclrJ)sH1N(Z&Fb6FznnWdkGAaWyz`F~T5M
z4wi8&1oszoq=Cs;;f-y~a7W2iA1uTA2@Gg3KCYBb4#$)1=K}6Hwm*U`9a}BOL^&-P
zgUX};W5HADM1aB@(Tt(NSeWdvCH#}B7vU(w0vuB<Fh85%NFs~}=9r&>vH7^Qa#z}j
zKjGN4*y7-{`JaUXE_h)B)3Gd#6)$HnGmdy!;u<YlBO}b1*ustCL_C;CvxxyXH(X%E
zXf(2!;aH~{RvmXCj;)?E@*1Z>0RBdfh#6g@fw|E?bhZ(_0ey`aF-MfYXzll&L&b*@
zX&~s0HYNS>Lm77|jIcD(2tQU%V<Q9yj5vxdW5cmn=V9H@e~-cco!5=9&ZWcrlXk~)
z4FHaAAWV;98e=jpCK(RsBkCKkNBV7_5R8uiDG););iyUt%*@6G)&EI>6SJw`a>X60
zZeTiAePgA|vEXrh2lV>C^tt~n{2c_+U!`Y)8O!Ogq5Wsl8_&l6Bb@^={K~S~|F=OT
znlqRj>5axl{t*%4Va)!oJ@1H+B5@>Q2-r~^DfS-;YN+%0X;5HfGA>&a4P3t;Q~{G7
z-hUi!F$a|m+Vek76c~}|PzZ#RqJEY9f0a%U5)u*|WNu_?VjLU@!e6ktX^^p5h#|%h
zhcUwAj7^M<LU1^v5V+=1=>%+pnNTu;0Vg@-Pss!ZzfC6K7yozG9fY}os0D@^1hzcI
zD&LsbKY7-pR(okr7_)t@XfwIKNCYhPgA6TJ8XL#~KyV{5Hcvp|Lv*2d3L!}nHwm*>
zGr8``=?JPYl}N!y27?SVm<qR=gnz1sTfzdw%14NdB+}`4Je<|Qjf@D5wVdKki6GK>
z#;J-AM<)}<<AZe*eiE#{trG+Abf!8lmJLydkeu`d)DTvk03lKA9d6d%;Lug9Hv(yM
zrg}XuL!w@P3WS1VFPea(q45j~kqQzN-~tR(z0GHhmuY}HL$bbERTTVXT_{jjfTT%e
zIvT9rkwDS`J{TRy1Q`fm)C?X(@?b84eKsb$RtkgQ0@5P@sNTuR9g70@5jG!BhCihc
zFfRc-1?$a&WdCNkV3fcPbQBR)|MOKL)>VmmXcCJ(7W9EAUJvoXY)f2(3o|hKpw0qy
z2}qQK^JhgJ3pQ;CiR7epG^_L5K?p|bP&Psov00rDg(b4H8b+}PA*Zn)L1??%wCR`a
z0yjZLR{%G^tB7Z8MN*un`FI(a6xP!~<Qz7s_#iwHKr}3v7+D|>3QLhuL;?^7_(=^z
z)ziY+QWt;|JHi=R1?qZ?FqCVfNSLH+Baskx$-%YZt~<sLlqWL7#j`yywP630$Yh9n
zV9tYY;UKTV17ijNZL9<d9wcTe;DP~uxL^`k{K!I*!~B4u6FP)Ujl|I{hKveAqQ^9e
z{WCR+Kpc`{vnrqf54zB}2r3>I%mju6hQ2fl0+DTpKM9sYPm&`UBoea$aL+*LPiF8U
zPzUdJ1LHPShU7g6cr<H@k0#R4<Y+pY9D)Y9VWD_kHgluwo58W|VGA3v{UJ7ol`H^^
z8*aS}Xg!6{tPX18v_F^}i6fHGERW!b0k+quU&KHV2Y?Y)PEjhA7{(Tax+FB2B?#C*
zLO^0%u*HZWIk0Vy{TN0AC?}Op1X(U{dJQeSSzQ3uP&oTO$S87Xu>r|8Hqk6+jg+V_
z!+Hzz4Dk-Ddjh<}nNI&X?@UZH;E{{DGk+5ahCC0${4qEPY`1!G+Ia@2#Tc+zL>GxB
z{vwkIwm-&@npLexzX%{!kR<`KphUec%MHkasQPFkhi)Wn^tV74p)!dm?t(c6fY~Cf
z2Y3<M$Gm}{5V;JdR7I>1F@h|_b{B2H$}j;YaFs3K`A8;*q=*Mb0FYsM3@>sd`wBV8
zGR)tY3ue{8;2?#-YB<}QIYeDBvj9zMm_+>uV__1&iHCgH1rrZ$gS#N4@%)o2na!%I
zzthN2Y-aZnBg~Y57Q^B8kGf<ML8KuNS(0<XG=axJ79EIYZ-Hppx}pGwiefs5pHLTx
z!zclxiBj=#m~uj09NsW+!4v~&Hy1>y%ymGZPN+-94X398d7h3^(Q!a1vYr$JQ7TGB
z36hBhiDm5EMl^_#U^x;E53ej#c<hJ;>Z1eJ&`o%XITRD9VIX+k1>GYp9Aoiia4-xc
zZpBUU#ALJB27<+yk7AqEL9pWOUhs$=5ft{om<+WL6rDV}D9e}N&>RDbQo}HhJ`WDU
zSz(wAP@YBvseyVvHLpOZ<Kc8^ObI{?kN~-YpzEjtjpK-Gq}~~Dy&%U9BL}E}NTSGz
ziu`=PbX#$$6jT)GQMu*g#peQDYC-T_m<<&X27#S?$HZI!E<l5jWBR7JRCYuPPo>AB
zbRh<aMC?Z+*tu@N68RWR@i-5uO3FxH9;gCNf@Fd`M__pj@wj+!KWaEJk29=PCbARr
zfJl&xk+I1T`xL@(Jm%pUxk+Id-vLb|GIKfc91KN30w63_rg1+!o-pPG@&u1?I%sw)
zn5pnhmT2H^9pwD6hUVyzPz<_xR=^&KtU!w&J^~wIQ6CQI#v1`8=1`!3E92qiR#}`W
z9|Go-!zV8v6J#i2)&g1o#E1x}mX%8i4>NwLANF=$e)vh_g_Py-agr5LL_nCzAh0u1
zVb&m|3j0w`AA;!x;WZV=aHvn=47V_M;LG3<UIx>}_{#A85&1fx;u=8#Ak=16@sS{d
zkUF8l4-YWBc@d`kte!;?k{QZZMbpV>FtkMnk=bKg3s5aP8#RhZ6wi~`n+F6RX4E4*
zlq1RxD4<*YWtccZ1J)tJio#UqN1!MpjG#2dMt%?sS<xO0MWdMNazq49Ux<i^JI&&>
zK%I3@1tJ>jvcHQ{!$zJxr7p<`t2dTl-wWGKRq0@bbI^1^NRWYuGn8N;^!0@p2=gJ5
ztbI+GuMsK~f~39>2vP)HJ`pUiVO<wf0T48Y+fN}#z;_4|hC<8&b?^-Z;?F5{d16?7
z7(qPmgbPM~aBz@y2j<{85%l1rx)TaPMqfagFx07WAupxLYNXWVX;h-ab=1OzMp3}L
z9B2}Y7S_`vhPgm#3ESD(!Rm`J6+}cwqF6jf>WV>=U=85F0G*Dvh(sBpB2e`R{o&G)
zC@tv`D&mG5Dv@E~u8q5=X8_g#T`&lZ2@|i66%3QCj};=JX5au1B>5SO;Sa=0O*azq
z2}0MAggk=KnnV^v{y+@blBzigS%lCML!iil+QMW(gz}J>Ri}}Vl|w}jbBazT3!yZH
z$*`!kSWRZB3i?S@68eG&jS*Q{{Gtj;eF0haeIN^}?B!`Rw$$FjQlrCCi;f(T+Ds<6
z9D&kO2Gfa=tC}1spu!_u8&%vRfF8A`5hKL&xEGQEg>=KzMc5ipQ30$|<p_BZxiJy3
zf@DF`DRnVaI9brOku117R#4@Q%90Ttq()?pK)IL-A!3Di1_u!cvXHI{q!2>Ig~F#t
zpvhp05E4O-rJ<vVB)Wl#1v)a-A|h5eOkFraHkXhW3q%)A7KW83Iixg#tnMU`gU*s=
zII2E&5_u95f!3D+A3SJH6!`dI4Fo<3IcPoPWZ)|jttA%@6fHs)K_Yncg~3Oe=qPo7
zi59CjZ~G39aQ-xI9u*`QBMwCX@nS@d1fs;KU%BGBc?+*E%uB<1^Yeio>8E*8FqoMJ
z(JkP(7D9m#Q3RXaLa%nKn-Xl^dsIwikCdsvP9^GTz+%DwVU>a!=@D^SeBs!LDd2CE
zN(~W0WT{JtaDpm3J~N1M@#1+Nm^DCz@EDAVnGC+M3&AlRvm6X4>_93zCgSVhU=)KW
z%kHeB-$yo090_s1y|twqv9T26f48TYq$2$CqF;5%1DXh`zQRCFEBnmF>IEss_PDF{
zoH+ad#Z#Xhe}(T|<~`z>?j6C=yYg1GP8bPs8jL65e=U@Ahs$W~ozSwm4VeDRp0vBV
z#IF?}JFegD;WOZmzQ4p)SglA*>u%T^Nn+rnhO~kAA6^`--|wxC7e8K1UHV3G3=)Ec
z5*iN)f#3VFDmdCVex_~7arxTm$MyNM?6bqQWIE0DGp2=q@-o3Ybd{qA{bVosbzk%@
zxu9^6Nmk0V6q}<d@O=htJxB|AwDLm69c|`e-8<{sA_HXQNCMkql=tGuT3RBVj5?pC
z-yos>RhQ>(^*?eaHnXeTB5c>kMg6sbW#$Ya=XW!te?Zt9N*WK|^2}+tyJL|5gyS2^
z1~GzplIrav$L_Yzl-MF>uOnX5;BPD+kE$1dx<k_K5=`g1ct+jyG>*PBFx&Y;-`|OZ
zc%N|Z2`5F7bCw&d3a)4NtwQ);8g-T%H(2e2&h7gRCLAE~NZS!9iJLn+-@DIO#vSdN
zCKh8oF!>C**>=7RQNr$x)kZ`H;fw0I4f~cwge<!!j$Le$VC5m0PN+=L`(Sfl-VnlW
zQ{^ov4X*O$^VybBGr&Ko%$D}>k^=GicD{k*V$THE%@psA?T>AJR9u^~jQBdNExAVB
z?m_j=Vr9Q3AG}cQO9;Cxa`uXBD~$7wCe)P@veuN>%WQCyDy|Wu=2RhS7w)+|xLex&
z`eMo5)upGezV6MhHR+Puws+wP{Zxm3;xfBse`Qj&C>vJUo}FSF&F9f^uMMp?eemW7
z?CMzOJ(_sl8T;pviwF(c&9^kLO{#}OCF+efsjjh)JrnRXp#SP2;rp_Q$uftRZJRpA
zb6H@T@jO={A>{4OJelng8U6)#gxzyj-`GMHxEVv0kNsA&;Jq7VZA3}tBdvp>bLLrP
z95=rizpmlE;+!{YF(OlTwFreKyFggaDW1Eorxs*3t`%_EpLfqWaGiPLVID&h>w&J;
z_Vp*%+3I*mw?=sx%U@k5A$UoL|Bb-y_s&y=Ctt`x5d5NF<w96moV|6$v-^tGD^-M6
zZ;<KvHdryQB?G0f*il1+897BJPnDr}D1KejOktBg9dlj$;E7&!KLDZ*Et8%!Mb%>Y
zU+TF}Ew`=+k7EU6kG4S8C#(u2H@94c(1v)yKv^6>*#+4fpO93gYT*lOyMv2kv9AWP
ztqrvY^rP7)H?VNla*+q*w6<+eiAmJTd3zzRP0v)s=9nPXqHpW1c^k^hgRdp)i>z68
z=<ME^-)LzH`YrxG8I^iBQV)<Wy^1@tJ=zz-3ay$O>vSiHAaqf9rCM6<)ICybKiBac
z=06wVlfHIS%c?A)J#vA50hV=@*JM^*PxMXZFBd!D`4}C(vp(f*<*Vlq_J<C-?Cs>D
zX^kS!82I@92Rn*m%W`{Xt#qx>>EO{*ZTPS<SL0;-f&*J=X3MExL))24sD~|2HQ%^=
z{=tuhyerip>^e%t{C*=`>%yMCBUj$WTfP^TKBjZu#<kCFvM=u9n!?hqEoKYcEmKq9
z*Xcc^gqz!UcE~ok`3)YZz9)CS!^ZCaU7R(%SOfoiFl$~^){*3G2`i@<2JBj2d}Zd#
z%e{iA$4onwhjeD$RP)tYK9^(ZDc|OZO#Q(Wy?a)9qqp}!;n5z|@Mft<qx(u@0>WgN
z=y(Bv`f~n2_MsPPI?e@F3p4pk^lMA^`v!hS@J7YI_j{gil!)qCwR77EgQ81R?3xX2
zx6az9H|6{CUv4<YEVkID0P-59TkkyKFzfUqWrD-Nrn%e9c;71K*L_vp@~F>Qqg7EM
zQQ`c<P;nK(X9V%yxUf?FS$O+5{5O}#*3(~3zMm8)4U)dL_Fhcgx{$X%GcPA&0aUNm
zReiSN15bF4rR>ER`|93k&*FULj?hh28Ib{7nG#(&tMlK_9=M;>bKEYhV^W;x!oM>h
z1c*!TR9*dgHcR@ehVq<YRUo+~b|De-xu<VIg5U@*T@WhZv8NCRaPqrY0n)fGe44T=
zd2Zt2O>zs9RaQt?3iz8PHfx*f_;{Sf-dXUhGT>uVU-9{p4=L_HBm(1_!%0URi<Uim
ze&%EKmJ7`G*=r{}`sAEOlsqRhC$s-b?ej;ETtpOaq*hk1Jv2{ip3e%OjcT)hWYAsh
zToRD&%e<y-xP2s1)q!}pYs<2G{A%{ok4<(^y`Hd0d5p=5{mx_^s&b}ix1p}xj%K=O
zA2IQmo2x@x^AN?GRs7A}Sw()%>F-s&XGAW_>dWLV4oPz$BQ$0G@4agjwcM%w{L+(}
zsh|(r8smStN?_4?d&vv)WDdr>OMP=!vD~}-$KJhiid95|JhH)>1VTVzb#qZk?M-sn
z1}%Yvl#=T;Q>V#(R=9O-281n`8{Ol3G^#c%kbYOt-)FX0z@!^{w(YH^A4pQ7%GbSq
zu2bx}K6c-(t*$EQPqULW7exiT`Z+J%5S>}7_C@|`#@}hOzWKh&1<H+Jxe_dJu}>p{
zRWXjq&VmFDbPaWlbdAM_%~TSYDcDD4!z}(_rzhnl$_HKDrg_`V2rUqGx7AeeFd96)
zchglD4<EFlwq|5%ajNhB_{aJ)51n7VewK!p>Q21$yR@|@W?s!%t#`(I!ggxOo+W)3
zt5E1WmSg**cik<_z~X+L<%KtVU-?f@*O95VPx`2P?Ri3Z_<7GKS@>_%bvd?23r+<D
zZ@=Qv)A^=yKXj&yh#q67sNdP?>lb#H)3-UrznIZ~t|vc6=5<mk)#~{BO!Ulo`8l0t
zE?-Q}94)jmtGCTd3u&2KjG6SwWQk?p;a+C!#zl;+d%(ascJqz9k5P7%r#}{<iw=I1
z*x_2d$t*f4e^bt*%I#{Gue?~v+hOzU%Bp3)n7bE@ubiuT_>|&&wcz5_Pc3mIEgNA7
zTTz{q_|D38VYOFX*i4)F^j<-nwA<oOJ7N@%^_$1-Jzq&gcXZ1ar670MDRhhMIJUU=
zAZ0_i{gP8VI>Ik+E?W9`+9|6?V;|(QV80Zsgx{s#-+>?i(*4g5&VqPi3?LpHjunC@
zaL^VgZwT?>a0dGS;0Yu63Cx6_fKOo2h%1uiZBMK<uaJ|YTs8MrcNNMHo%Tv{W18GF
zi-@DD3%*S|_M&MA*89ME1xM9(dzGLhiz|=jl{)p(b>FMuT_@~514AN4SWD?zZEd1b
zcJ`L<KGZ=iIWsS2Mt=7~(f9L`+N<-jHyH;AZY?}GciUQTlND8pwS+3F{q(yo3%_P~
zNyg3caMhYN#(h{v@QgPykrxyH5EZa$v+xr_9PZ63Q|*nZ8DG9`ulsyKmHxH%VOwb&
z&;2`1=8Al>;?+V+l9ye?Z!ncHIZ~1L*<v^I@|i;rHpFEoAHTca$Ew0v^8%=EBEtgu
zs=SQMPoC{avdHzONJ{PO*dVbxF{WkKj#J%(t3Ik6MK4!BbT+>oIVDV^TSE!L8YM37
zRf;VY*&*o5d*iWj^^LbJQa>u*xyPQit;XABYW2E2Vzi!Lb2hPR^ZY58<x7f_!<|;G
zy?^NY^sfBMmCru>o$kZxUD+96vPgK1_qXmduvJ1dPk0!S<%B2Cb4NP|hJm#@w9`Bf
z08aW%&c(lf1obcY_dlLD%tpYC1C8Vcbu%9q$xI+e1hW9YY$({cc<<k1-9~}SMoz-z
z007O6#{&9?h5vu;Slm$z!3ck@ShtZf{{q~1_yk!{6{q0_hT~&z#})htS1e6(<@_I_
zWdY)hP9={%E84*97XbBGnty=x0-=ru<C~fP>6Gk=8qm*2rH+=SvHrN|_&?gw|KJ#E
z7K-F2h^c|0@wkrn&y+inECy~CXlO95$i_9mv4#LEZgc|AnEVrN==|}4?h`@hb2a%9
zxA+&F^_LTd49tEJ)L1e6DNBJ%&dV>_A4~HOqUD-VWI8?~o%NyvE|}giiEY10Ci)e;
zZDumA36uT<^!BKu`^O674*`eUk@v=9Qya$8<SJlL=>G?1PaK%7t-|R){+AH#t3v+{
zL|cd(q!|jt(eNh5cBCM3Fn*#SY;J_cg1Nbs;Um(?xbc9~KV!82jPvG(78hje2Ml{f
zxZNKGNCyb)aKS$wI1lkT&2x7K2a2;WUo7wv5=DWKH1@_amBB`j0@RW!3>IP?unyAe
z0cr|D26DEaIZz)44DaD#7<UYVdzkPQP?XNSDAyamJj}r+4c~z4;U9&+0O!t2L*gJ4
z0nO@~IY-X3A=a$p)G<XsXw<Nwjrr+e?2UOA<cY=zcfr_$-E=yU5aD7hlpCee0<bWk
zA?$PE0iHlrWEc_#fZ{v=PUV7;29Lly@5W70L>9u$P;?k_r7{V|d%=h`n9_t<1z0;4
zs0(cG=K-`7pw0#&M*%VdydzKr&|*36N9VKA$0AWM%mju5z_?BTc4Z+FriQUm7o*!B
z1%pCV+5jR$1`>@Xg_D2~0j>&+`<MV8pK3uI4e}-eic<k=bRa5BEBF%4fsg_4CJRco
zLwzQI$VCF!YYVsy5D7$g%rme<0N{v`9+;Y;YYcbHS#XUAt^oj~F$-Mm&BM=N#*c^R
zL$dIE@o~%lgy-WQh1$;nN@qcYe`=Nm19JobVTUo|9Aggypg}fRg9flBpz)9pnKfOs
zp9^p*@NW_LTtk4u##8O*LZUy-C>gM@hLHb~7wHi&T5Skx2_ZQK3~FTSlL}ycFo<Is
z49Fb?4J-iYRsNsU3=$eRh~A%Hs9^EaixkGQ2Jiv};2I=+D9BBS!J{>XhQ}Hfafo0;
zCHN%?>~}SAuA}4RT>zvpl>=grcft4oJLe|E(PqH_<pcoq29_zN7JQ+`g|Pv0Y_k9`
zK(=`p5g74tz&y@^Vzh9SmIxspm_rp%6#-U1X5Y|tO>i9mShs@fuvshzIN3HJEf)9+
zIZDUnz@oUY2fLCDEaac0DFaEsVPa@VJSI*6cgNU%W4D0^FfpVe8*mAzh@C3|J0g-7
zc7M1ixE{yBSPos)9=giG+fL%OF?T1;Vz(WV;)Yn*p$?QsCPgsO^KIPWYy$A!8axHO
zImLp>N{rFffK)&N3mv>C2rOH;I|HyINMJzY=xFeEC>kAYpbtN25$Di?1&Dks93|NZ
zNC{1V`5#s>Je=0BAOP^u5Y%%NR1kq49ZrUA9Bn_>VkDP<8a7NAlm}MDp*-XxaN#hb
zL<KDzU_|K=0I3<xf_2A`B3&?2Ky&KGkRFSFki3AVgY*d+1-xx4gb0#!*c9Nlv$Hhd
z1_KF1Vg>=MDOQj~7K|7YGzqg5z9K}51V$4BbWdVLB7!|ws3$wJ(C%2Fk?t#2m_!EX
zv!Mq?;Bq3sigp4OVSQNEi#7hjN*Q8Ff2i*W!jaJIZq@?eDFGan$N28h3sYbfjT9Oh
zLBpUgfNR7qnl@+m#8FmqUa0$m{Sx-%)T=?}H<_u=RmxW%b&`AGr1r4;%fT1w;@vTs
zJ`E18JFJ|3v;=2*eX3ZLcE@MS)(eJ?O_In*@e^JE72@n4@b<6$y5)YO#A~Z>w~zZt
zxy`J5XHfVs*Z+(>h1ur1A+1txOFj*=`e;^|>3k80a6&WbOUKmd203AMvC~}}kEo1U
z0A=k8j<*2nyYQJz__v35KWBzYS9QI-5qaGR(G~BTr*~a>j^b0Nchm+_WHCY5-c`Fc
z5@#0wqiFw$lawzPbl<hRuX(-fs4|4DNfFsgU?x9$_U^uGpKE>Gv5e*gd@gk^s8h!@
z&oRB-I@F~JLcQ||DLWcYxIXwX$Ncj;`4R;qKL<0*&h!nAn;@);f{vO%+Sa{-FXAW<
zKVEIPu3CDKt{-7=PePujFyiy;PrY(QsRA{ME!yhV0^y;N-w_t~<sYD{ZZ*DKJbC&V
zjlXjN6yCO}G@QgzD(cZ6&*R(!q51d$vi~>#AT*MPZ6o898a}$yd&Nn4?d3Q4^15O*
zFRLlJ%-Zs~fcxI>KRUW|VQGTVW9J{$M+5M9wB0ejc~LO|g|3mE+YYa_olal>us5ma
zCFJaREcK{h&l9b-^><M=3o8q6%zdj^T8zv;Z$4pPfRjVue_JX_%mQali453zR!DsB
z4;R1LTk5ndX75(Qp86m<J>i1oss+oM_~#qmSu46qAmO%SO+utlM6>3L`>$lSL<$N7
zP9Nh7EH#Yh3rYj`tdh4V@Q0_Il|37#@4hVm0N&1cp6oMcx4oJt>NHQL8ZI?_V6&-@
z5r6-Jymsb{zAw#_lgw09_&3{&bs|k5>{m0V#X4V}p9-tRSnt?lcwXb$+%x=(T`#6e
zcAZFX{TMSh<@0nIo7Z}FVp(l#LocOe<nY&tsPR^m^&{3ctlNbJhhaDGnf$qPe%Ko|
z_2YU2!HcGNRjVUHC7wDdoj+ZpxZdt|$$o{$SdUb6(=Ioinb+3M;zQL4sTn0W-V{jO
zwQ^3~-{}jiJs9?0TBYnCeSstbNv%+I9tb<^f6O~a_qJ|!jQnX`<75Qrd?)_8k0~&i
zfwK?>NpW)t*4dq`7Y$hWDJ+#p54U{1I*lkJ@o3g`5r?)zxd?}VEbH`Rdz)#e(b_24
z+xQDEY0)NT`>vM0`_Oc{y1ir0o34_aH{oBhCv4dqEUnqcw;dYis4phfetWfxSALM`
zxyG~Z>CIx{SgE(r>wcwE<;q@L%P683c3-=HE-hs6h~6YIE0Oc2J{z0)zNix)sE)C0
z*6!JOmi<yt4u2M-<gtk-?iRzhKWRacm(-C0Q(j5JVXf@S-bNR<qDx(_sXqh;QIk)T
zT;z+VdFQX(x9`V+Yth$&kH)=&uzqqMKRjFfQXR9W;daP?7UB3@p7#}5V%w~bpLLtw
zxp;*PuWyIb?mb(UeHwVQ@%0Au3w-*5(}n%f>nhz-;?{=(OrORx!{*(7Um}gBRc$=K
z`oT3xA&t8AB_0B_xT{GaLS3@mldpD|ek4=B?TX*J>E3?P$o?trskMB?H8*$L)wsMD
z{yQxj?p!(Vtl?m3SqB|*RR!Xw_abvQWo{2nJV*m9?Xjgs;U!9r*V46XX6Rjyv_QNu
zS-a3BN86_~EkiW6n|e^y%Hz~aojcNB?7z<sRoW@_M)h{7lW`mB^`%qS!s%Bbtjk=<
z=WW*yPZ2$KQ*mG2aUAA(t(T04OQfz~@H^f!$Ms#I?&O`j6z87Cyw2Y*c*Qx<X@_~j
zk=CXeJ1_B1ZJ4(J!kX5vx81~Wvc+0C2`gFU6GReq)1FV?@%~GDykPpp)%l+5)AAW}
zJ}uu@@}*RE^BYO1roVK0!l!*tvP=wT2c-O!?{>Mz?vn<?<R4~AM)wqa8Q47#@00i>
zBVtQ-^-G)EL8~!35ziE_*wuIKx;}X_72Ro<eJo`Dr)+HHdb!DtTO3RG?QneZLT!xa
zPJuf*Zd!+rD7BZ(a?0B6s!q$PTKnGeK-;c85g2QMHL1mockGj9<;PCj-Isse<H^CC
z`c5S!vDIrSlUgpe+0O0@OU&}mZCgJG4j6sE_`n`dYCz?=3-b$F%D!}$-(Jn{n4);a
z)pqKQsbYNnQz+M3zZ!TP$bYp-xpv^}VgDUBL!@Ho>$STFDU&{kLD=A(yH402n`JsT
zKx$(w)VnUS6}kU0zpDr@s?DzAPHS=h!UMPSy{mIHc$)X`Hp}o`o#>>HjBD@AFe9#g
zGL<*x@AO<&FU0PXnx#hdN!;8LiHIDhPnyDgSjD}g`bS+-)zpyCRrGv^zKy5c*Y{sz
zW=U6?TfI2dSMzY^JBQmxv#43*G${oEi`gl2_0E=hgzap^Ep<6m5$OAMSKM<CpX+d!
pgtAzf&?xP>HtSQSs78(S0dwaTLV2gF=Zl3%D=ZdEV!iI~{{Z0XpS}P9

delta 11247
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
PM-uvCa^O`NrqcfbztdIT