From ce9d0b22cfcb77ac6f9f17053bdf07644fb30972 Mon Sep 17 00:00:00 2001
From: Roman Khimov <roman@nspcc.ru>
Date: Thu, 18 Nov 2021 16:37:42 +0300
Subject: [PATCH] *: use NEP-XX naming consistently in docs/comments

Standards are NEP-11 and NEP-17, not NEP11, not NEP17, not anything
else. Variable/function names of course can use whatever fits, but documents
and comments should be consistent wrt this.
---
 CHANGELOG.md                           | 20 ++++++++++----------
 cli/nep11_test.go                      |  4 ++--
 cli/nep17_test.go                      |  2 +-
 cli/testdata/verify.go                 |  4 ++--
 cli/wallet/nep11.go                    | 26 +++++++++++++-------------
 cli/wallet/nep17.go                    | 16 ++++++++--------
 cli/wallet/wallet.go                   |  4 ++--
 docs/cli.md                            |  2 +-
 examples/README.md                     |  2 +-
 examples/nft-nd-nns/nns.go             |  2 +-
 examples/nft-nd/nft.go                 |  2 +-
 pkg/core/blockchain.go                 | 10 +++++-----
 pkg/core/dao/dao.go                    |  8 ++++----
 pkg/core/helper_test.go                |  2 +-
 pkg/core/native/management.go          |  4 ++--
 pkg/core/native/management_test.go     |  4 ++--
 pkg/core/state/native_state.go         |  2 +-
 pkg/core/state/tokens.go               |  4 ++--
 pkg/rpc/client/nep11.go                | 26 +++++++++++++-------------
 pkg/rpc/client/nep17.go                | 16 ++++++++--------
 pkg/rpc/server/server.go               |  4 ++--
 pkg/smartcontract/manifest/manifest.go |  4 ++--
 pkg/wallet/token_test.go               |  6 +++---
 23 files changed, 87 insertions(+), 87 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ca54b0783..82fca29cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -294,7 +294,7 @@ Improvements:
    StateRootInHeader option (#2028)
  * cached GAS per vote value leads to substantially improved block processing
    speed (#2032)
- * failed native NEP17 transfers now still re-save the old value to the
+ * failed native NEP-17 transfers now still re-save the old value to the
    storage making state dumps compatible with C# (#2034)
  * refactored and renamed some stackitem package functions, added proper error
    values in all cases (#2045)
@@ -412,30 +412,30 @@ Bugs fixed:
 ## 0.95.0 "Sharpness" (17 May 2021)
 
 This version mostly implements N3 RC2 protocol changes (and is fully
-RC2-compatible), but also brings NEP11 CLI support and small improvements for
+RC2-compatible), but also brings NEP-11 CLI support and small improvements for
 node operators.
 
 Please note that this release is incompatible with 0.94.1 and there won't be
 long-term support provided for it.
 
 New features:
- * CLI command for NEP17 transfers now accepts `data` parameter for the
+ * CLI command for NEP-17 transfers now accepts `data` parameter for the
    transfer (#1906)
  * contract deployment CLI comand now also accepts `data` parameter for
    `_deploy` method (#1907)
- * NEP11 and NEP17 transfers from CLI can now have multiple signers (#1914)
+ * NEP-11 and NEP-17 transfers from CLI can now have multiple signers (#1914)
  * `System.Runtime.BurnGas` interop was added to burn some GAS as well as
    `refuel` GAS contract method to add GAS to current execution environment
    (#1937)
  * port number announced via P2P can now differ from actual port node is bound
    to if new option is used (#1942)
- * CLI now supports full set of NEP11 commands, including balance and
+ * CLI now supports full set of NEP-11 commands, including balance and
    transfers (#1918)
  * string split, memory search and compare functions added to stdlib (#1943)
  * MaxValidUntilBlockIncrement can now be configured (#1963)
 
 Behavior changes:
- * `data` parameter is now passed in a different way to NEP17 RPC client
+ * `data` parameter is now passed in a different way to NEP-17 RPC client
    methods (#1906)
  * default (used if nothing else specified) signer scope is now
    `CalledByEntry` in CLI and RPC (#1909)
@@ -454,7 +454,7 @@ Behavior changes:
  * node will reread TLS certificates (if any configured) on SIGHUP (#1945)
  * contract trusts are now expressed with permission descriptors in manifest
    (#1946)
- * NEP11 transfers now also support `data` parameter (#1950)
+ * NEP-11 transfers now also support `data` parameter (#1950)
  * N3 RC2 testnet magic differs from N2 RC1 testnet (#1951, #1954)
  * stdlib encoding/decoding methods now only accept inputs no longer than 1024
    bytes (#1943)
@@ -485,7 +485,7 @@ Improvements:
 Bugs fixed:
  * `getproof` RPC request returned successful results in some cases where it
    should fail
- * `Transfer` events with invalid numbers were not rejected by NEP17 tracking
+ * `Transfer` events with invalid numbers were not rejected by NEP-17 tracking
    code (#1902)
  * boolean function parameters were not accepted by `invokefunction` RPC call
    implementation (#1920)
@@ -744,9 +744,9 @@ New features:
 Behavior changes:
  * VM CLI now supports and requires manifests to properly work with NEF files
    (#1642)
- * NEP17-related CLI commands now output GAS balance as floating point numbers
+ * NEP-17-related CLI commands now output GAS balance as floating point numbers
    (#1654)
- * `--from` parameter can be omitted now for NEP17 CLI transfers, the default
+ * `--from` parameter can be omitted now for NEP-17 CLI transfers, the default
    wallet address will be used in this case (#1655)
  * native contracts now use more specific types for methods arguments (#1657)
  * some native contract names and IDs have changed (#1622, #1660)
diff --git a/cli/nep11_test.go b/cli/nep11_test.go
index 576d7184c..a5852f25d 100644
--- a/cli/nep11_test.go
+++ b/cli/nep11_test.go
@@ -53,7 +53,7 @@ func TestNEP11Import(t *testing.T) {
 	// already exists
 	e.RunWithError(t, append(args, "--token", nnsContractHash.StringLE())...)
 
-	// not a NEP11 token
+	// not a NEP-11 token
 	e.RunWithError(t, append(args, "--token", neoContractHash.StringLE())...)
 
 	t.Run("Info", func(t *testing.T) {
@@ -283,7 +283,7 @@ func TestNEP11_OwnerOf_BalanceOf_Transfer(t *testing.T) {
 	e.Run(t, append(cmdCheckBalance, "--token", h.StringLE())...)
 	checkBalanceResult(t, nftOwnerAddr, "1") // tokenID1
 
-	// transfer: good, to NEP11-Payable contract, with data
+	// transfer: good, to NEP-11-Payable contract, with data
 	verifyH := deployVerifyContract(t, e)
 	cmdTransfer = []string{
 		"neo-go", "wallet", "nep11", "transfer",
diff --git a/cli/nep17_test.go b/cli/nep17_test.go
index bc86b0bca..d71c458cf 100644
--- a/cli/nep17_test.go
+++ b/cli/nep17_test.go
@@ -321,7 +321,7 @@ func TestNEP17ImportToken(t *testing.T) {
 		"--wallet", walletPath,
 		"--token", address.Uint160ToString(neoContractHash)) // try address instead of sh
 
-	// not a NEP17 token
+	// not a NEP-17 token
 	e.RunWithError(t, "neo-go", "wallet", "nep17", "import",
 		"--rpc-endpoint", "http://"+e.RPC.Addr,
 		"--wallet", walletPath,
diff --git a/cli/testdata/verify.go b/cli/testdata/verify.go
index 0e6c51352..3f399c9f6 100644
--- a/cli/testdata/verify.go
+++ b/cli/testdata/verify.go
@@ -12,8 +12,8 @@ func Verify() bool {
 func OnNEP17Payment(from interop.Hash160, amount int, data interface{}) {
 }
 
-// OnNEP11Payment notifies about NEP11 payment. You don't call this method directly,
-// instead it's called by NEP11 contract when you transfer funds from your address
+// OnNEP11Payment notifies about NEP-11 payment. You don't call this method directly,
+// instead it's called by NEP-11 contract when you transfer funds from your address
 // to the address of this NFT contract.
 func OnNEP11Payment(from interop.Hash160, amount int, token []byte, data interface{}) {
 	runtime.Notify("OnNEP11Payment", from, amount, token, data)
diff --git a/cli/wallet/nep11.go b/cli/wallet/nep11.go
index e0393484e..b22d30245 100644
--- a/cli/wallet/nep11.go
+++ b/cli/wallet/nep11.go
@@ -52,14 +52,14 @@ func newNEP11Commands() []cli.Command {
 		},
 		{
 			Name:      "import",
-			Usage:     "import NEP11 token to a wallet",
+			Usage:     "import NEP-11 token to a wallet",
 			UsageText: "import --wallet <path> --rpc-endpoint <node> --timeout <time> --token <hash>",
 			Action:    importNEP11Token,
 			Flags:     importFlags,
 		},
 		{
 			Name:      "info",
-			Usage:     "print imported NEP11 token info",
+			Usage:     "print imported NEP-11 token info",
 			UsageText: "print --wallet <path> [--token <hash-or-name>]",
 			Action:    printNEP11Info,
 			Flags: []cli.Flag{
@@ -69,7 +69,7 @@ func newNEP11Commands() []cli.Command {
 		},
 		{
 			Name:      "remove",
-			Usage:     "remove NEP11 token from the wallet",
+			Usage:     "remove NEP-11 token from the wallet",
 			UsageText: "remove --wallet <path> --token <hash-or-name>",
 			Action:    removeNEP11Token,
 			Flags: []cli.Flag{
@@ -80,13 +80,13 @@ func newNEP11Commands() []cli.Command {
 		},
 		{
 			Name:      "transfer",
-			Usage:     "transfer NEP11 tokens",
+			Usage:     "transfer NEP-11 tokens",
 			UsageText: "transfer --wallet <path> --rpc-endpoint <node> --timeout <time> --from <addr> --to <addr> --token <hash-or-name> --id <token-id> [--amount string] [data] [-- <cosigner1:Scope> [<cosigner2> [...]]]",
 			Action:    transferNEP11,
 			Flags:     transferFlags,
-			Description: `Transfers specified NEP11 token with optional cosigners list attached to 
-   the transfer. Amount should be specified for divisible NEP11
-   tokens and omitted for non-divisible NEP11 tokens. See
+			Description: `Transfers specified NEP-11 token with optional cosigners list attached to
+   the transfer. Amount should be specified for divisible NEP-11
+   tokens and omitted for non-divisible NEP-11 tokens. See
    'contract testinvokefunction' documentation for the details
    about cosigners syntax. If no cosigners are given then the
    sender with CalledByEntry scope will be used as the only
@@ -95,7 +95,7 @@ func newNEP11Commands() []cli.Command {
 		},
 		{
 			Name:      "properties",
-			Usage:     "print properties of NEP11 token",
+			Usage:     "print properties of NEP-11 token",
 			UsageText: "properties --rpc-endpoint <node> --timeout <time> --token <hash> --id <token-id>",
 			Action:    printNEP11Properties,
 			Flags: append([]cli.Flag{
@@ -105,7 +105,7 @@ func newNEP11Commands() []cli.Command {
 		},
 		{
 			Name:      "ownerOf",
-			Usage:     "print owner of non-divisible NEP11 token with the specified ID",
+			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,
 			Flags: append([]cli.Flag{
@@ -301,7 +301,7 @@ func printNEP11Owner(ctx *cli.Context) error {
 
 	result, err := c.NEP11NDOwnerOf(tokenHash.Uint160(), tokenID)
 	if err != nil {
-		return cli.NewExitError(fmt.Sprintf("failed to call NEP11 `ownerOf` method: %s", err.Error()), 1)
+		return cli.NewExitError(fmt.Sprintf("failed to call NEP-11 `ownerOf` method: %s", err.Error()), 1)
 	}
 
 	fmt.Fprintln(ctx.App.Writer, address.Uint160ToString(result))
@@ -330,7 +330,7 @@ func printNEP11TokensOf(ctx *cli.Context) error {
 
 	result, err := c.NEP11TokensOf(tokenHash.Uint160(), acc.Uint160())
 	if err != nil {
-		return cli.NewExitError(fmt.Sprintf("failed to call NEP11 `tokensOf` method: %s", err.Error()), 1)
+		return cli.NewExitError(fmt.Sprintf("failed to call NEP-11 `tokensOf` method: %s", err.Error()), 1)
 	}
 
 	for i := range result {
@@ -356,7 +356,7 @@ func printNEP11Tokens(ctx *cli.Context) error {
 
 	result, err := c.NEP11Tokens(tokenHash.Uint160())
 	if err != nil {
-		return cli.NewExitError(fmt.Sprintf("failed to call optional NEP11 `tokens` method: %s", err.Error()), 1)
+		return cli.NewExitError(fmt.Sprintf("failed to call optional NEP-11 `tokens` method: %s", err.Error()), 1)
 	}
 
 	for i := range result {
@@ -387,7 +387,7 @@ func printNEP11Properties(ctx *cli.Context) error {
 
 	result, err := c.NEP11Properties(tokenHash.Uint160(), tokenID)
 	if err != nil {
-		return cli.NewExitError(fmt.Sprintf("failed to call NEP11 `properties` method: %s", err.Error()), 1)
+		return cli.NewExitError(fmt.Sprintf("failed to call NEP-11 `properties` method: %s", err.Error()), 1)
 	}
 
 	bytes, err := stackitem.ToJSON(result)
diff --git a/cli/wallet/nep17.go b/cli/wallet/nep17.go
index 9d17975ad..bb6965122 100644
--- a/cli/wallet/nep17.go
+++ b/cli/wallet/nep17.go
@@ -89,14 +89,14 @@ func newNEP17Commands() []cli.Command {
 		},
 		{
 			Name:      "import",
-			Usage:     "import NEP17 token to a wallet",
+			Usage:     "import NEP-17 token to a wallet",
 			UsageText: "import --wallet <path> --rpc-endpoint <node> --timeout <time> --token <hash>",
 			Action:    importNEP17Token,
 			Flags:     importFlags,
 		},
 		{
 			Name:      "info",
-			Usage:     "print imported NEP17 token info",
+			Usage:     "print imported NEP-17 token info",
 			UsageText: "print --wallet <path> [--token <hash-or-name>]",
 			Action:    printNEP17Info,
 			Flags: []cli.Flag{
@@ -106,7 +106,7 @@ func newNEP17Commands() []cli.Command {
 		},
 		{
 			Name:      "remove",
-			Usage:     "remove NEP17 token from the wallet",
+			Usage:     "remove NEP-17 token from the wallet",
 			UsageText: "remove --wallet <path> --token <hash-or-name>",
 			Action:    removeNEP17Token,
 			Flags: []cli.Flag{
@@ -117,11 +117,11 @@ func newNEP17Commands() []cli.Command {
 		},
 		{
 			Name:      "transfer",
-			Usage:     "transfer NEP17 tokens",
+			Usage:     "transfer NEP-17 tokens",
 			UsageText: "transfer --wallet <path> --rpc-endpoint <node> --timeout <time> --from <addr> --to <addr> --token <hash-or-name> --amount string [data] [-- <cosigner1:Scope> [<cosigner2> [...]]]",
 			Action:    transferNEP17,
 			Flags:     transferFlags,
-			Description: `Transfers specified NEP17 token amount with optional 'data' parameter and cosigners
+			Description: `Transfers specified NEP-17 token amount with optional 'data' parameter and cosigners
    list attached to the transfer. See 'contract testinvokefunction' documentation
    for the details about 'data' parameter and cosigners syntax. If no 'data' is
    given then default nil value will be used. If no cosigners are given then the
@@ -130,7 +130,7 @@ func newNEP17Commands() []cli.Command {
 		},
 		{
 			Name:  "multitransfer",
-			Usage: "transfer NEP17 tokens to multiple recipients",
+			Usage: "transfer NEP-17 tokens to multiple recipients",
 			UsageText: `multitransfer --wallet <path> --rpc-endpoint <node> --timeout <time> --from <addr>` +
 				` <token1>:<addr1>:<amount1> [<token2>:<addr2>:<amount2> [...]] [-- <cosigner1:Scope> [<cosigner2> [...]]]`,
 			Action: multiTransferNEP17,
@@ -478,7 +478,7 @@ func multiTransferNEP17(ctx *cli.Context) error {
 	}
 	cosignersAccounts, err := cmdargs.GetSignersAccounts(wall, cosigners)
 	if err != nil {
-		return cli.NewExitError(fmt.Errorf("failed to create NEP17 multitransfer transaction: %w", err), 1)
+		return cli.NewExitError(fmt.Errorf("failed to create NEP-17 multitransfer transaction: %w", err), 1)
 	}
 
 	return signAndSendNEP17Transfer(ctx, c, acc, recipients, cosignersAccounts)
@@ -537,7 +537,7 @@ func transferNEP(ctx *cli.Context, standard string) error {
 	}
 	cosignersAccounts, err := cmdargs.GetSignersAccounts(wall, cosigners)
 	if err != nil {
-		return cli.NewExitError(fmt.Errorf("failed to create NEP17 transfer transaction: %w", err), 1)
+		return cli.NewExitError(fmt.Errorf("failed to create NEP-17 transfer transaction: %w", err), 1)
 	}
 
 	amountArg := ctx.String("amount")
diff --git a/cli/wallet/wallet.go b/cli/wallet/wallet.go
index 581cfd834..772b5d8a5 100644
--- a/cli/wallet/wallet.go
+++ b/cli/wallet/wallet.go
@@ -231,12 +231,12 @@ func NewCommands() []cli.Command {
 			},
 			{
 				Name:        "nep17",
-				Usage:       "work with NEP17 contracts",
+				Usage:       "work with NEP-17 contracts",
 				Subcommands: newNEP17Commands(),
 			},
 			{
 				Name:        "nep11",
-				Usage:       "work with NEP11 contracts",
+				Usage:       "work with NEP-11 contracts",
 				Subcommands: newNEP11Commands(),
 			},
 			{
diff --git a/docs/cli.md b/docs/cli.md
index 34ef325b9..cbd2adcc2 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -464,7 +464,7 @@ To print token IDs owned by the specified owner, use `tokensOf` command with
 
 #### Owner Of
 
-For non-divisible NEP-11 tokens only. To print owner of non-divisible NEP11 token
+For non-divisible NEP-11 tokens only. To print owner of non-divisible NEP-11 token
 use `ownerOf` method, specify token hash via `--token` flag and token ID via
 `--id` flag:
 
diff --git a/examples/README.md b/examples/README.md
index 88864d0e4..b6a787227 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -31,7 +31,7 @@ See the table below for the detailed examples description.
 | [runtime](runtime) | This contract demonstrates how to use special `_initialize` and `_deploy` methods. See the [compiler documentation](../docs/compiler.md#vm-api-interop-layer ) for methods details. It also shows the pattern for checking owner witness inside the contract with the help of `runtime.CheckWitness` interop [function](../pkg/interop/runtime/runtime.go). |
 | [storage](storage) | The contract implements API for basic operations with a contract storage. It shows hos to use `storage` interop package. See the `storage` [package documentation](../pkg/interop/storage/storage.go). |
 | [timer](timer) | The idea of the contract is to count `tick` method invocations and destroy itself after the third invocation. It shows how to use `contract.Call` interop function to call, update (migrate) and destroy the contract. Please, refer to the `contract.Call` [function documentation](../pkg/interop/contract/contract.go) |
-| [token](token) | This contract implements NEP17 token standard (like NEO and GAS tokens) with all required methods and operations. See the NEP17 token standard [specification](https://github.com/neo-project/proposals/pull/126) for details. |
+| [token](token) | This contract implements NEP-17 token standard (like NEO and GAS tokens) with all required methods and operations. See the NEP-17 token standard [specification](https://github.com/neo-project/proposals/pull/126) for details. |
 | [token-sale](token-sale) | The contract represents a token with `allowance`. It means that the token owner should approve token withdrawing before the transfer. The contract demonstrates how interop packages can be combined to work together. |
 
 ## Compile
diff --git a/examples/nft-nd-nns/nns.go b/examples/nft-nd-nns/nns.go
index 0206b9524..3ffce9ace 100644
--- a/examples/nft-nd-nns/nns.go
+++ b/examples/nft-nd-nns/nns.go
@@ -1,5 +1,5 @@
 /*
-Package nns contains non-divisible non-fungible NEP11-compatible token
+Package nns contains non-divisible non-fungible NEP-11-compatible token
 implementation. This token is a compatible analogue of C# Neo Name Service
 token and is aimed to serve as a domain name service for Neo smart-contracts,
 thus it's NeoNameService. This token can be minted with new domain name
diff --git a/examples/nft-nd/nft.go b/examples/nft-nd/nft.go
index f153abe23..ffa1c4956 100644
--- a/examples/nft-nd/nft.go
+++ b/examples/nft-nd/nft.go
@@ -1,5 +1,5 @@
 /*
-Package nft contains non-divisible non-fungible NEP11-compatible token
+Package nft contains non-divisible non-fungible NEP-11-compatible token
 implementation. This token can be minted with GAS transfer to contract address,
 it will hash some data (including data provided in transfer) and produce
 base64-encoded string that is your NFT. Since it's based on hashing and basically
diff --git a/pkg/core/blockchain.go b/pkg/core/blockchain.go
index 0745794e6..1f92796d2 100644
--- a/pkg/core/blockchain.go
+++ b/pkg/core/blockchain.go
@@ -541,7 +541,7 @@ func (bc *Blockchain) jumpToStateInternal(p uint32, stage stateJumpStage) error
 			if err != nil {
 				return fmt.Errorf("failed to remove outdated state data for the genesis block: %w", err)
 			}
-			// TODO: remove NEP17 transfers and NEP17 transfer info for genesis block, #2096 related.
+			// TODO: remove NEP-17 transfers and NEP-17 transfer info for genesis block, #2096 related.
 			_, err = cache.Persist()
 			if err != nil {
 				return fmt.Errorf("failed to drop genesis block state: %w", err)
@@ -1404,7 +1404,7 @@ func appendTokenTransfer(cache dao.DAO, transCache map[util.Uint160]transferData
 	return nil
 }
 
-// ForEachNEP17Transfer executes f for each nep17 transfer in log.
+// ForEachNEP17Transfer executes f for each NEP-17 transfer in log.
 func (bc *Blockchain) ForEachNEP17Transfer(acc util.Uint160, f func(*state.NEP17Transfer) (bool, error)) error {
 	balances, err := bc.dao.GetTokenTransferInfo(acc)
 	if err != nil {
@@ -1426,7 +1426,7 @@ func (bc *Blockchain) ForEachNEP17Transfer(acc util.Uint160, f func(*state.NEP17
 	return nil
 }
 
-// ForEachNEP11Transfer executes f for each nep11 transfer in log.
+// ForEachNEP11Transfer executes f for each NEP-11 transfer in log.
 func (bc *Blockchain) ForEachNEP11Transfer(acc util.Uint160, f func(*state.NEP11Transfer) (bool, error)) error {
 	balances, err := bc.dao.GetTokenTransferInfo(acc)
 	if err != nil {
@@ -1448,12 +1448,12 @@ func (bc *Blockchain) ForEachNEP11Transfer(acc util.Uint160, f func(*state.NEP11
 	return nil
 }
 
-// GetNEP17Contracts returns the list of deployed NEP17 contracts.
+// GetNEP17Contracts returns the list of deployed NEP-17 contracts.
 func (bc *Blockchain) GetNEP17Contracts() []util.Uint160 {
 	return bc.contracts.Management.GetNEP17Contracts()
 }
 
-// GetNEP11Contracts returns the list of deployed NEP11 contracts.
+// GetNEP11Contracts returns the list of deployed NEP-11 contracts.
 func (bc *Blockchain) GetNEP11Contracts() []util.Uint160 {
 	return bc.contracts.Management.GetNEP11Contracts()
 }
diff --git a/pkg/core/dao/dao.go b/pkg/core/dao/dao.go
index 131f3c6fd..52c30ec62 100644
--- a/pkg/core/dao/dao.go
+++ b/pkg/core/dao/dao.go
@@ -149,9 +149,9 @@ func (dao *Simple) GetContractScriptHash(id int32) (util.Uint160, error) {
 	return *data, nil
 }
 
-// -- start nep17 transfer info.
+// -- start NEP-17 transfer info.
 
-// GetTokenTransferInfo retrieves nep17 transfer info from the cache.
+// GetTokenTransferInfo retrieves NEP-17 transfer info from the cache.
 func (dao *Simple) GetTokenTransferInfo(acc util.Uint160) (*state.TokenTransferInfo, error) {
 	key := storage.AppendPrefix(storage.STTokenTransferInfo, acc.BytesBE())
 	bs := state.NewTokenTransferInfo()
@@ -162,7 +162,7 @@ func (dao *Simple) GetTokenTransferInfo(acc util.Uint160) (*state.TokenTransferI
 	return bs, nil
 }
 
-// PutTokenTransferInfo saves nep17 transfer info in the cache.
+// PutTokenTransferInfo saves NEP-17 transfer info in the cache.
 func (dao *Simple) PutTokenTransferInfo(acc util.Uint160, bs *state.TokenTransferInfo) error {
 	return dao.putTokenTransferInfo(acc, bs, io.NewBufBinWriter())
 }
@@ -172,7 +172,7 @@ func (dao *Simple) putTokenTransferInfo(acc util.Uint160, bs *state.TokenTransfe
 	return dao.putWithBuffer(bs, key, buf)
 }
 
-// -- end nep17 transfer info.
+// -- end NEP-17 transfer info.
 
 // -- start transfer log.
 
diff --git a/pkg/core/helper_test.go b/pkg/core/helper_test.go
index 58bcab296..c76c8b531 100644
--- a/pkg/core/helper_test.go
+++ b/pkg/core/helper_test.go
@@ -512,7 +512,7 @@ func newNEP17TransferWithAssert(sc, from, to util.Uint160, amount int64, needAss
 		emit.Opcodes(w.BinWriter, opcode.ASSERT)
 	}
 	if w.Err != nil {
-		panic(fmt.Errorf("failed to create nep17 transfer transaction: %w", w.Err))
+		panic(fmt.Errorf("failed to create NEP-17 transfer transaction: %w", w.Err))
 	}
 
 	script := w.Bytes()
diff --git a/pkg/core/native/management.go b/pkg/core/native/management.go
index 5584d03fc..3b63cfef0 100644
--- a/pkg/core/native/management.go
+++ b/pkg/core/native/management.go
@@ -35,7 +35,7 @@ type Management struct {
 	contracts map[util.Uint160]*state.Contract
 	// nep11 is a map of NEP11-compliant contracts which is updated with every PostPersist.
 	nep11 map[util.Uint160]struct{}
-	// nep17 is a map of NEP17-compliant contracts which is updated with every PostPersist.
+	// nep17 is a map of NEP-17-compliant contracts which is updated with every PostPersist.
 	nep17 map[util.Uint160]struct{}
 }
 
@@ -548,7 +548,7 @@ func (m *Management) GetNEP11Contracts() []util.Uint160 {
 	return result
 }
 
-// GetNEP17Contracts returns hashes of all deployed contracts that support NEP17 standard. The list
+// GetNEP17Contracts returns hashes of all deployed contracts that support NEP-17 standard. The list
 // is updated every PostPersist, so until PostPersist is called, the result for the previous block
 // is returned.
 func (m *Management) GetNEP17Contracts() []util.Uint160 {
diff --git a/pkg/core/native/management_test.go b/pkg/core/native/management_test.go
index b7715e16e..88498e00c 100644
--- a/pkg/core/native/management_test.go
+++ b/pkg/core/native/management_test.go
@@ -92,7 +92,7 @@ func TestManagement_GetNEP17Contracts(t *testing.T) {
 
 	require.Empty(t, mgmt.GetNEP17Contracts())
 
-	// Deploy NEP17 contract
+	// Deploy NEP-17 contract
 	script := []byte{byte(opcode.RET)}
 	sender := util.Uint160{1, 2, 3}
 	ne, err := nef.NewFile(script)
@@ -107,7 +107,7 @@ func TestManagement_GetNEP17Contracts(t *testing.T) {
 	c1, err := mgmt.Deploy(d, sender, ne, manif)
 	require.NoError(t, err)
 
-	// PostPersist is not yet called, thus no NEP17 contracts are expected
+	// PostPersist is not yet called, thus no NEP-17 contracts are expected
 	require.Empty(t, mgmt.GetNEP17Contracts())
 
 	// Call PostPersist, check c1 contract hash is returned
diff --git a/pkg/core/state/native_state.go b/pkg/core/state/native_state.go
index d4bd0208d..22141a62f 100644
--- a/pkg/core/state/native_state.go
+++ b/pkg/core/state/native_state.go
@@ -11,7 +11,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 )
 
-// NEP17Balance represents balance state of a NEP17-token.
+// NEP17Balance represents balance state of a NEP-17-token.
 type NEP17Balance struct {
 	Balance big.Int
 }
diff --git a/pkg/core/state/tokens.go b/pkg/core/state/tokens.go
index beae5109c..2d1dc8f51 100644
--- a/pkg/core/state/tokens.go
+++ b/pkg/core/state/tokens.go
@@ -18,9 +18,9 @@ type TokenTransferLog struct {
 	Raw []byte
 }
 
-// NEP17Transfer represents a single NEP17 Transfer event.
+// NEP17Transfer represents a single NEP-17 Transfer event.
 type NEP17Transfer struct {
-	// Asset is a NEP17 contract ID.
+	// Asset is a NEP-17 contract ID.
 	Asset int32
 	// Address is the address of the sender.
 	From util.Uint160
diff --git a/pkg/rpc/client/nep11.go b/pkg/rpc/client/nep11.go
index a26f43c3b..32c7c13c4 100644
--- a/pkg/rpc/client/nep11.go
+++ b/pkg/rpc/client/nep11.go
@@ -16,33 +16,33 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/wallet"
 )
 
-// NEP11Decimals invokes `decimals` NEP11 method on a specified contract.
+// NEP11Decimals invokes `decimals` NEP-11 method on a specified contract.
 func (c *Client) NEP11Decimals(tokenHash util.Uint160) (int64, error) {
 	return c.nepDecimals(tokenHash)
 }
 
-// NEP11Symbol invokes `symbol` NEP11 method on a specified contract.
+// NEP11Symbol invokes `symbol` NEP-11 method on a specified contract.
 func (c *Client) NEP11Symbol(tokenHash util.Uint160) (string, error) {
 	return c.nepSymbol(tokenHash)
 }
 
-// NEP11TotalSupply invokes `totalSupply` NEP11 method on a specified contract.
+// NEP11TotalSupply invokes `totalSupply` NEP-11 method on a specified contract.
 func (c *Client) NEP11TotalSupply(tokenHash util.Uint160) (int64, error) {
 	return c.nepTotalSupply(tokenHash)
 }
 
-// NEP11BalanceOf invokes `balanceOf` NEP11 method on a specified contract.
+// NEP11BalanceOf invokes `balanceOf` NEP-11 method on a specified contract.
 func (c *Client) NEP11BalanceOf(tokenHash, owner util.Uint160) (int64, error) {
 	return c.nepBalanceOf(tokenHash, owner, nil)
 }
 
-// NEP11TokenInfo returns full NEP11 token info.
+// NEP11TokenInfo returns full NEP-11 token info.
 func (c *Client) NEP11TokenInfo(tokenHash util.Uint160) (*wallet.Token, error) {
 	return c.nepTokenInfo(tokenHash, manifest.NEP11StandardName)
 }
 
 // TransferNEP11 creates an invocation transaction that invokes 'transfer' method
-// on a given token to move the whole NEP11 token with the specified token ID to
+// on a given token to move the whole NEP-11 token with the specified token ID to
 // given account and sends it to the network returning just a hash of it.
 func (c *Client) TransferNEP11(acc *wallet.Account, to util.Uint160,
 	tokenHash util.Uint160, tokenID string, data interface{}, gas int64, cosigners []SignerAccount) (util.Uint256, error) {
@@ -59,7 +59,7 @@ func (c *Client) TransferNEP11(acc *wallet.Account, to util.Uint160,
 
 // CreateNEP11TransferTx creates an invocation transaction for the 'transfer'
 // method of a given contract (token) to move the whole (or the specified amount
-// of) NEP11 token with the specified token ID to given account and returns it.
+// of) NEP-11 token with the specified token ID to given account and returns it.
 // The returned transaction is not signed. CreateNEP11TransferTx is also a
 // helper for TransferNEP11 and TransferNEP11D.
 // `args` for TransferNEP11:  to util.Uint160, tokenID string, data interface{};
@@ -70,7 +70,7 @@ func (c *Client) CreateNEP11TransferTx(acc *wallet.Account, tokenHash util.Uint1
 	emit.AppCall(w.BinWriter, tokenHash, "transfer", callflag.All, args...)
 	emit.Opcodes(w.BinWriter, opcode.ASSERT)
 	if w.Err != nil {
-		return nil, fmt.Errorf("failed to create NEP11 transfer script: %w", w.Err)
+		return nil, fmt.Errorf("failed to create NEP-11 transfer script: %w", w.Err)
 	}
 	from, err := address.StringToUint160(acc.Address)
 	if err != nil {
@@ -114,7 +114,7 @@ func (c *Client) NEP11TokensOf(tokenHash util.Uint160, owner util.Uint160) ([]st
 
 // Non-divisible NFT methods section start.
 
-// NEP11NDOwnerOf invokes `ownerOf` non-devisible NEP11 method with the
+// 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) {
 	result, err := c.InvokeFunction(tokenHash, "ownerOf", []smartcontract.Parameter{
@@ -139,7 +139,7 @@ func (c *Client) NEP11NDOwnerOf(tokenHash util.Uint160, tokenID string) (util.Ui
 // Divisible NFT methods section start.
 
 // TransferNEP11D creates an invocation transaction that invokes 'transfer'
-// method on a given token to move specified amount of divisible NEP11 assets
+// method on a given token to move specified amount of divisible NEP-11 assets
 // (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,
@@ -159,13 +159,13 @@ func (c *Client) TransferNEP11D(acc *wallet.Account, to util.Uint160,
 	return c.SignAndPushTx(tx, acc, cosigners)
 }
 
-// NEP11DBalanceOf invokes `balanceOf` divisible NEP11 method on a
+// 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)
 }
 
-// NEP11DOwnerOf returns list of the specified NEP11 divisible token owners.
+// NEP11DOwnerOf returns list of the specified NEP-11 divisible token owners.
 func (c *Client) NEP11DOwnerOf(tokenHash util.Uint160, tokenID string) ([]util.Uint160, error) {
 	result, err := c.InvokeFunction(tokenHash, "ownerOf", []smartcontract.Parameter{
 		{
@@ -196,7 +196,7 @@ func (c *Client) NEP11DOwnerOf(tokenHash util.Uint160, tokenID string) ([]util.U
 
 // Optional NFT methods section start.
 
-// NEP11Properties invokes `properties` optional NEP11 method on a
+// NEP11Properties invokes `properties` optional NEP-11 method on a
 // specified contract.
 func (c *Client) NEP11Properties(tokenHash util.Uint160, tokenID string) (*stackitem.Map, error) {
 	result, err := c.InvokeFunction(tokenHash, "properties", []smartcontract.Parameter{{
diff --git a/pkg/rpc/client/nep17.go b/pkg/rpc/client/nep17.go
index 1df287409..ee7685c20 100644
--- a/pkg/rpc/client/nep17.go
+++ b/pkg/rpc/client/nep17.go
@@ -29,33 +29,33 @@ type SignerAccount struct {
 	Account *wallet.Account
 }
 
-// NEP17Decimals invokes `decimals` NEP17 method on a specified contract.
+// NEP17Decimals invokes `decimals` NEP-17 method on a specified contract.
 func (c *Client) NEP17Decimals(tokenHash util.Uint160) (int64, error) {
 	return c.nepDecimals(tokenHash)
 }
 
-// NEP17Symbol invokes `symbol` NEP17 method on a specified contract.
+// NEP17Symbol invokes `symbol` NEP-17 method on a specified contract.
 func (c *Client) NEP17Symbol(tokenHash util.Uint160) (string, error) {
 	return c.nepSymbol(tokenHash)
 }
 
-// NEP17TotalSupply invokes `totalSupply` NEP17 method on a specified contract.
+// NEP17TotalSupply invokes `totalSupply` NEP-17 method on a specified contract.
 func (c *Client) NEP17TotalSupply(tokenHash util.Uint160) (int64, error) {
 	return c.nepTotalSupply(tokenHash)
 }
 
-// NEP17BalanceOf invokes `balanceOf` NEP17 method on a specified contract.
+// NEP17BalanceOf invokes `balanceOf` NEP-17 method on a specified contract.
 func (c *Client) NEP17BalanceOf(tokenHash, acc util.Uint160) (int64, error) {
 	return c.nepBalanceOf(tokenHash, acc, nil)
 }
 
-// NEP17TokenInfo returns full NEP17 token info.
+// NEP17TokenInfo returns full NEP-17 token info.
 func (c *Client) NEP17TokenInfo(tokenHash util.Uint160) (*wallet.Token, error) {
 	return c.nepTokenInfo(tokenHash, manifest.NEP17StandardName)
 }
 
 // CreateNEP17TransferTx creates an invocation transaction for the 'transfer'
-// method of a given contract (token) to move specified amount of NEP17 assets
+// method of a given contract (token) to move specified amount of NEP-17 assets
 // (in FixedN format using contract's number of decimals) to given account and
 // returns it. The returned transaction is not signed.
 func (c *Client) CreateNEP17TransferTx(acc *wallet.Account, to util.Uint160,
@@ -70,7 +70,7 @@ func (c *Client) CreateNEP17TransferTx(acc *wallet.Account, to util.Uint160,
 }
 
 // CreateNEP17MultiTransferTx creates an invocation transaction for performing
-// NEP17 transfers from a single sender to multiple recipients with the given
+// NEP-17 transfers from a single sender to multiple recipients with the given
 // data and cosigners. Transaction's sender is included with the CalledByEntry
 // scope by default.
 func (c *Client) CreateNEP17MultiTransferTx(acc *wallet.Account, gas int64,
@@ -134,7 +134,7 @@ func (c *Client) CreateTxFromScript(script []byte, acc *wallet.Account, sysFee,
 }
 
 // TransferNEP17 creates an invocation transaction that invokes 'transfer' method
-// on a given token to move specified amount of NEP17 assets (in FixedN format
+// on a given token to move specified amount of NEP-17 assets (in FixedN format
 // using contract's number of decimals) to given account with data specified and
 // sends it to the network returning just a hash of it. Cosigners argument
 // specifies a set of the transaction cosigners (may be nil or may include sender)
diff --git a/pkg/rpc/server/server.go b/pkg/rpc/server/server.go
index 70ec058a5..81bf5f6ca 100644
--- a/pkg/rpc/server/server.go
+++ b/pkg/rpc/server/server.go
@@ -682,7 +682,7 @@ func (s *Server) getNEP11Balances(ps request.Params) (interface{}, *response.Err
 	}
 	lastUpdated, err := s.chain.GetTokenLastUpdated(u)
 	if err != nil {
-		return nil, response.NewRPCError("Failed to get NEP11 last updated block", err.Error(), err)
+		return nil, response.NewRPCError("Failed to get NEP-11 last updated block", err.Error(), err)
 	}
 	var count int
 	stateSyncPoint := lastUpdated[math.MinInt32]
@@ -804,7 +804,7 @@ func (s *Server) getNEP17Balances(ps request.Params) (interface{}, *response.Err
 	}
 	lastUpdated, err := s.chain.GetTokenLastUpdated(u)
 	if err != nil {
-		return nil, response.NewRPCError("Failed to get NEP17 last updated block", err.Error(), err)
+		return nil, response.NewRPCError("Failed to get NEP-17 last updated block", err.Error(), err)
 	}
 	stateSyncPoint := lastUpdated[math.MinInt32]
 	bw := io.NewBufBinWriter()
diff --git a/pkg/smartcontract/manifest/manifest.go b/pkg/smartcontract/manifest/manifest.go
index 57fa3477e..4f25c5416 100644
--- a/pkg/smartcontract/manifest/manifest.go
+++ b/pkg/smartcontract/manifest/manifest.go
@@ -15,9 +15,9 @@ const (
 	// MaxManifestSize is a max length for a valid contract manifest.
 	MaxManifestSize = math.MaxUint16
 
-	// NEP11StandardName represents the name of NEP11 smartcontract standard.
+	// NEP11StandardName represents the name of NEP-11 smartcontract standard.
 	NEP11StandardName = "NEP-11"
-	// NEP17StandardName represents the name of NEP17 smartcontract standard.
+	// NEP17StandardName represents the name of NEP-17 smartcontract standard.
 	NEP17StandardName = "NEP-17"
 	// NEP11Payable represents the name of contract interface which can receive NEP-11 tokens.
 	NEP11Payable = "NEP-11-Payable"
diff --git a/pkg/wallet/token_test.go b/pkg/wallet/token_test.go
index ee48c485a..cf6275ee2 100644
--- a/pkg/wallet/token_test.go
+++ b/pkg/wallet/token_test.go
@@ -14,9 +14,9 @@ func TestToken_MarshalJSON(t *testing.T) {
 	h, err := util.Uint160DecodeStringLE("f8d448b227991cf07cb96a6f9c0322437f1599b9")
 	require.NoError(t, err)
 
-	tok := NewToken(h, "NEP17 Standard", "NEP17", 8, manifest.NEP17StandardName)
-	require.Equal(t, "NEP17 Standard", tok.Name)
-	require.Equal(t, "NEP17", tok.Symbol)
+	tok := NewToken(h, "NEP-17 standard token", "NEPT", 8, manifest.NEP17StandardName)
+	require.Equal(t, "NEP-17 standard token", tok.Name)
+	require.Equal(t, "NEPT", tok.Symbol)
 	require.EqualValues(t, 8, tok.Decimals)
 	require.Equal(t, h, tok.Hash)
 	require.Equal(t, "NcqKahsZ93ZyYS5bep8G2TY1zRB7tfUPdK", tok.Address())