TrueCloudLab/neoneo-go
7
0
Fork 2
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #1281 from nspcc-dev/drop-go-1.12-and-fix-some-things

Browse source 
Drop go 1.12 and fix some things
This commit is contained in:
Roman Khimov 2020-08-07 13:34:54 +03:00 committed by GitHub
commit c3c88a57cd
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
54 changed files with 235 additions and 280 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
.circleci/config.yml
View file

@ -3,11 +3,6 @@ orbs:
codecov: codecov/codecov@1.0.5
executors:
go1_12:
docker:
- image: circleci/golang:1.12
environment:
GO111MODULE: "on"
go1_13:
docker:
- image: circleci/golang:1.13
@ -54,16 +49,6 @@ jobs:
name: go-vet
command: go vet ./...
test_1_12:
working_directory: /go/src/github.com/nspcc-dev/neo-go
executor: go1_12
steps:
- checkout
- run: git submodule sync
- run: git submodule update --init
- gomod
- run: go test -v -race ./...
test_1_13:
working_directory: /go/src/github.com/nspcc-dev/neo-go
executor: go1_13
@ -100,7 +85,7 @@ jobs:
build_cli:
working_directory: /go/src/github.com/nspcc-dev/neo-go
executor: go1_12
executor: go1_14
steps:
- checkout
- gomod
@ -111,7 +96,7 @@ jobs:
build_image:
working_directory: /go/src/github.com/nspcc-dev/neo-go
executor: go1_12
executor: go1_14
docker:
- image: golang:1-alpine
steps:
@ -142,10 +127,6 @@ workflows:
filters:
tags:
only: v/[0-9]+\.[0-9]+\.[0-9]+/
- test_1_12:
filters:
tags:
only: v/[0-9]+\.[0-9]+\.[0-9]+/
- test_1_13:
filters:
tags:

2
.travis.yml
View file

@ -1,6 +1,6 @@
language: go
go:
- 1.12.x
- 1.14.x
env:
- GO111MODULE=on
install:

2
Dockerfile
View file

@ -19,7 +19,7 @@ RUN set -x \
&& export GO111MODULE=on \
&& export CGO_ENABLED=0 \
&& export LDFLAGS="-X ${REPO}/pkg/config.Version=${VERSION}" \
&& go build -v -mod=vendor -ldflags "${LDFLAGS}" -o /go/bin/neo-go ./cli
&& go build -trimpath -v -mod=vendor -ldflags "${LDFLAGS}" -o /go/bin/neo-go ./cli
# Executable image
FROM alpine

2
Makefile
View file

@ -26,7 +26,7 @@ build: deps
@set -x \
&& export GOGC=off \
&& export CGO_ENABLED=0 \
&& go build -v -mod=vendor -ldflags $(BUILD_FLAGS) -o ${BINARY} ./cli/main.go
&& go build -trimpath -v -mod=vendor -ldflags $(BUILD_FLAGS) -o ${BINARY} ./cli/main.go
neo-go.service: neo-go.service.template
@sed -r -e 's_BINDIR_$(BINDIR)_' -e 's_UNITWORKDIR_$(UNITWORKDIR)_' -e 's_SYSCONFIGDIR_$(SYSCONFIGDIR)_' $< >$@

2
README.md
View file

@ -36,7 +36,7 @@ Neo 3 code (0.90.0 being compatible with Neo 3 preview2).
## Installation
Go: 1.12+
Go: 1.13+
Install dependencies.

17
cli/server/server.go
View file

@ -15,7 +15,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/network"
"github.com/nspcc-dev/neo-go/pkg/network/metrics"
"github.com/nspcc-dev/neo-go/pkg/rpc/server"
"github.com/pkg/errors"
"github.com/urfave/cli"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
@ -198,7 +197,7 @@ func dumpDB(ctx *cli.Context) error {
bh := chain.GetHeaderHash(int(i))
b, err := chain.GetBlock(bh)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to get block %d: %s", i, err), 1)
return cli.NewExitError(fmt.Errorf("failed to get block %d: %w", i, err), 1)
}
buf := io.NewBufBinWriter()
b.EncodeBinary(buf.BinWriter)
@ -296,7 +295,7 @@ func restoreDB(ctx *cli.Context) error {
} else {
err = chain.AddBlock(block)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to add block %d: %s", i, err), 1)
return cli.NewExitError(fmt.Errorf("failed to add block %d: %w", i, err), 1)
}
}
if dumpDir != "" {
@ -309,7 +308,7 @@ func restoreDB(ctx *cli.Context) error {
lastIndex = block.Index
if block.Index%1000 == 0 {
if err := dump.tryPersist(dumpDir, block.Index); err != nil {
return cli.NewExitError(fmt.Errorf("can't dump storage to file: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't dump storage to file: %w", err), 1)
}
}
}
@ -350,7 +349,7 @@ func startServer(ctx *cli.Context) error {
serv, err := network.NewServer(serverConfig, chain, log)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to create network server: %v", err), 1)
return cli.NewExitError(fmt.Errorf("failed to create network server: %w", err), 1)
}
rpcServer := server.New(chain, cfg.ApplicationConfiguration.RPC, serv, log)
errChan := make(chan error)
@ -367,13 +366,13 @@ Main:
for {
select {
case err := <-errChan:
shutdownErr = errors.Wrap(err, "Error encountered by server")
shutdownErr = fmt.Errorf("server error: %w", err)
cancel()
case <-grace.Done():
serv.Shutdown()
if serverErr := rpcServer.Shutdown(); serverErr != nil {
shutdownErr = errors.Wrap(serverErr, "Error encountered whilst shutting down server")
shutdownErr = fmt.Errorf("error on shutdown: %w", serverErr)
}
prometheus.ShutDown()
pprof.ShutDown()
@ -411,12 +410,12 @@ func configureAddresses(cfg config.ApplicationConfiguration) {
func initBlockChain(cfg config.Config, log *zap.Logger) (*core.Blockchain, error) {
store, err := storage.NewStore(cfg.ApplicationConfiguration.DBConfiguration)
if err != nil {
return nil, cli.NewExitError(fmt.Errorf("could not initialize storage: %s", err), 1)
return nil, cli.NewExitError(fmt.Errorf("could not initialize storage: %w", err), 1)
}
chain, err := core.NewBlockchain(store, cfg.ProtocolConfiguration, log)
if err != nil {
return nil, cli.NewExitError(fmt.Errorf("could not initialize blockchain: %s", err), 1)
return nil, cli.NewExitError(fmt.Errorf("could not initialize blockchain: %w", err), 1)
}
return chain, nil
}

34
cli/smartcontract/smart_contract.go
View file

@ -4,6 +4,7 @@ import (
"bytes"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"os"
@ -25,7 +26,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm"
"github.com/nspcc-dev/neo-go/pkg/wallet"
"github.com/pkg/errors"
"github.com/urfave/cli"
"golang.org/x/crypto/ssh/terminal"
)
@ -411,7 +411,7 @@ func invokeInternal(ctx *cli.Context, signAndPush bool) error {
}
script, err := util.Uint160DecodeStringLE(args[0])
if err != nil {
return cli.NewExitError(fmt.Errorf("incorrect script hash: %v", err), 1)
return cli.NewExitError(fmt.Errorf("incorrect script hash: %w", err), 1)
}
if len(args) <= 1 {
return cli.NewExitError(errNoMethod, 1)
@ -427,7 +427,7 @@ func invokeInternal(ctx *cli.Context, signAndPush bool) error {
}
param, err := smartcontract.NewParameterFromString(s)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to parse argument #%d: %v", k+paramsStart+1, err), 1)
return cli.NewExitError(fmt.Errorf("failed to parse argument #%d: %w", k+paramsStart+1, err), 1)
}
params = append(params, *param)
}
@ -437,7 +437,7 @@ func invokeInternal(ctx *cli.Context, signAndPush bool) error {
for i, c := range args[cosignersStart:] {
cosigner, err := parseCosigner(c)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to parse cosigner #%d: %v", i+1, err), 1)
return cli.NewExitError(fmt.Errorf("failed to parse cosigner #%d: %w", i+1, err), 1)
}
cosigners = append(cosigners, cosigner)
}
@ -468,11 +468,11 @@ func invokeInternal(ctx *cli.Context, signAndPush bool) error {
}
script, err := hex.DecodeString(resp.Script)
if err != nil {
return cli.NewExitError(fmt.Errorf("bad script returned from the RPC node: %v", err), 1)
return cli.NewExitError(fmt.Errorf("bad script returned from the RPC node: %w", err), 1)
}
txHash, err := c.SignAndPushInvocationTx(script, acc, resp.GasConsumed, gas, cosigners)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to push invocation tx: %v", err), 1)
return cli.NewExitError(fmt.Errorf("failed to push invocation tx: %w", err), 1)
}
fmt.Printf("Sent invocation transaction %s\n", txHash.StringLE())
} else {
@ -499,7 +499,7 @@ func testInvokeScript(ctx *cli.Context) error {
}
nefFile, err := nef.FileFromBytes(b)
if err != nil {
return cli.NewExitError(errors.Wrapf(err, "failed to restore .nef file"), 1)
return cli.NewExitError(fmt.Errorf("failed to restore .nef file: %w", err), 1)
}
args := ctx.Args()
@ -508,7 +508,7 @@ func testInvokeScript(ctx *cli.Context) error {
for i, c := range args[:] {
cosigner, err := parseCosigner(c)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to parse signer #%d: %v", i+1, err), 1)
return cli.NewExitError(fmt.Errorf("failed to parse signer #%d: %w", i+1, err), 1)
}
signers = append(signers, cosigner)
}
@ -570,12 +570,12 @@ func inspect(ctx *cli.Context) error {
if compile {
b, err = compiler.Compile(bytes.NewReader(b))
if err != nil {
return cli.NewExitError(errors.Wrap(err, "failed to compile"), 1)
return cli.NewExitError(fmt.Errorf("failed to compile: %w", err), 1)
}
} else {
nefFile, err := nef.FileFromBytes(b)
if err != nil {
return cli.NewExitError(errors.Wrapf(err, "failed to restore .nef file"), 1)
return cli.NewExitError(fmt.Errorf("failed to restore .nef file: %w", err), 1)
}
b = nefFile.Script
}
@ -645,17 +645,17 @@ func contractDeploy(ctx *cli.Context) error {
}
nefFile, err := nef.FileFromBytes(f)
if err != nil {
return cli.NewExitError(errors.Wrapf(err, "failed to restore .nef file"), 1)
return cli.NewExitError(fmt.Errorf("failed to restore .nef file: %w", err), 1)
}
manifestBytes, err := ioutil.ReadFile(manifestFile)
if err != nil {
return cli.NewExitError(errors.Wrapf(err, "failed to read manifest file"), 1)
return cli.NewExitError(fmt.Errorf("failed to read manifest file: %w", err), 1)
}
m := &manifest.Manifest{}
err = json.Unmarshal(manifestBytes, m)
if err != nil {
return cli.NewExitError(errors.Wrapf(err, "failed to restore manifest file"), 1)
return cli.NewExitError(fmt.Errorf("failed to restore manifest file: %w", err), 1)
}
gctx, cancel := options.GetTimeoutContext(ctx)
@ -668,17 +668,17 @@ func contractDeploy(ctx *cli.Context) error {
txScript, err := request.CreateDeploymentScript(nefFile.Script, m)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to create deployment script: %v", err), 1)
return cli.NewExitError(fmt.Errorf("failed to create deployment script: %w", err), 1)
}
// It doesn't require any signers.
invRes, err := c.InvokeScript(txScript, nil)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to test-invoke deployment script: %v", err), 1)
return cli.NewExitError(fmt.Errorf("failed to test-invoke deployment script: %w", err), 1)
}
txHash, err := c.SignAndPushInvocationTx(txScript, acc, invRes.GasConsumed, gas, nil)
if err != nil {
return cli.NewExitError(fmt.Errorf("failed to push invocation tx: %v", err), 1)
return cli.NewExitError(fmt.Errorf("failed to push invocation tx: %w", err), 1)
}
fmt.Printf("Sent deployment transaction %s for contract %s\n", txHash.StringLE(), nefFile.Header.ScriptHash.StringLE())
return nil
@ -693,7 +693,7 @@ func parseContractConfig(confFile string) (ProjectConfig, error) {
err = yaml.Unmarshal(confBytes, &conf)
if err != nil {
return conf, cli.NewExitError(fmt.Errorf("bad config: %v", err), 1)
return conf, cli.NewExitError(fmt.Errorf("bad config: %w", err), 1)
}
return conf, nil
}

14
cli/wallet/multisig.go
View file

@ -48,7 +48,7 @@ func signMultisig(ctx *cli.Context) error {
addr := ctx.String("addr")
sh, err := address.StringToUint160(addr)
if err != nil {
return cli.NewExitError(fmt.Errorf("invalid address: %v", err), 1)
return cli.NewExitError(fmt.Errorf("invalid address: %w", err), 1)
}
acc := wall.GetAccount(sh)
if acc == nil {
@ -65,13 +65,13 @@ func signMultisig(ctx *cli.Context) error {
if err != nil {
return cli.NewExitError(err, 1)
} else if err := acc.Decrypt(pass); err != nil {
return cli.NewExitError(fmt.Errorf("can't unlock an account: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't unlock an account: %w", err), 1)
}
priv := acc.PrivateKey()
sign := priv.Sign(tx.GetSignedPart())
if err := c.AddSignature(acc.Contract, priv.PublicKey(), sign); err != nil {
return cli.NewExitError(fmt.Errorf("can't add signature: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't add signature: %w", err), 1)
} else if err := writeParameterContext(c, ctx.String("out")); err != nil {
return cli.NewExitError(err, 1)
}
@ -104,21 +104,21 @@ func signMultisig(ctx *cli.Context) error {
func readParameterContext(filename string) (*context.ParameterContext, error) {
data, err := ioutil.ReadFile(filename)
if err != nil {
return nil, fmt.Errorf("can't read input file: %v", err)
return nil, fmt.Errorf("can't read input file: %w", err)
}
c := new(context.ParameterContext)
if err := json.Unmarshal(data, c); err != nil {
return nil, fmt.Errorf("can't parse transaction: %v", err)
return nil, fmt.Errorf("can't parse transaction: %w", err)
}
return c, nil
}
func writeParameterContext(c *context.ParameterContext, filename string) error {
if data, err := json.Marshal(c); err != nil {
return fmt.Errorf("can't marshal transaction: %v", err)
return fmt.Errorf("can't marshal transaction: %w", err)
} else if err := ioutil.WriteFile(filename, data, 0644); err != nil {
return fmt.Errorf("can't write transaction to file: %v", err)
return fmt.Errorf("can't write transaction to file: %w", err)
}
return nil
}

20
cli/wallet/nep5.go
View file

@ -144,7 +144,7 @@ func getNEP5Balance(ctx *cli.Context) error {
addr := ctx.String("addr")
addrHash, err := address.StringToUint160(addr)
if err != nil {
return cli.NewExitError(fmt.Errorf("invalid address: %v", err), 1)
return cli.NewExitError(fmt.Errorf("invalid address: %w", err), 1)
}
acc := wall.GetAccount(addrHash)
if acc == nil {
@ -242,7 +242,7 @@ func importNEP5Token(ctx *cli.Context) error {
tokenHash, err := util.Uint160DecodeStringLE(ctx.String("token"))
if err != nil {
return cli.NewExitError(fmt.Errorf("invalid token contract hash: %v", err), 1)
return cli.NewExitError(fmt.Errorf("invalid token contract hash: %w", err), 1)
}
for _, t := range wall.Extra.Tokens {
@ -262,7 +262,7 @@ func importNEP5Token(ctx *cli.Context) error {
tok, err := c.NEP5TokenInfo(tokenHash)
if err != nil {
return cli.NewExitError(fmt.Errorf("can't receive token info: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't receive token info: %w", err), 1)
}
wall.AddToken(tok)
@ -327,9 +327,9 @@ func removeNEP5Token(ctx *cli.Context) error {
}
}
if err := wall.RemoveToken(token.Hash); err != nil {
return cli.NewExitError(fmt.Errorf("can't remove token: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't remove token: %w", err), 1)
} else if err := wall.Save(); err != nil {
return cli.NewExitError(fmt.Errorf("error while saving wallet: %v", err), 1)
return cli.NewExitError(fmt.Errorf("error while saving wallet: %w", err), 1)
}
return nil
}
@ -385,7 +385,7 @@ func multiTransferNEP5(ctx *cli.Context) error {
}
amount, err := util.FixedNFromString(ss[2], int(token.Decimals))
if err != nil {
return cli.NewExitError(fmt.Errorf("invalid amount: %v", err), 1)
return cli.NewExitError(fmt.Errorf("invalid amount: %w", err), 1)
}
recepients = append(recepients, client.TransferTarget{
Token: token.Hash,
@ -432,7 +432,7 @@ func transferNEP5(ctx *cli.Context) error {
amount, err := util.FixedNFromString(ctx.String("amount"), int(token.Decimals))
if err != nil {
return cli.NewExitError(fmt.Errorf("invalid amount: %v", err), 1)
return cli.NewExitError(fmt.Errorf("invalid amount: %w", err), 1)
}
return signAndSendTransfer(ctx, c, acc, []client.TransferTarget{{
@ -464,11 +464,11 @@ func signAndSendTransfer(ctx *cli.Context, c *client.Client, acc *wallet.Account
sign := priv.Sign(tx.GetSignedPart())
scCtx := context.NewParameterContext("Neo.Core.ContractTransaction", tx)
if err := scCtx.AddSignature(acc.Contract, pub, sign); err != nil {
return cli.NewExitError(fmt.Errorf("can't add signature: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't add signature: %w", err), 1)
} else if data, err := json.Marshal(scCtx); err != nil {
return cli.NewExitError(fmt.Errorf("can't marshal tx to JSON: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't marshal tx to JSON: %w", err), 1)
} else if err := ioutil.WriteFile(outFile, data, 0644); err != nil {
return cli.NewExitError(fmt.Errorf("can't write tx to file: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't write tx to file: %w", err), 1)
}
} else {
_ = acc.SignTx(tx)

12
cli/wallet/wallet.go
View file

@ -284,7 +284,7 @@ func convertWallet(ctx *cli.Context) error {
address.Prefix = address.NEO3Prefix
newAcc, err := wallet.NewAccountFromWIF(acc.PrivateKey().WIF())
if err != nil {
return cli.NewExitError(fmt.Errorf("can't convert account: %v", err), -1)
return cli.NewExitError(fmt.Errorf("can't convert account: %w", err), -1)
}
newAcc.Address = address.Uint160ToString(acc.Contract.ScriptHash())
newAcc.Contract = acc.Contract
@ -292,7 +292,7 @@ func convertWallet(ctx *cli.Context) error {
newAcc.Label = acc.Label
newAcc.Locked = acc.Locked
if err := newAcc.Encrypt(pass); err != nil {
return cli.NewExitError(fmt.Errorf("can't encrypt converted account: %v", err), -1)
return cli.NewExitError(fmt.Errorf("can't encrypt converted account: %w", err), -1)
}
newWallet.AddAccount(newAcc)
}
@ -333,7 +333,7 @@ func exportKeys(ctx *cli.Context) error {
addr = ctx.Args().First()
_, err := address.StringToUint160(addr)
if err != nil {
return cli.NewExitError(fmt.Errorf("can't parse address: %v", err), 1)
return cli.NewExitError(fmt.Errorf("can't parse address: %w", err), 1)
}
}
@ -394,7 +394,7 @@ func importMultisig(ctx *cli.Context) error {
for i := range args {
pubs[i], err = keys.NewPublicKeyFromString(args[i])
if err != nil {
return cli.NewExitError(fmt.Errorf("can't decode public key %d: %v", i, err), 1)
return cli.NewExitError(fmt.Errorf("can't decode public key %d: %w", i, err), 1)
}
}
@ -468,9 +468,9 @@ func removeAccount(ctx *cli.Context) error {
}
if err := wall.RemoveAccount(acc.Address); err != nil {
return cli.NewExitError(fmt.Errorf("error on remove: %v", err), 1)
return cli.NewExitError(fmt.Errorf("error on remove: %w", err), 1)
} else if err := wall.Save(); err != nil {
return cli.NewExitError(fmt.Errorf("error while saving wallet: %v", err), 1)
return cli.NewExitError(fmt.Errorf("error while saving wallet: %w", err), 1)
}
return nil
}

23
docs/conventions.md
View file

@ -14,4 +14,25 @@ func example(test int) (num int) {
return
}
In the above function we have used a named return paramter, which allows you to include a simple return statement without the variables you are returning. This practice can cause confusion when functions become large or the logic becomes complex, so these should be avoided.
In the above function we have used a named return paramter, which allows you to include a simple return statement without the variables you are returning. This practice can cause confusion when functions become large or the logic becomes complex, so these should be avoided.
## Use error wrapping
Bad:
```
err = SomeAPI()
if err != nil {
return fmt.Errorf("something bad happened: %v", err)
}
```
Good:
```
err = SomeAPI()
if err != nil {
return fmt.Errorf("something bad happened: %w", err)
}
```
Error wrapping allows `errors.Is` and `errors.As` usage in upper layer
functions which might be useful.

3
go.mod
View file

@ -13,7 +13,6 @@ require (
github.com/nspcc-dev/dbft v0.0.0-20200711144034-c526ccc6f570
github.com/nspcc-dev/rfc6979 v0.2.0
github.com/pierrec/lz4 v2.5.2+incompatible
github.com/pkg/errors v0.8.1
github.com/prometheus/client_golang v1.2.1
github.com/stretchr/testify v1.4.0
github.com/syndtr/goleveldb v0.0.0-20180307113352-169b1b37be73
@ -28,4 +27,4 @@ require (
gopkg.in/abiosoft/ishell.v2 v2.0.0
)
go 1.12
go 1.13

11
pkg/compiler/compiler.go
View file

@ -15,7 +15,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/smartcontract/nef"
"github.com/pkg/errors"
"golang.org/x/tools/go/loader"
)
@ -141,15 +140,15 @@ func CompileAndSave(src string, o *Options) ([]byte, error) {
}
b, di, err := CompileWithDebugInfo(bytes.NewReader(b))
if err != nil {
return nil, fmt.Errorf("error while trying to compile smart contract file: %v", err)
return nil, fmt.Errorf("error while trying to compile smart contract file: %w", err)
}
f, err := nef.NewFile(b)
if err != nil {
return nil, fmt.Errorf("error while trying to create .nef file: %v", err)
return nil, fmt.Errorf("error while trying to create .nef file: %w", err)
}
bytes, err := f.Bytes()
if err != nil {
return nil, fmt.Errorf("error while serializing .nef file: %v", err)
return nil, fmt.Errorf("error while serializing .nef file: %w", err)
}
out := fmt.Sprintf("%s.%s", o.Outfile, o.Ext)
err = ioutil.WriteFile(out, bytes, os.ModePerm)
@ -179,11 +178,11 @@ func CompileAndSave(src string, o *Options) ([]byte, error) {
if o.ManifestFile != "" {
m, err := di.ConvertToManifest(o.ContractFeatures, o.ContractSupportedStandards...)
if err != nil {
return b, errors.Wrap(err, "failed to convert debug info to manifest")
return b, fmt.Errorf("failed to convert debug info to manifest: %w", err)
}
mData, err := json.Marshal(m)
if err != nil {
return b, errors.Wrap(err, "failed to marshal manifest")
return b, fmt.Errorf("failed to marshal manifest to JSON: %w", err)
}
return b, ioutil.WriteFile(o.ManifestFile, mData, os.ModePerm)
}

7
pkg/config/config.go
View file

@ -7,7 +7,6 @@ import (
"github.com/go-yaml/yaml"
"github.com/nspcc-dev/neo-go/pkg/config/netmode"
"github.com/pkg/errors"
)
const userAgentFormat = "/NEO-GO:%s/"
@ -37,12 +36,12 @@ func Load(path string, netMode netmode.Magic) (Config, error) {
// LoadFile loads config from the provided path.
func LoadFile(configPath string) (Config, error) {
if _, err := os.Stat(configPath); os.IsNotExist(err) {
return Config{}, errors.Wrap(err, "Unable to load config")
return Config{}, fmt.Errorf("config '%s' doesn't exist", configPath)
}
configData, err := ioutil.ReadFile(configPath)
if err != nil {
return Config{}, errors.Wrap(err, "Unable to read config")
return Config{}, fmt.Errorf("unable to read config: %w", err)
}
config := Config{
@ -54,7 +53,7 @@ func LoadFile(configPath string) (Config, error) {
err = yaml.Unmarshal(configData, &config)
if err != nil {
return Config{}, errors.Wrap(err, "Problem unmarshaling config json data")
return Config{}, fmt.Errorf("failed to unmarshal config YAML: %w", err)
}
return config, nil

6
pkg/consensus/payload.go
View file

@ -1,6 +1,7 @@
package consensus
import (
"errors"
"fmt"
"github.com/nspcc-dev/dbft/payload"
@ -14,7 +15,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/emit"
"github.com/pkg/errors"
)
type (
@ -306,7 +306,7 @@ func (m *message) DecodeBinary(r *io.BinReader) {
case recoveryMessageType:
m.payload = new(recoveryMessage)
default:
r.Err = errors.Errorf("invalid type: 0x%02x", byte(m.Type))
r.Err = fmt.Errorf("invalid type: 0x%02x", byte(m.Type))
return
}
m.payload.DecodeBinary(r)
@ -338,7 +338,7 @@ func (p *Payload) decodeData() error {
br := io.NewBinReaderFromBuf(p.data)
m.DecodeBinary(br)
if br.Err != nil {
return errors.Wrap(br.Err, "cannot decode data into message")
return fmt.Errorf("can't decode message: %w", br.Err)
}
p.message = m
return nil

3
pkg/consensus/recovery_message.go
View file

@ -1,11 +1,12 @@
package consensus
import (
"errors"
"github.com/nspcc-dev/dbft/crypto"
"github.com/nspcc-dev/dbft/payload"
"github.com/nspcc-dev/neo-go/pkg/io"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/pkg/errors"
)
type (

118
pkg/core/blockchain.go
View file

@ -1,9 +1,9 @@
package core
import (
"errors"
"fmt"
"math/big"
"sort"
"sync"
"sync/atomic"
"time"
@ -27,7 +27,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/vm"
"github.com/nspcc-dev/neo-go/pkg/vm/emit"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -223,7 +222,7 @@ func (bc *Blockchain) init() error {
bc.blockHeight = bHeight
bc.persistedHeight = bHeight
if err = bc.dao.InitMPT(bHeight); err != nil {
return errors.Wrapf(err, "can't init MPT at height %d", bHeight)
return fmt.Errorf("can't init MPT at height %d: %w", bHeight, err)
}
hashes, err := bc.dao.GetHeaderHashes()
@ -263,7 +262,7 @@ func (bc *Blockchain) init() error {
for hash != targetHash {
header, err := bc.GetHeader(hash)
if err != nil {
return fmt.Errorf("could not get header %s: %s", hash, err)
return fmt.Errorf("could not get header %s: %w", hash, err)
}
headers = append(headers, header)
hash = header.PrevHash
@ -420,7 +419,7 @@ func (bc *Blockchain) AddBlock(block *block.Block) error {
expectedHeight := bc.BlockHeight() + 1
if expectedHeight != block.Index {
return ErrInvalidBlockIndex
return fmt.Errorf("expected %d, got %d: %w", expectedHeight, block.Index, ErrInvalidBlockIndex)
}
headerLen := bc.headerListLen()
@ -433,13 +432,13 @@ func (bc *Blockchain) AddBlock(block *block.Block) error {
if bc.config.VerifyBlocks {
err := block.Verify()
if err != nil {
return fmt.Errorf("block %s is invalid: %s", block.Hash().StringLE(), err)
return fmt.Errorf("block %s is invalid: %w", block.Hash().StringLE(), err)
}
if bc.config.VerifyTransactions {
for _, tx := range block.Transactions {
err := bc.VerifyTx(tx, block)
if err != nil {
return fmt.Errorf("transaction %s failed to verify: %s", tx.Hash().StringLE(), err)
return fmt.Errorf("transaction %s failed to verify: %w", tx.Hash().StringLE(), err)
}
}
}
@ -478,7 +477,7 @@ func (bc *Blockchain) addHeaders(verify bool, headers ...*block.Header) (err err
// Verify that the chain of the headers is consistent.
var lastHeader *block.Header
if lastHeader, err = bc.GetHeader(headers[0].PrevHash); err != nil {
return fmt.Errorf("previous header was not found: %v", err)
return fmt.Errorf("previous header was not found: %w", err)
}
for _, h := range headers {
if err = bc.verifyHeader(h, lastHeader); err != nil {
@ -579,9 +578,9 @@ func (bc *Blockchain) storeBlock(block *block.Block) error {
v.LoadScriptWithFlags(bc.contracts.GetPersistScript(), smartcontract.AllowModifyStates|smartcontract.AllowCall)
v.SetPriceGetter(getPrice)
if err := v.Run(); err != nil {
return errors.Wrap(err, "can't persist native contracts")
return fmt.Errorf("onPersist run failed: %w", err)
} else if _, err := systemInterop.DAO.Persist(); err != nil {
return errors.Wrap(err, "can't persist `onPersist` changes")
return fmt.Errorf("can't save onPersist changes: %w", err)
}
for i := range systemInterop.Notifications {
bc.handleNotification(&systemInterop.Notifications[i], cache, block, block.Hash())
@ -597,7 +596,7 @@ func (bc *Blockchain) storeBlock(block *block.Block) error {
appExecResults = append(appExecResults, aer)
err := cache.PutAppExecResult(aer)
if err != nil {
return errors.Wrap(err, "failed to Store notifications")
return fmt.Errorf("failed to store onPersist exec result: %w", err)
}
}
@ -616,7 +615,7 @@ func (bc *Blockchain) storeBlock(block *block.Block) error {
if !v.HasFailed() {
_, err := systemInterop.DAO.Persist()
if err != nil {
return errors.Wrap(err, "failed to persist invocation results")
return fmt.Errorf("failed to persist invocation results: %w", err)
}
for i := range systemInterop.Notifications {
bc.handleNotification(&systemInterop.Notifications[i], cache, block, tx.Hash())
@ -638,7 +637,7 @@ func (bc *Blockchain) storeBlock(block *block.Block) error {
appExecResults = append(appExecResults, aer)
err = cache.PutAppExecResult(aer)
if err != nil {
return errors.Wrap(err, "failed to Store notifications")
return fmt.Errorf("failed to store tx exec result: %w", err)
}
}
@ -647,7 +646,7 @@ func (bc *Blockchain) storeBlock(block *block.Block) error {
if block.Index > 0 {
prev, err := bc.dao.GetStateRoot(block.Index - 1)
if err != nil {
return errors.WithMessagef(err, "can't get previous state root")
return fmt.Errorf("can't get previous state root: %w", err)
}
prevHash = hash.DoubleSha256(prev.GetSignedPart())
}
@ -1204,41 +1203,26 @@ func (bc *Blockchain) verifyHeader(currHeader, prevHeader *block.Header) error {
func (bc *Blockchain) verifyTx(t *transaction.Transaction, block *block.Block) error {
height := bc.BlockHeight()
if t.ValidUntilBlock <= height || t.ValidUntilBlock > height+transaction.MaxValidUntilBlockIncrement {
return errors.Errorf("transaction has expired. ValidUntilBlock = %d, current height = %d", t.ValidUntilBlock, height)
return fmt.Errorf("transaction has expired. ValidUntilBlock = %d, current height = %d", t.ValidUntilBlock, height)
}
hashes, err := bc.GetScriptHashesForVerifying(t)
if err != nil {
return err
}
blockedAccounts, err := bc.contracts.Policy.GetBlockedAccountsInternal(bc.dao)
if err != nil {
return err
}
for _, h := range hashes {
i := sort.Search(len(blockedAccounts), func(i int) bool {
return !blockedAccounts[i].Less(h)
})
if i != len(blockedAccounts) && blockedAccounts[i].Equals(h) {
return errors.Errorf("policy check failed: account %s is blocked", h.StringLE())
}
}
maxBlockSystemFee := bc.contracts.Policy.GetMaxBlockSystemFeeInternal(bc.dao)
if maxBlockSystemFee < t.SystemFee {
return errors.Errorf("policy check failed: transaction's fee shouldn't exceed maximum block system fee %d", maxBlockSystemFee)
// Policying.
if err := bc.contracts.Policy.CheckPolicy(bc.dao, t); err != nil {
// Only one %w can be used.
return fmt.Errorf("%w: %v", ErrPolicy, err)
}
balance := bc.GetUtilityTokenBalance(t.Sender())
need := t.SystemFee + t.NetworkFee
if balance.Cmp(big.NewInt(need)) < 0 {
return errors.Errorf("insufficient funds: balance is %v, need: %v", balance, need)
return fmt.Errorf("insufficient funds: balance is %v, need: %v", balance, need)
}
size := io.GetVarSize(t)
if size > transaction.MaxTransactionSize {
return errors.Errorf("invalid transaction size = %d. It shoud be less then MaxTransactionSize = %d", io.GetVarSize(t), transaction.MaxTransactionSize)
return fmt.Errorf("too big transaction (%d > MaxTransactionSize %d)", size, transaction.MaxTransactionSize)
}
needNetworkFee := int64(size) * bc.FeePerByte()
netFee := t.NetworkFee - needNetworkFee
if netFee < 0 {
return errors.Errorf("insufficient funds: net fee is %v, need %v", t.NetworkFee, needNetworkFee)
return fmt.Errorf("insufficient funds: net fee is %v, need %v", t.NetworkFee, needNetworkFee)
}
if block == nil {
if ok := bc.memPool.Verify(t, bc); !ok {
@ -1286,7 +1270,7 @@ func (bc *Blockchain) AddStateRoot(r *state.MPTRoot) error {
}
}
if err := bc.verifyStateRoot(r); err != nil {
return errors.WithMessage(err, "invalid state root")
return fmt.Errorf("invalid state root: %w", err)
}
if r.Index > bc.BlockHeight() { // just put it into the store for future checks
return bc.dao.PutStateRoot(&state.MPTRootState{
@ -1298,7 +1282,7 @@ func (bc *Blockchain) AddStateRoot(r *state.MPTRoot) error {
flag := state.Unverified
if r.Witness != nil {
if err := bc.verifyStateRootWitness(r); err != nil {
return errors.WithMessage(err, "can't verify signature")
return fmt.Errorf("can't verify signature: %w", err)
}
flag = state.Verified
}
@ -1315,7 +1299,7 @@ func (bc *Blockchain) AddStateRoot(r *state.MPTRoot) error {
func (bc *Blockchain) updateStateHeight(newHeight uint32) error {
h, err := bc.dao.GetCurrentStateRootHeight()
if err != nil {
return errors.WithMessage(err, "can't get current state root height")
return fmt.Errorf("can't get current state root height: %w", err)
} else if newHeight == h+1 {
updateStateHeightMetric(newHeight)
return bc.dao.PutCurrentStateRootHeight(h + 1)
@ -1367,23 +1351,17 @@ func (bc *Blockchain) PoolTx(t *transaction.Transaction) error {
defer bc.lock.RUnlock()
if bc.HasTransaction(t.Hash()) {
return ErrAlreadyExists
return fmt.Errorf("blockchain: %w", ErrAlreadyExists)
}
if err := bc.verifyTx(t, nil); err != nil {
return err
}
// Policying.
if ok, err := bc.contracts.Policy.CheckPolicy(bc.newInteropContext(trigger.Application, bc.dao, nil, t), t); err != nil {
return err
} else if !ok {
return ErrPolicy
}
if err := bc.memPool.Add(t, bc); err != nil {
switch err {
case mempool.ErrOOM:
switch {
case errors.Is(err, mempool.ErrOOM):
return ErrOOM
case mempool.ErrConflict:
return ErrAlreadyExists
case errors.Is(err, mempool.ErrDup):
return fmt.Errorf("mempool: %w", ErrAlreadyExists)
default:
return err
}
@ -1416,19 +1394,6 @@ func (bc *Blockchain) GetEnrollments() ([]state.Validator, error) {
return bc.contracts.NEO.GetCandidates(bc.dao)
}
// GetScriptHashesForVerifying returns all the ScriptHashes of a transaction which will be use
// to verify whether the transaction is bonafide or not.
// Golang implementation of GetScriptHashesForVerifying method in C# (https://github.com/neo-project/neo/blob/master/neo/Network/P2P/Payloads/Transaction.cs#L190)
func (bc *Blockchain) GetScriptHashesForVerifying(t *transaction.Transaction) ([]util.Uint160, error) {
hashesResult := make([]util.Uint160, len(t.Signers))
for i, s := range t.Signers {
hashesResult[i] = s.Account
}
return hashesResult, nil
}
// GetTestVM returns a VM and a Store setup for a test run of some sort of code.
func (bc *Blockchain) GetTestVM(tx *transaction.Transaction) *vm.VM {
systemInterop := bc.newInteropContext(trigger.Application, bc.dao, nil, tx)
@ -1479,12 +1444,12 @@ func (bc *Blockchain) verifyHashAgainstScript(hash util.Uint160, witness *transa
}
err = vm.Run()
if vm.HasFailed() {
return errors.Errorf("vm failed to execute the script with error: %s", err)
return fmt.Errorf("vm execution has failed: %w", err)
}
resEl := vm.Estack().Pop()
if resEl != nil {
if !resEl.Bool() {
return errors.Errorf("signature check failed")
return fmt.Errorf("signature check failed")
}
if useKeys {
bc.keyCacheLock.RLock()
@ -1497,7 +1462,7 @@ func (bc *Blockchain) verifyHashAgainstScript(hash util.Uint160, witness *transa
}
}
} else {
return errors.Errorf("no result returned from the script")
return fmt.Errorf("no result returned from the script")
}
return nil
}
@ -1509,23 +1474,14 @@ func (bc *Blockchain) verifyHashAgainstScript(hash util.Uint160, witness *transa
// not yet added into any block.
// Golang implementation of VerifyWitnesses method in C# (https://github.com/neo-project/neo/blob/master/neo/SmartContract/Helper.cs#L87).
func (bc *Blockchain) verifyTxWitnesses(t *transaction.Transaction, block *block.Block) error {
hashes, err := bc.GetScriptHashesForVerifying(t)
if err != nil {
return err
if len(t.Signers) != len(t.Scripts) {
return fmt.Errorf("number of signers doesn't match witnesses (%d vs %d)", len(t.Signers), len(t.Scripts))
}
witnesses := t.Scripts
if len(hashes) != len(witnesses) {
return errors.Errorf("expected len(hashes) == len(witnesses). got: %d != %d", len(hashes), len(witnesses))
}
sort.Slice(hashes, func(i, j int) bool { return hashes[i].Less(hashes[j]) })
sort.Slice(witnesses, func(i, j int) bool { return witnesses[i].ScriptHash().Less(witnesses[j].ScriptHash()) })
interopCtx := bc.newInteropContext(trigger.Verification, bc.dao, block, t)
for i := 0; i < len(hashes); i++ {
err := bc.verifyHashAgainstScript(hashes[i], &witnesses[i], interopCtx, false, t.NetworkFee)
for i := range t.Signers {
err := bc.verifyHashAgainstScript(t.Signers[i].Account, &t.Scripts[i], interopCtx, false, t.NetworkFee)
if err != nil {
numStr := fmt.Sprintf("witness #%d", i)
return errors.Wrap(err, numStr)
return fmt.Errorf("witness #%d: %w", i, err)
}
}

1
pkg/core/blockchainer/blockchainer.go
View file

@ -44,7 +44,6 @@ type Blockchainer interface {
GetValidators() ([]*keys.PublicKey, error)
GetStandByCommittee() keys.PublicKeys
GetStandByValidators() keys.PublicKeys
GetScriptHashesForVerifying(*transaction.Transaction) ([]util.Uint160, error)
GetStateRoot(height uint32) (*state.MPTRootState, error)
GetStorageItem(id int32, key []byte) *state.StorageItem
GetStorageItems(id int32) (map[string]*state.StorageItem, error)

3
pkg/core/helper_test.go
View file

@ -26,7 +26,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/vm/emit"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/nspcc-dev/neo-go/pkg/wallet"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
"go.uber.org/zap/zaptest"
)
@ -396,7 +395,7 @@ func signTx(bc *Blockchain, txs ...*transaction.Transaction) error {
validators := bc.GetStandByValidators()
rawScript, err := smartcontract.CreateMultiSigRedeemScript(bc.config.ValidatorsCount/2+1, validators)
if err != nil {
return errors.Wrap(err, "fail to sign tx")
return fmt.Errorf("failed to sign tx: %w", err)
}
for _, tx := range txs {
size := io.GetVarSize(tx)

4
pkg/core/interop/crypto/ecdsa.go
View file

@ -62,14 +62,14 @@ func ecdsaCheckMultisig(ic *interop.Context, v *vm.VM, curve elliptic.Curve) err
hashToCheck := hash.Sha256(msg).BytesBE()
pkeys, err := v.Estack().PopSigElements()
if err != nil {
return fmt.Errorf("wrong parameters: %s", err.Error())
return fmt.Errorf("wrong parameters: %w", err)
}
if !v.AddGas(ECDSAVerifyPrice * int64(len(pkeys))) {
return errors.New("gas limit exceeded")
}
sigs, err := v.Estack().PopSigElements()
if err != nil {
return fmt.Errorf("wrong parameters: %s", err.Error())
return fmt.Errorf("wrong parameters: %w", err)
}
// It's ok to have more keys than there are signatures (it would
// just mean that some keys didn't sign), but not the other way around.

3
pkg/core/interop/runtime/util.go
View file

@ -1,12 +1,13 @@
package runtime
import (
"errors"
"github.com/nspcc-dev/neo-go/pkg/core/interop"
"github.com/nspcc-dev/neo-go/pkg/core/state"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
)
// GasLeft returns remaining amount of GAS.

5
pkg/core/interop/runtime/witness.go
View file

@ -2,6 +2,8 @@ package runtime
import (
"crypto/elliptic"
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/core/dao"
"github.com/nspcc-dev/neo-go/pkg/core/interop"
@ -9,7 +11,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm"
"github.com/pkg/errors"
)
// CheckHashedWitness checks given hash against current list of script hashes
@ -91,7 +92,7 @@ func CheckWitness(ic *interop.Context, v *vm.VM) error {
res, err = CheckHashedWitness(ic, hash)
}
if err != nil {
return errors.Wrap(err, "failed to check")
return fmt.Errorf("failed to check witness: %w", err)
}
v.Estack().PushVal(res)
return nil

14
pkg/core/interop_neo.go
View file

@ -74,7 +74,7 @@ func createContractStateFromVM(ic *interop.Context, v *vm.VM) (*state.Contract,
var m manifest.Manifest
err := m.UnmarshalJSON(manifestBytes)
if err != nil {
return nil, fmt.Errorf("unable to retrieve manifest from stack: %v", err)
return nil, fmt.Errorf("unable to retrieve manifest from stack: %w", err)
}
return &state.Contract{
Script: script,
@ -105,7 +105,7 @@ func contractCreate(ic *interop.Context, v *vm.VM) error {
}
cs, err := contractToStackItem(newcontract)
if err != nil {
return fmt.Errorf("cannot convert contract to stack item: %v", err)
return fmt.Errorf("cannot convert contract to stack item: %w", err)
}
v.Estack().PushVal(cs)
return nil
@ -149,10 +149,10 @@ func contractUpdate(ic *interop.Context, v *vm.VM) error {
}
contract.Manifest.ABI.Hash = newHash
if err := ic.DAO.PutContractState(contract); err != nil {
return fmt.Errorf("failed to update script: %v", err)
return fmt.Errorf("failed to update script: %w", err)
}
if err := ic.DAO.DeleteContractState(oldHash); err != nil {
return fmt.Errorf("failed to update script: %v", err)
return fmt.Errorf("failed to update script: %w", err)
}
}
// if manifest was provided, update the old contract manifest and check associated
@ -161,7 +161,7 @@ func contractUpdate(ic *interop.Context, v *vm.VM) error {
var newManifest manifest.Manifest
err := newManifest.UnmarshalJSON(manifestBytes)
if err != nil {
return fmt.Errorf("unable to retrieve manifest from stack: %v", err)
return fmt.Errorf("unable to retrieve manifest from stack: %w", err)
}
// we don't have to perform `GetContractState` one more time as it's already up-to-date
contract.Manifest = newManifest
@ -171,14 +171,14 @@ func contractUpdate(ic *interop.Context, v *vm.VM) error {
if !contract.HasStorage() {
siMap, err := ic.DAO.GetStorageItems(contract.ID)
if err != nil {
return fmt.Errorf("failed to update manifest: %v", err)
return fmt.Errorf("failed to update manifest: %w", err)
}
if len(siMap) != 0 {
return errors.New("old contract shouldn't have storage")
}
}
if err := ic.DAO.PutContractState(contract); err != nil {
return fmt.Errorf("failed to update manifest: %v", err)
return fmt.Errorf("failed to update manifest: %w", err)
}
}

2
pkg/core/native/interop.go
View file

@ -27,7 +27,7 @@ func Deploy(ic *interop.Context, _ *vm.VM) error {
return err
}
if err := native.Initialize(ic); err != nil {
return fmt.Errorf("initializing %s native contract: %v", md.Name, err)
return fmt.Errorf("initializing %s native contract: %w", md.Name, err)
}
}
return nil

2
pkg/core/native/native_gas.go
View file

@ -92,7 +92,7 @@ func (g *GAS) OnPersist(ic *interop.Context) error {
}
validators, err := g.NEO.getNextBlockValidatorsInternal(ic.Chain, ic.DAO)
if err != nil {
return fmt.Errorf("cannot get block validators: %v", err)
return fmt.Errorf("can't get block validators: %w", err)
}
primary := validators[ic.Block.ConsensusData.PrimaryIndex].GetScriptHash()
var netFee int64

2
pkg/core/native/native_neo.go
View file

@ -2,6 +2,7 @@ package native
import (
"crypto/elliptic"
"errors"
"math/big"
"sort"
"strings"
@ -18,7 +19,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
)
// NEO represents NEO native contract.

35
pkg/core/native/policy.go
View file

@ -2,6 +2,8 @@ package native
import (
"encoding/binary"
"errors"
"fmt"
"math/big"
"sort"
"sync"
@ -15,7 +17,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
)
const (
@ -508,23 +509,27 @@ func (p *Policy) checkValidators(ic *interop.Context) (bool, error) {
return runtime.CheckHashedWitness(ic, prevBlock.NextConsensus)
}
// CheckPolicy checks whether transaction's script hashes for verifying are
// included into blocked accounts list.
func (p *Policy) CheckPolicy(ic *interop.Context, tx *transaction.Transaction) (bool, error) {
ba, err := p.GetBlockedAccountsInternal(ic.DAO)
// CheckPolicy checks whether transaction conforms to current policy restrictions
// like not being signed by blocked account or not exceeding block-level system
// fee limit.
func (p *Policy) CheckPolicy(d dao.DAO, tx *transaction.Transaction) error {
ba, err := p.GetBlockedAccountsInternal(d)
if err != nil {
return false, err
return fmt.Errorf("unable to get blocked accounts list: %w", err)
}
scriptHashes, err := ic.Chain.GetScriptHashesForVerifying(tx)
if err != nil {
return false, err
}
for _, acc := range ba {
for _, hash := range scriptHashes {
if acc.Equals(hash) {
return false, nil
if len(ba) > 0 {
for _, signer := range tx.Signers {
i := sort.Search(len(ba), func(i int) bool {
return !ba[i].Less(signer.Account)
})
if i != len(ba) && ba[i].Equals(signer.Account) {
return fmt.Errorf("account %s is blocked", signer.Account.StringLE())
}
}
}
return true, nil
maxBlockSystemFee := p.GetMaxBlockSystemFeeInternal(d)
if maxBlockSystemFee < tx.SystemFee {
return fmt.Errorf("transaction's fee can't exceed maximum block system fee %d", maxBlockSystemFee)
}
return nil
}

2
pkg/core/storage/boltdb_store.go
View file

@ -39,7 +39,7 @@ func NewBoltDBStore(cfg BoltDBOptions) (*BoltDBStore, error) {
err = db.Update(func(tx *bbolt.Tx) error {
_, err = tx.CreateBucketIfNotExists(Bucket)
if err != nil {
return fmt.Errorf("could not create root bucket: %v", err)
return fmt.Errorf("could not create root bucket: %w", err)
}
return nil
})

4
pkg/crypto/keys/publickey.go
View file

@ -6,6 +6,7 @@ import (
"crypto/x509"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"math/big"
@ -16,7 +17,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/emit"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/pkg/errors"
)
// coordLen is the number of bytes in serialized X or Y coordinate.
@ -267,7 +267,7 @@ func (p *PublicKey) DecodeBinary(r *io.BinReader) {
return
}
default:
r.Err = errors.Errorf("invalid prefix %d", prefix)
r.Err = fmt.Errorf("invalid prefix %d", prefix)
return
}
if x.Cmp(curveParams.P) >= 0 || y.Cmp(curveParams.P) >= 0 {

2
pkg/encoding/base58/base58.go
View file

@ -2,10 +2,10 @@ package base58
import (
"bytes"
"errors"
"github.com/mr-tron/base58"
"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
"github.com/pkg/errors"
)
// CheckDecode implements a base58-encoded string decoding with hash-based

2
pkg/io/fileWriter.go
View file

@ -12,7 +12,7 @@ func MakeDirForFile(filePath string, creator string) error {
dir := path.Dir(fileName)
err := os.MkdirAll(dir, os.ModePerm)
if err != nil {
return fmt.Errorf("could not create dir for %s: %v", creator, err)
return fmt.Errorf("could not create dir for %s: %w", creator, err)
}
return nil
}

3
pkg/network/helper_test.go
View file

@ -112,9 +112,6 @@ func (chain testChain) GetStandByValidators() keys.PublicKeys {
func (chain testChain) GetEnrollments() ([]state.Validator, error) {
panic("TODO")
}
func (chain testChain) GetScriptHashesForVerifying(*transaction.Transaction) ([]util.Uint160, error) {
panic("TODO")
}
func (chain testChain) GetStateRoot(height uint32) (*state.MPTRootState, error) {
panic("TODO")
}

5
pkg/network/payload/headers.go
View file

@ -1,10 +1,11 @@
package payload
import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/config/netmode"
"github.com/nspcc-dev/neo-go/pkg/core/block"
"github.com/nspcc-dev/neo-go/pkg/io"
"github.com/pkg/errors"
)
// Headers payload.
@ -19,7 +20,7 @@ const (
)
// ErrTooManyHeaders is an error returned when too many headers were received.
var ErrTooManyHeaders = errors.Errorf("too many headers were received (max: %d)", MaxHeadersAllowed)
var ErrTooManyHeaders = fmt.Errorf("too many headers were received (max: %d)", MaxHeadersAllowed)
// DecodeBinary implements Serializable interface.
func (p *Headers) DecodeBinary(br *io.BinReader) {

8
pkg/network/server.go
View file

@ -843,12 +843,12 @@ func (s *Server) relayBlocksLoop() {
// verifyAndPoolTX verifies the TX and adds it to the local mempool.
func (s *Server) verifyAndPoolTX(t *transaction.Transaction) RelayReason {
if err := s.chain.PoolTx(t); err != nil {
switch err {
case core.ErrAlreadyExists:
switch {
case errors.Is(err, core.ErrAlreadyExists):
return RelayAlreadyExists
case core.ErrOOM:
case errors.Is(err, core.ErrOOM):
return RelayOutOfMemory
case core.ErrPolicy:
case errors.Is(err, core.ErrPolicy):
return RelayPolicyFail
default:
return RelayInvalid

2
pkg/network/tcp_peer.go
View file

@ -161,7 +161,7 @@ func (p *TCPPeer) handleConn() {
}
if err = p.server.handleMessage(p, msg); err != nil {
if p.Handshaked() {
err = fmt.Errorf("handling %s message: %v", msg.Command.String(), err)
err = fmt.Errorf("handling %s message: %w", msg.Command.String(), err)
}
break
}

6
pkg/rpc/client/client.go
View file

@ -4,6 +4,7 @@ import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"net"
"net/http"
@ -15,7 +16,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/rpc/request"
"github.com/nspcc-dev/neo-go/pkg/rpc/response"
"github.com/pkg/errors"
)
const (
@ -123,7 +123,7 @@ func (c *Client) SetWIF(wif string) error {
defer c.wifMu.Unlock()
decodedWif, err := keys.WIFDecode(wif, 0x00)
if err != nil {
return errors.Wrap(err, "Failed to decode WIF; failed to add WIF to client ")
return fmt.Errorf("failed to decode WIF: %w", err)
}
c.wif = decodedWif
return nil
@ -176,7 +176,7 @@ func (c *Client) makeHTTPRequest(r *request.Raw) (*response.Raw, error) {
if resp.StatusCode != http.StatusOK {
err = fmt.Errorf("HTTP %d/%s", resp.StatusCode, http.StatusText(resp.StatusCode))
} else {
err = errors.Wrap(err, "JSON decoding")
err = fmt.Errorf("JSON decoding: %w", err)
}
}
if err != nil {

12
pkg/rpc/client/nep5.go
View file

@ -123,7 +123,7 @@ func (c *Client) CreateNEP5TransferTx(acc *wallet.Account, to util.Uint160, toke
func (c *Client) CreateNEP5MultiTransferTx(acc *wallet.Account, gas int64, recepients ...TransferTarget) (*transaction.Transaction, error) {
from, err := address.StringToUint160(acc.Address)
if err != nil {
return nil, fmt.Errorf("bad account address: %v", err)
return nil, fmt.Errorf("bad account address: %w", err)
}
w := io.NewBufBinWriter()
for i := range recepients {
@ -147,7 +147,7 @@ func (c *Client) CreateTxFromScript(script []byte, acc *wallet.Account, gas int6
},
})
if err != nil {
return nil, fmt.Errorf("can't add system fee to transaction: %v", err)
return nil, fmt.Errorf("can't add system fee to transaction: %w", err)
}
tx := transaction.New(c.opts.Network, script, result.GasConsumed)
tx.Signers = []transaction.Signer{
@ -158,12 +158,12 @@ func (c *Client) CreateTxFromScript(script []byte, acc *wallet.Account, gas int6
}
tx.ValidUntilBlock, err = c.CalculateValidUntilBlock()
if err != nil {
return nil, fmt.Errorf("can't calculate validUntilBlock: %v", err)
return nil, fmt.Errorf("can't calculate validUntilBlock: %w", err)
}
err = c.AddNetworkFee(tx, gas, acc)
if err != nil {
return nil, fmt.Errorf("can't add network fee to transaction: %v", err)
return nil, fmt.Errorf("can't add network fee to transaction: %w", err)
}
return tx, nil
@ -180,7 +180,7 @@ func (c *Client) TransferNEP5(acc *wallet.Account, to util.Uint160, token util.U
}
if err := acc.SignTx(tx); err != nil {
return util.Uint256{}, fmt.Errorf("can't sign tx: %v", err)
return util.Uint256{}, fmt.Errorf("can't sign tx: %w", err)
}
return c.SendRawTransaction(tx)
@ -194,7 +194,7 @@ func (c *Client) MultiTransferNEP5(acc *wallet.Account, gas int64, recepients ..
}
if err := acc.SignTx(tx); err != nil {
return util.Uint256{}, fmt.Errorf("can't sign tx: %v", err)
return util.Uint256{}, fmt.Errorf("can't sign tx: %w", err)
}
return c.SendRawTransaction(tx)

2
pkg/rpc/client/policy.go
View file

@ -1,13 +1,13 @@
package client
import (
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/core/native"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
)
// PolicyContractHash represents a hash of native Policy contract.

16
pkg/rpc/client/rpc.go
View file

@ -2,6 +2,7 @@ package client
import (
"encoding/hex"
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/core"
@ -16,7 +17,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/wallet"
"github.com/pkg/errors"
)
// GetApplicationLog returns the contract log based on the specified txid.
@ -428,28 +428,28 @@ func (c *Client) SignAndPushInvocationTx(script []byte, acc *wallet.Account, sys
addr, err := address.StringToUint160(acc.Address)
if err != nil {
return txHash, errors.Wrap(err, "failed to get address")
return txHash, fmt.Errorf("failed to get address: %w", err)
}
tx.Signers = getSigners(addr, cosigners)
validUntilBlock, err := c.CalculateValidUntilBlock()
if err != nil {
return txHash, errors.Wrap(err, "failed to add validUntilBlock to transaction")
return txHash, fmt.Errorf("failed to add validUntilBlock to transaction: %w", err)
}
tx.ValidUntilBlock = validUntilBlock
err = c.AddNetworkFee(tx, int64(netfee), acc)
if err != nil {
return txHash, errors.Wrapf(err, "failed to add network fee")
return txHash, fmt.Errorf("failed to add network fee: %w", err)
}
if err = acc.SignTx(tx); err != nil {
return txHash, errors.Wrap(err, "failed to sign tx")
return txHash, fmt.Errorf("failed to sign tx: %w", err)
}
txHash = tx.Hash()
actualHash, err := c.SendRawTransaction(tx)
if err != nil {
return txHash, errors.Wrap(err, "failed sendning tx")
return txHash, fmt.Errorf("failed to send tx: %w", err)
}
if !actualHash.Equals(txHash) {
return actualHash, fmt.Errorf("sent and actual tx hashes mismatch:\n\tsent: %v\n\tactual: %v", txHash.StringLE(), actualHash.StringLE())
@ -505,7 +505,7 @@ func (c *Client) CalculateValidUntilBlock() (uint32, error) {
)
blockCount, err := c.GetBlockCount()
if err != nil {
return result, errors.Wrapf(err, "cannot get block count")
return result, fmt.Errorf("can't get block count: %w", err)
}
if c.cache.calculateValidUntilBlock.expiresAt > blockCount {
@ -513,7 +513,7 @@ func (c *Client) CalculateValidUntilBlock() (uint32, error) {
} else {
validators, err := c.GetValidators()
if err != nil {
return result, errors.Wrapf(err, "cannot get validators")
return result, fmt.Errorf("can't get validators: %w", err)
}
validatorsCount = uint32(len(validators))
c.cache.calculateValidUntilBlock = calculateValidUntilBlockCache{

7
pkg/rpc/client/rpc_test.go
View file

@ -28,7 +28,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@ -577,7 +576,7 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{
result: func(c *Client) interface{} {
addr, err := address.StringToUint160("NMipL5VsNoLUBUJKPKLhxaEbPQVCZnyJyB")
if err != nil {
panic(errors.Wrap(err, "failed to parse UnclaimedGas address"))
panic(fmt.Errorf("failed to parse UnclaimedGas address: %w", err))
}
return result.UnclaimedGas{
Address: addr,
@ -691,7 +690,7 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{
result: func(c *Client) interface{} {
h, err := util.Uint256DecodeStringLE("72159b0cf1221110daad6e1df6ef4ff03012173b63c86910bd7134deb659c875")
if err != nil {
panic(fmt.Errorf("can't decode `sendrawtransaction` result hash: %v", err))
panic(fmt.Errorf("can't decode `sendrawtransaction` result hash: %w", err))
}
return h
},
@ -711,7 +710,7 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{
result: func(c *Client) interface{} {
h, err := util.Uint256DecodeStringLE("1bdea8f80eb5bd97fade38d5e7fb93b02c9d3e01394e9f4324218132293f7ea6")
if err != nil {
panic(fmt.Errorf("can't decode `submitblock` result hash: %v", err))
panic(fmt.Errorf("can't decode `submitblock` result hash: %w", err))
}
return h
},

2
pkg/rpc/request/param.go
View file

@ -5,6 +5,7 @@ import (
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"strconv"
@ -12,7 +13,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/encoding/address"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/pkg/errors"
)
type (

9
pkg/rpc/request/types.go
View file

@ -2,9 +2,8 @@ package request
import (
"encoding/json"
"fmt"
"io"
"github.com/pkg/errors"
)
const (
@ -60,11 +59,11 @@ func (r *In) DecodeData(data io.ReadCloser) error {
err := json.NewDecoder(data).Decode(r)
if err != nil {
return errors.Errorf("error parsing JSON payload: %s", err)
return fmt.Errorf("error parsing JSON payload: %w", err)
}
if r.JSONRPC != JSONRPCVersion {
return errors.Errorf("invalid version, expected 2.0 got: '%s'", r.JSONRPC)
return fmt.Errorf("invalid version, expected 2.0 got: '%s'", r.JSONRPC)
}
return nil
@ -77,7 +76,7 @@ func (r *In) Params() (*Params, error) {
err := json.Unmarshal(r.RawParams, &params)
if err != nil {
return nil, errors.Errorf("error parsing params field in payload: %s", err)
return nil, fmt.Errorf("error parsing params: %w", err)
}
return &params, nil

3
pkg/rpc/response/events.go
View file

@ -2,8 +2,7 @@ package response
import (
"encoding/json"
"github.com/pkg/errors"
"errors"
)
type (

10
pkg/rpc/server/server.go
View file

@ -4,6 +4,7 @@ import (
"context"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"math"
"math/big"
@ -30,7 +31,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/rpc/response/result"
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -614,7 +614,7 @@ func (s *Server) getDecimals(contractID int32, cache map[int32]decimals) (decima
},
})
if err != nil {
return decimals{}, fmt.Errorf("can't create script: %v", err)
return decimals{}, fmt.Errorf("can't create script: %w", err)
}
res := s.runScriptInVM(script, nil)
if res == nil || res.State != "HALT" || len(res.Stack) == 0 {
@ -692,7 +692,7 @@ func (s *Server) getrawtransaction(reqParams request.Params) (interface{}, *resp
if txHash, err := reqParams.Value(0).GetUint256(); err != nil {
resultsErr = response.ErrInvalidParams
} else if tx, height, err := s.chain.GetTransaction(txHash); err != nil {
err = errors.Wrapf(err, "Invalid transaction hash: %s", txHash)
err = fmt.Errorf("invalid transaction %s: %w", txHash, err)
return nil, response.NewRPCError("Unknown transaction", err.Error(), err)
} else if reqParams.Value(1).GetBoolean() {
_header := s.chain.GetHeaderHash(int(height))
@ -917,8 +917,8 @@ func (s *Server) submitBlock(reqParams request.Params) (interface{}, *response.E
}
err = s.chain.AddBlock(b)
if err != nil {
switch err {
case core.ErrInvalidBlockIndex, core.ErrAlreadyExists:
switch {
case errors.Is(err, core.ErrInvalidBlockIndex) || errors.Is(err, core.ErrAlreadyExists):
return nil, response.ErrAlreadyExists
default:
return nil, response.ErrValidationFailed

8
pkg/smartcontract/nef/nef.go
View file

@ -95,13 +95,13 @@ func GetVersion(version string) (Version, error) {
}
major, err := strconv.ParseInt(versions[0], 10, 32)
if err != nil {
return result, fmt.Errorf("failed to parse major version: %v", err)
return result, fmt.Errorf("failed to parse major version: %w", err)
}
result.Major = int32(major)
minor, err := strconv.ParseInt(versions[1], 10, 32)
if err != nil {
return result, fmt.Errorf("failed to parse minor version: %v", err)
return result, fmt.Errorf("failed to parse minor version: %w", err)
}
result.Minor = int32(minor)
@ -112,7 +112,7 @@ func GetVersion(version string) (Version, error) {
}
build, err := strconv.ParseInt(b, 10, 32)
if err != nil {
return result, fmt.Errorf("failed to parse build version: %v", err)
return result, fmt.Errorf("failed to parse build version: %w", err)
}
result.Build = int32(build)
@ -120,7 +120,7 @@ func GetVersion(version string) (Version, error) {
r := strings.SplitN(versions[3], "-", 2)[0]
revision, err := strconv.ParseInt(r, 10, 32)
if err != nil {
return result, fmt.Errorf("failed to parse revision version: %v", err)
return result, fmt.Errorf("failed to parse revision version: %w", err)
}
result.Revision = int32(revision)
}

5
pkg/smartcontract/param_type.go
View file

@ -3,6 +3,8 @@ package smartcontract
import (
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"strconv"
"strings"
@ -10,7 +12,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/encoding/address"
"github.com/nspcc-dev/neo-go/pkg/io"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/pkg/errors"
)
// ParamType represents the Type of the smart contract parameter.
@ -160,7 +161,7 @@ func ParseParamType(typ string) (ParamType, error) {
case "any":
return AnyType, nil
default:
return UnknownType, errors.Errorf("Unknown contract parameter type: %s", typ)
return UnknownType, fmt.Errorf("bad parameter type: %s", typ)
}
}

14
pkg/smartcontract/parameter.go
View file

@ -5,6 +5,7 @@ import (
"encoding/binary"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"math"
"math/bits"
@ -14,7 +15,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/io"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/pkg/errors"
)
// PropertyState represents contract properties (flags).
@ -94,7 +94,7 @@ func (p Parameter) MarshalJSON() ([]byte, error) {
case InteropInterfaceType, AnyType:
resultRawValue = nil
default:
resultErr = errors.Errorf("Marshaller for type %s not implemented", p.Type)
resultErr = fmt.Errorf("can't marshal %s", p.Type)
}
if resultErr != nil {
return nil, resultErr
@ -183,7 +183,7 @@ func (p *Parameter) UnmarshalJSON(data []byte) (err error) {
// stub, ignore value, it can only be null
p.Value = nil
default:
return errors.Errorf("Unmarshaller for type %s not implemented", p.Type)
return fmt.Errorf("can't unmarshal %s", p.Type)
}
return
}
@ -300,7 +300,7 @@ func (p Parameter) TryParse(dest interface{}) error {
switch p.Type {
case ByteArrayType:
if data, ok = p.Value.([]byte); !ok {
return errors.Errorf("failed to cast %s to []byte", p.Value)
return fmt.Errorf("failed to cast %s to []byte", p.Value)
}
switch dest := dest.(type) {
case *util.Uint160:
@ -362,7 +362,7 @@ func (p Parameter) TryParse(dest interface{}) error {
*dest = string(data)
return nil
default:
return errors.Errorf("cannot cast param of type %s to type %s", p.Type, dest)
return fmt.Errorf("cannot cast param of type %s to type %s", p.Type, dest)
}
default:
return errors.New("cannot define param type")
@ -373,7 +373,7 @@ func (p Parameter) TryParse(dest interface{}) error {
func bytesToUint64(b []byte, size int) (uint64, error) {
var length = size / 8
if len(b) > length {
return 0, errors.Errorf("input doesn't fit into %d bits", size)
return 0, fmt.Errorf("input doesn't fit into %d bits", size)
}
if len(b) < length {
data := make([]byte, length)
@ -412,7 +412,7 @@ func NewParameterFromString(in string) (*Parameter, error) {
}
// We currently do not support following types:
if res.Type == ArrayType || res.Type == MapType || res.Type == InteropInterfaceType || res.Type == VoidType {
return nil, errors.Errorf("Unsupported contract parameter type: %s", res.Type)
return nil, fmt.Errorf("unsupported parameter type %s", res.Type)
}
buf.Reset()
hadType = true

4
pkg/vm/cli/cli.go
View file

@ -241,7 +241,7 @@ func handleBreak(c *ishell.Context) {
}
n, err := strconv.Atoi(c.Args[0])
if err != nil {
c.Err(fmt.Errorf("argument conversion error: %s", err))
c.Err(fmt.Errorf("argument conversion error: %w", err))
return
}
@ -388,7 +388,7 @@ func handleStep(c *ishell.Context) {
if len(c.Args) > 0 {
n, err = strconv.Atoi(c.Args[0])
if err != nil {
c.Err(fmt.Errorf("argument conversion error: %s", err))
c.Err(fmt.Errorf("argument conversion error: %w", err))
return
}
}

2
pkg/vm/interop.go
View file

@ -128,7 +128,7 @@ func EnumeratorCreate(v *VM) error {
default:
data, err := t.TryBytes()
if err != nil {
return fmt.Errorf("can not create enumerator from type %s: %v", t.Type(), err)
return fmt.Errorf("can not create enumerator from type %s: %w", t.Type(), err)
}
interop = &byteArrayWrapper{
index: -1,

4
pkg/vm/json_test.go
View file

@ -5,6 +5,7 @@ import (
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"math/big"
@ -19,7 +20,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/smartcontract"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
)
@ -437,7 +437,7 @@ func (v *vmUTStackItem) UnmarshalJSON(data []byte) error {
var it vmUTStackItem
if err := d.Decode(&it); err != nil {
return fmt.Errorf("can't decode map value: %v", err)
return fmt.Errorf("can't decode map value: %w", err)
}
item := jsonStringToInteger(key)

3
pkg/vm/state.go
View file

@ -1,9 +1,8 @@
package vm
import (
"errors"
"strings"
"github.com/pkg/errors"
)
// State of the VM.

2
pkg/vm/vm.go
View file

@ -4,6 +4,7 @@ import (
"crypto/elliptic"
"encoding/binary"
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"math"
@ -20,7 +21,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
)
type errorAtInstruct struct {

2
pkg/vm/vm_test.go
View file

@ -5,6 +5,7 @@ import (
"crypto/elliptic"
"encoding/binary"
"encoding/hex"
"errors"
"fmt"
"math/big"
"math/rand"
@ -17,7 +18,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/vm/emit"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

6
scripts/compare-dumps.go
View file

@ -55,11 +55,11 @@ func (d dump) normalize() {
func compare(a, b string) error {
dumpA, err := readFile(a)
if err != nil {
return fmt.Errorf("reading file %s: %v", a, err)
return fmt.Errorf("reading file %s: %w", a, err)
}
dumpB, err := readFile(b)
if err != nil {
return fmt.Errorf("reading file %s: %v", b, err)
return fmt.Errorf("reading file %s: %w", b, err)
}
dumpA.normalize()
dumpB.normalize()
@ -143,7 +143,7 @@ func cliMain(c *cli.Context) error {
bname := filepath.Join(b, fname)
err := compare(aname, bname)
if err != nil {
return fmt.Errorf("file %s: %v", fname, err)
return fmt.Errorf("file %s: %w", fname, err)
}
}
}