neo-go/cli/wallet_test.go

package main

import (
	"encoding/hex"
	"encoding/json"
	"math/big"
	"path/filepath"
	"strings"
	"testing"

	"github.com/chzyer/readline"
	"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
	"github.com/nspcc-dev/neo-go/pkg/encoding/address"
	"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/stretchr/testify/require"
)

func TestWalletAccountRemove(t *testing.T) {
	tmpDir := t.TempDir()
	e := newExecutor(t, false)

	walletPath := filepath.Join(tmpDir, "wallet.json")
	e.In.WriteString("acc1\r")
	e.In.WriteString("pass\r")
	e.In.WriteString("pass\r")
	e.Run(t, "neo-go", "wallet", "init", "--wallet", walletPath, "--account")

	e.In.WriteString("acc2\r")
	e.In.WriteString("pass\r")
	e.In.WriteString("pass\r")
	e.Run(t, "neo-go", "wallet", "create", "--wallet", walletPath)

	w, err := wallet.NewWalletFromFile(walletPath)
	require.NoError(t, err)

	t.Run("missing wallet", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "remove")
	})
	t.Run("missing address", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "remove", "--wallet", walletPath)
	})
	t.Run("invalid address", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "remove", "--wallet", walletPath,
			"--address", util.Uint160{}.StringLE())
	})

	addr := w.Accounts[0].Address
	t.Run("askForConsent > no", func(t *testing.T) {
		e.In.WriteString("no")
		e.Run(t, "neo-go", "wallet", "remove", "--wallet", walletPath,
			"--address", addr)
		actual, err := wallet.NewWalletFromFile(walletPath)
		require.NoError(t, err)
		require.Equal(t, w, actual)
	})

	e.Run(t, "neo-go", "wallet", "remove", "--wallet", walletPath,
		"--address", addr, "--force")

	actual, err := wallet.NewWalletFromFile(walletPath)
	require.NoError(t, err)
	require.Equal(t, 1, len(actual.Accounts))
	require.Equal(t, w.Accounts[1], actual.Accounts[0])
}

func TestWalletChangePassword(t *testing.T) {
	tmpDir := t.TempDir()
	e := newExecutor(t, false)

	walletPath := filepath.Join(tmpDir, "wallet.json")
	e.In.WriteString("acc1\r")
	e.In.WriteString("pass\r")
	e.In.WriteString("pass\r")
	e.Run(t, "neo-go", "wallet", "init", "--wallet", walletPath, "--account")

	e.In.WriteString("acc2\r")
	e.In.WriteString("pass\r")
	e.In.WriteString("pass\r")
	e.Run(t, "neo-go", "wallet", "create", "--wallet", walletPath)

	w, err := wallet.NewWalletFromFile(walletPath)
	require.NoError(t, err)

	addr1 := w.Accounts[0].Address
	addr2 := w.Accounts[1].Address
	t.Run("missing wallet path", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "change-password")
	})
	t.Run("EOF reading old password", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "change-password", "--wallet", walletPath)
	})
	t.Run("bad old password", func(t *testing.T) {
		e.In.WriteString("ssap\r")
		e.In.WriteString("aaa\r") // Pretend for the password to be fine.
		e.In.WriteString("aaa\r")

		e.RunWithError(t, "neo-go", "wallet", "change-password", "--wallet", walletPath)
	})
	t.Run("no account", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "change-password", "--wallet", walletPath, "--address", "NVTiAjNgagDkTr5HTzDmQP9kPwPHN5BgVq")
	})
	t.Run("bad new password, multiaccount", func(t *testing.T) {
		e.In.WriteString("pass\r")
		e.In.WriteString("pass1\r")
		e.In.WriteString("pass2\r")
		e.RunWithError(t, "neo-go", "wallet", "change-password", "--wallet", walletPath)
	})
	t.Run("good, multiaccount", func(t *testing.T) {
		e.In.WriteString("pass\r")
		e.In.WriteString("asdf\r")
		e.In.WriteString("asdf\r")
		e.Run(t, "neo-go", "wallet", "change-password", "--wallet", walletPath)
	})
	t.Run("good, single account", func(t *testing.T) {
		e.In.WriteString("asdf\r")
		e.In.WriteString("jkl\r")
		e.In.WriteString("jkl\r")
		e.Run(t, "neo-go", "wallet", "change-password", "--wallet", walletPath, "--address", addr1)
	})
	t.Run("bad, different passwords", func(t *testing.T) {
		e.In.WriteString("jkl\r")
		e.RunWithError(t, "neo-go", "wallet", "change-password", "--wallet", walletPath)
	})
	t.Run("good, second account", func(t *testing.T) {
		e.In.WriteString("asdf\r")
		e.In.WriteString("jkl\r")
		e.In.WriteString("jkl\r")
		e.Run(t, "neo-go", "wallet", "change-password", "--wallet", walletPath, "--address", addr2)
	})
	t.Run("good, second multiaccount", func(t *testing.T) {
		e.In.WriteString("jkl\r")
		e.In.WriteString("pass\r")
		e.In.WriteString("pass\r")
		e.Run(t, "neo-go", "wallet", "change-password", "--wallet", walletPath)
	})
}

func TestWalletInit(t *testing.T) {
	e := newExecutor(t, false)

	t.Run("missing path", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "init")
	})
	t.Run("invalid path", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "init", "--wallet", t.TempDir())
	})
	t.Run("good: no account", func(t *testing.T) {
		walletPath := filepath.Join(t.TempDir(), "wallet.json")
		e.Run(t, "neo-go", "wallet", "init", "--wallet", walletPath)
		w, err := wallet.NewWalletFromFile(walletPath)
		require.NoError(t, err)
		require.Equal(t, 0, len(w.Accounts))
	})
	t.Run("with account", func(t *testing.T) {
		walletPath := filepath.Join(t.TempDir(), "wallet.json")
		t.Run("missing acc name", func(t *testing.T) {
			e.RunWithError(t, "neo-go", "wallet", "init", "--wallet", walletPath, "--account")
		})
		t.Run("missing pass", func(t *testing.T) {
			e.In.WriteString("acc\r")
			e.RunWithError(t, "neo-go", "wallet", "init", "--wallet", walletPath, "--account")
		})
		t.Run("missing second pass", func(t *testing.T) {
			e.In.WriteString("acc\r")
			e.In.WriteString("pass\r")
			e.RunWithError(t, "neo-go", "wallet", "init", "--wallet", walletPath, "--account")
		})
		e.In.WriteString("acc\r")
		e.In.WriteString("pass\r")
		e.In.WriteString("pass\r")
		e.Run(t, "neo-go", "wallet", "init", "--wallet", walletPath, "--account")
		w, err := wallet.NewWalletFromFile(walletPath)
		require.NoError(t, err)
		require.Equal(t, 1, len(w.Accounts))
		require.Equal(t, "acc", w.Accounts[0].Label)
	})

	tmpDir := t.TempDir()
	walletPath := filepath.Join(tmpDir, "wallet.json")
	e.Run(t, "neo-go", "wallet", "init", "--wallet", walletPath)

	t.Run("terminal escape codes", func(t *testing.T) {
		walletPath := filepath.Join(tmpDir, "walletrussian.json")
		bksp := string([]byte{
			byte(readline.CharBackward),
			byte(readline.CharDelete),
		})
		e.In.WriteString("буквыы" +
			bksp + bksp + bksp +
			"andmore\r")
		e.In.WriteString("пароу" + bksp + "ль\r")
		e.In.WriteString("пароль\r")
		e.Run(t, "neo-go", "wallet", "init", "--account",
			"--wallet", walletPath)

		w, err := wallet.NewWalletFromFile(walletPath)
		require.NoError(t, err)
		require.Len(t, w.Accounts, 1)
		require.Equal(t, "букandmore", w.Accounts[0].Label)
		require.NoError(t, w.Accounts[0].Decrypt("пароль", w.Scrypt))
		w.Close()
	})

	t.Run("CreateAccount", func(t *testing.T) {
		t.Run("stdin", func(t *testing.T) {
			e.RunWithError(t, "neo-go", "wallet", "create", "--wallet", "-")
		})
		t.Run("passwords mismatch", func(t *testing.T) {
			e.In.WriteString("testname\r")
			e.In.WriteString("testpass\r")
			e.In.WriteString("badpass\r")
			e.RunWithError(t, "neo-go", "wallet", "create", "--wallet", walletPath)
		})
		e.In.WriteString("testname\r")
		e.In.WriteString("testpass\r")
		e.In.WriteString("testpass\r")
		e.Run(t, "neo-go", "wallet", "create", "--wallet", walletPath)

		w, err := wallet.NewWalletFromFile(walletPath)
		require.NoError(t, err)
		require.Len(t, w.Accounts, 1)
		require.Equal(t, w.Accounts[0].Label, "testname")
		require.NoError(t, w.Accounts[0].Decrypt("testpass", w.Scrypt))
		w.Close()

		t.Run("RemoveAccount", func(t *testing.T) {
			sh := w.Accounts[0].Contract.ScriptHash()
			addr := w.Accounts[0].Address
			e.In.WriteString("y\r")
			e.Run(t, "neo-go", "wallet", "remove",
				"--wallet", walletPath, "--address", addr)
			w, err := wallet.NewWalletFromFile(walletPath)
			require.NoError(t, err)
			require.Nil(t, w.GetAccount(sh))
			w.Close()
		})
	})

	t.Run("Import", func(t *testing.T) {
		t.Run("WIF", func(t *testing.T) {
			t.Run("missing wallet", func(t *testing.T) {
				e.RunWithError(t, "neo-go", "wallet", "import")
			})
			priv, err := keys.NewPrivateKey()
			require.NoError(t, err)
			e.In.WriteString("test_account\r")
			e.In.WriteString("qwerty\r")
			e.In.WriteString("qwerty\r")
			e.Run(t, "neo-go", "wallet", "import", "--wallet", walletPath,
				"--wif", priv.WIF())

			w, err := wallet.NewWalletFromFile(walletPath)
			require.NoError(t, err)
			t.Cleanup(w.Close)
			acc := w.GetAccount(priv.GetScriptHash())
			require.NotNil(t, acc)
			require.Equal(t, "test_account", acc.Label)
			require.NoError(t, acc.Decrypt("qwerty", w.Scrypt))

			t.Run("AlreadyExists", func(t *testing.T) {
				e.In.WriteString("test_account_2\r")
				e.In.WriteString("qwerty2\r")
				e.In.WriteString("qwerty2\r")
				e.RunWithError(t, "neo-go", "wallet", "import",
					"--wallet", walletPath, "--wif", priv.WIF())
			})

			t.Run("contract", func(t *testing.T) {
				priv, err = keys.NewPrivateKey()
				require.NoError(t, err)

				t.Run("invalid script", func(t *testing.T) {
					e.In.WriteString("test_account_3\r")
					e.In.WriteString("qwerty\r")
					e.In.WriteString("qwerty\r")
					e.RunWithError(t, "neo-go", "wallet", "import",
						"--wallet", walletPath, "--wif", priv.WIF(), "--contract", "not-a-hex")
				})

				e.In.WriteString("test_account_3\r")
				e.In.WriteString("qwerty\r")
				e.In.WriteString("qwerty\r")
				e.Run(t, "neo-go", "wallet", "import",
					"--wallet", walletPath, "--wif", priv.WIF(), "--contract", "0a0b0c")

				w, err := wallet.NewWalletFromFile(walletPath)
				require.NoError(t, err)
				t.Cleanup(w.Close)
				acc := w.GetAccount(priv.GetScriptHash())
				require.NotNil(t, acc)
				require.Equal(t, "test_account_3", acc.Label)
				require.NoError(t, acc.Decrypt("qwerty", w.Scrypt))
			})
		})
		t.Run("EncryptedWIF", func(t *testing.T) {
			acc, err := wallet.NewAccount()
			require.NoError(t, err)
			require.NoError(t, acc.Encrypt("somepass", keys.NEP2ScryptParams()))

			t.Run("InvalidPassword", func(t *testing.T) {
				e.In.WriteString("password1\r")
				e.RunWithError(t, "neo-go", "wallet", "import", "--wallet", walletPath,
					"--wif", acc.EncryptedWIF)
			})

			e.In.WriteString("somepass\r")
			e.Run(t, "neo-go", "wallet", "import", "--wallet", walletPath,
				"--wif", acc.EncryptedWIF)

			w, err := wallet.NewWalletFromFile(walletPath)
			require.NoError(t, err)
			t.Cleanup(w.Close)
			actual := w.GetAccount(acc.PrivateKey().GetScriptHash())
			require.NotNil(t, actual)
			require.NoError(t, actual.Decrypt("somepass", w.Scrypt))
		})
		t.Run("Multisig", func(t *testing.T) {
			t.Run("missing wallet", func(t *testing.T) {
				e.RunWithError(t, "neo-go", "wallet", "import-multisig")
			})
			t.Run("insufficient pubs", func(t *testing.T) {
				e.RunWithError(t, "neo-go", "wallet", "import-multisig",
					"--wallet", walletPath,
					"--min", "2")
			})
			privs, pubs := generateKeys(t, 4)
			cmd := []string{"neo-go", "wallet", "import-multisig",
				"--wallet", walletPath,
				"--min", "2"}
			t.Run("invalid pub encoding", func(t *testing.T) {
				e.RunWithError(t, append(cmd, hex.EncodeToString(pubs[1].Bytes()),
					hex.EncodeToString(pubs[1].Bytes()),
					hex.EncodeToString(pubs[2].Bytes()),
					"not-a-pub")...)
			})
			t.Run("missing WIF", func(t *testing.T) {
				e.RunWithError(t, append(cmd, hex.EncodeToString(pubs[0].Bytes()),
					hex.EncodeToString(pubs[1].Bytes()),
					hex.EncodeToString(pubs[2].Bytes()),
					hex.EncodeToString(pubs[3].Bytes()))...)
			})
			cmd = append(cmd, "--wif", privs[0].WIF())
			t.Run("InvalidPublicKeys", func(t *testing.T) {
				e.In.WriteString("multiacc\r")
				e.In.WriteString("multipass\r")
				e.In.WriteString("multipass\r")
				defer e.In.Reset()

				e.RunWithError(t, append(cmd, hex.EncodeToString(pubs[1].Bytes()),
					hex.EncodeToString(pubs[1].Bytes()),
					hex.EncodeToString(pubs[2].Bytes()),
					hex.EncodeToString(pubs[3].Bytes()))...)
			})
			e.In.WriteString("multiacc\r")
			e.In.WriteString("multipass\r")
			e.In.WriteString("multipass\r")
			e.Run(t, append(cmd, hex.EncodeToString(pubs[0].Bytes()),
				hex.EncodeToString(pubs[1].Bytes()),
				hex.EncodeToString(pubs[2].Bytes()),
				hex.EncodeToString(pubs[3].Bytes()))...)

			script, err := smartcontract.CreateMultiSigRedeemScript(2, pubs)
			require.NoError(t, err)

			w, err := wallet.NewWalletFromFile(walletPath)
			require.NoError(t, err)
			t.Cleanup(w.Close)
			actual := w.GetAccount(hash.Hash160(script))
			require.NotNil(t, actual)
			require.NoError(t, actual.Decrypt("multipass", w.Scrypt))
			require.Equal(t, script, actual.Contract.Script)

			t.Run("double-import", func(t *testing.T) {
				e.In.WriteString("multiacc\r")
				e.In.WriteString("multipass\r")
				e.In.WriteString("multipass\r")
				e.RunWithError(t, append(cmd, hex.EncodeToString(pubs[0].Bytes()),
					hex.EncodeToString(pubs[1].Bytes()),
					hex.EncodeToString(pubs[2].Bytes()),
					hex.EncodeToString(pubs[3].Bytes()))...)
			})
		})
	})
}

func TestWalletExport(t *testing.T) {
	e := newExecutor(t, false)

	t.Run("missing wallet", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "export")
	})
	t.Run("invalid address", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "export",
			"--wallet", validatorWallet, "not-an-address")
	})
	t.Run("Encrypted", func(t *testing.T) {
		e.Run(t, "neo-go", "wallet", "export",
			"--wallet", validatorWallet, validatorAddr)
		line, err := e.Out.ReadString('\n')
		require.NoError(t, err)
		enc, err := keys.NEP2Encrypt(validatorPriv, "one", keys.ScryptParams{N: 2, R: 1, P: 1}) // these params used in validator wallet for better resources consumption
		require.NoError(t, err)
		require.Equal(t, enc, strings.TrimSpace(line))
	})
	t.Run("Decrypted", func(t *testing.T) {
		t.Run("NoAddress", func(t *testing.T) {
			e.RunWithError(t, "neo-go", "wallet", "export",
				"--wallet", validatorWallet, "--decrypt")
		})
		t.Run("EOF reading password", func(t *testing.T) {
			e.RunWithError(t, "neo-go", "wallet", "export",
				"--wallet", validatorWallet, "--decrypt", validatorAddr)
		})
		t.Run("invalid password", func(t *testing.T) {
			e.In.WriteString("invalid_pass\r")
			e.RunWithError(t, "neo-go", "wallet", "export",
				"--wallet", validatorWallet, "--decrypt", validatorAddr)
		})
		e.In.WriteString("one\r")
		e.Run(t, "neo-go", "wallet", "export",
			"--wallet", validatorWallet, "--decrypt", validatorAddr)
		line, err := e.Out.ReadString('\n')
		require.NoError(t, err)
		require.Equal(t, validatorWIF, strings.TrimSpace(line))
	})
}

func TestWalletClaimGas(t *testing.T) {
	e := newExecutor(t, true)

	t.Run("missing wallet path", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "claim",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--address", testWalletAccount)
	})
	t.Run("missing address", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "claim",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--wallet", testWalletPath)
	})
	t.Run("invalid address", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "claim",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--wallet", testWalletPath,
			"--address", util.Uint160{}.StringLE())
	})
	t.Run("missing endpoint", func(t *testing.T) {
		e.In.WriteString("testpass\r")
		e.RunWithError(t, "neo-go", "wallet", "claim",
			"--wallet", testWalletPath,
			"--address", testWalletAccount)
	})
	t.Run("insufficient funds", func(t *testing.T) {
		e.In.WriteString("testpass\r")
		e.RunWithError(t, "neo-go", "wallet", "claim",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--wallet", testWalletPath,
			"--address", testWalletAccount)
	})

	args := []string{
		"neo-go", "wallet", "nep17", "multitransfer",
		"--rpc-endpoint", "http://" + e.RPC.Addr,
		"--wallet", validatorWallet,
		"--from", validatorAddr,
		"--force",
		"NEO:" + testWalletAccount + ":1000",
		"GAS:" + testWalletAccount + ":1000", // for tx send
	}
	e.In.WriteString("one\r")
	e.Run(t, args...)
	e.checkTxPersisted(t)

	h, err := address.StringToUint160(testWalletAccount)
	require.NoError(t, err)

	balanceBefore := e.Chain.GetUtilityTokenBalance(h)
	claimHeight := e.Chain.BlockHeight() + 1
	cl, err := e.Chain.CalculateClaimable(h, claimHeight)
	require.NoError(t, err)
	require.True(t, cl.Sign() > 0)

	e.In.WriteString("testpass\r")
	e.Run(t, "neo-go", "wallet", "claim",
		"--rpc-endpoint", "http://"+e.RPC.Addr,
		"--wallet", testWalletPath,
		"--address", testWalletAccount)
	tx, height := e.checkTxPersisted(t)
	balanceBefore.Sub(balanceBefore, big.NewInt(tx.NetworkFee+tx.SystemFee))
	balanceBefore.Add(balanceBefore, cl)

	balanceAfter := e.Chain.GetUtilityTokenBalance(h)
	// height can be bigger than claimHeight especially when tests are executed with -race.
	if height == claimHeight {
		require.Equal(t, 0, balanceAfter.Cmp(balanceBefore))
	} else {
		require.Equal(t, 1, balanceAfter.Cmp(balanceBefore))
	}
}

func TestWalletImportDeployed(t *testing.T) {
	tmpDir := t.TempDir()
	e := newExecutor(t, true)
	h := deployVerifyContract(t, e)
	walletPath := filepath.Join(tmpDir, "wallet.json")

	e.Run(t, "neo-go", "wallet", "init", "--wallet", walletPath)

	priv, err := keys.NewPrivateKey()
	require.NoError(t, err)

	t.Run("missing wallet", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "import-deployed")
	})
	t.Run("missing contract sh", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "import-deployed",
			"--wallet", walletPath)
	})
	t.Run("missing WIF", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "import-deployed",
			"--wallet", walletPath, "--contract", h.StringLE())
	})
	t.Run("missing endpoint", func(t *testing.T) {
		e.In.WriteString("acc\rpass\rpass\r")
		e.RunWithError(t, "neo-go", "wallet", "import-deployed",
			"--wallet", walletPath, "--contract", h.StringLE(),
			"--wif", priv.WIF())
	})
	t.Run("unknown contract", func(t *testing.T) {
		e.In.WriteString("acc\rpass\rpass\r")
		e.RunWithError(t, "neo-go", "wallet", "import-deployed",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--wallet", walletPath, "--contract", util.Uint160{}.StringLE(),
			"--wif", priv.WIF())
	})
	t.Run("no `verify` method", func(t *testing.T) {
		badH := deployNNSContract(t, e) // wrong contract with no `verify` method
		e.In.WriteString("acc\rpass\rpass\r")
		e.RunWithError(t, "neo-go", "wallet", "import-deployed",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--wallet", walletPath, "--contract", badH.StringLE(),
			"--wif", priv.WIF())
	})

	e.In.WriteString("acc\rpass\rpass\r")
	e.Run(t, "neo-go", "wallet", "import-deployed",
		"--rpc-endpoint", "http://"+e.RPC.Addr,
		"--wallet", walletPath, "--wif", priv.WIF(), "--name", "my_acc",
		"--contract", h.StringLE())

	w, err := wallet.NewWalletFromFile(walletPath)
	t.Cleanup(func() {
		w.Close()
	})
	require.NoError(t, err)
	require.Equal(t, 1, len(w.Accounts))
	contractAddr := w.Accounts[0].Address
	require.Equal(t, address.Uint160ToString(h), contractAddr)
	require.True(t, w.Accounts[0].Contract.Deployed)

	t.Run("re-importing", func(t *testing.T) {
		e.In.WriteString("acc\rpass\rpass\r")
		e.RunWithError(t, "neo-go", "wallet", "import-deployed",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--wallet", walletPath, "--wif", priv.WIF(), "--name", "my_acc",
			"--contract", h.StringLE())
	})

	t.Run("Sign", func(t *testing.T) {
		e.In.WriteString("one\r")
		e.Run(t, "neo-go", "wallet", "nep17", "multitransfer",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--wallet", validatorWallet, "--from", validatorAddr,
			"--force",
			"NEO:"+contractAddr+":10",
			"GAS:"+contractAddr+":10")
		e.checkTxPersisted(t)

		privTo, err := keys.NewPrivateKey()
		require.NoError(t, err)

		e.In.WriteString("pass\r")
		e.Run(t, "neo-go", "wallet", "nep17", "transfer",
			"--rpc-endpoint", "http://"+e.RPC.Addr,
			"--wallet", walletPath, "--from", contractAddr,
			"--force",
			"--to", privTo.Address(), "--token", "NEO", "--amount", "1")
		e.checkTxPersisted(t)

		b, _ := e.Chain.GetGoverningTokenBalance(h)
		require.Equal(t, big.NewInt(9), b)
		b, _ = e.Chain.GetGoverningTokenBalance(privTo.GetScriptHash())
		require.Equal(t, big.NewInt(1), b)
	})
}

func TestWalletDump(t *testing.T) {
	e := newExecutor(t, false)

	t.Run("missing wallet", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "dump")
	})
	cmd := []string{"neo-go", "wallet", "dump", "--wallet", testWalletPath}
	e.Run(t, cmd...)
	rawStr := strings.TrimSpace(e.Out.String())
	w := new(wallet.Wallet)
	require.NoError(t, json.Unmarshal([]byte(rawStr), w))
	require.Equal(t, 1, len(w.Accounts))
	require.Equal(t, testWalletAccount, w.Accounts[0].Address)

	t.Run("with decrypt", func(t *testing.T) {
		cmd = append(cmd, "--decrypt")
		t.Run("EOF reading password", func(t *testing.T) {
			e.RunWithError(t, cmd...)
		})
		t.Run("invalid password", func(t *testing.T) {
			e.In.WriteString("invalidpass\r")
			e.RunWithError(t, cmd...)
		})

		e.In.WriteString("testpass\r")
		e.Run(t, cmd...)
		rawStr := strings.TrimSpace(e.Out.String())
		w := new(wallet.Wallet)
		require.NoError(t, json.Unmarshal([]byte(rawStr), w))
		require.Equal(t, 1, len(w.Accounts))
		require.Equal(t, testWalletAccount, w.Accounts[0].Address)
	})
}

func TestWalletDumpKeys(t *testing.T) {
	e := newExecutor(t, false)
	t.Run("missing wallet", func(t *testing.T) {
		e.RunWithError(t, "neo-go", "wallet", "dump-keys")
	})
	cmd := []string{"neo-go", "wallet", "dump-keys", "--wallet", validatorWallet}
	pubRegex := "^0[23][a-hA-H0-9]{64}$"
	t.Run("all", func(t *testing.T) {
		e.Run(t, cmd...)
		e.checkNextLine(t, "Nhfg3TbpwogLvDGVvAvqyThbsHgoSUKwtn")
		e.checkNextLine(t, pubRegex)
		e.checkNextLine(t, "^\\s*$")
		e.checkNextLine(t, "NVTiAjNgagDkTr5HTzDmQP9kPwPHN5BgVq")
		for i := 0; i < 4; i++ {
			e.checkNextLine(t, pubRegex)
		}
		e.checkNextLine(t, "^\\s*$")
		e.checkNextLine(t, "NfgHwwTi3wHAS8aFAN243C5vGbkYDpqLHP")
		e.checkNextLine(t, pubRegex)
		e.checkEOF(t)
	})
	t.Run("unknown address", func(t *testing.T) {
		cmd := append(cmd, "--address", util.Uint160{}.StringLE())
		e.RunWithError(t, cmd...)
	})
	t.Run("simple signature", func(t *testing.T) {
		cmd := append(cmd, "--address", "Nhfg3TbpwogLvDGVvAvqyThbsHgoSUKwtn")
		e.Run(t, cmd...)
		e.checkNextLine(t, "simple signature contract")
		e.checkNextLine(t, pubRegex)
		e.checkEOF(t)
	})
	t.Run("3/4 multisig", func(t *testing.T) {
		cmd := append(cmd, "-a", "NVTiAjNgagDkTr5HTzDmQP9kPwPHN5BgVq")
		e.Run(t, cmd...)
		e.checkNextLine(t, "3 out of 4 multisig contract")
		for i := 0; i < 4; i++ {
			e.checkNextLine(t, pubRegex)
		}
		e.checkEOF(t)
	})
	t.Run("1/1 multisig", func(t *testing.T) {
		cmd := append(cmd, "--address", "NfgHwwTi3wHAS8aFAN243C5vGbkYDpqLHP")
		e.Run(t, cmd...)
		e.checkNextLine(t, "1 out of 1 multisig contract")
		e.checkNextLine(t, pubRegex)
		e.checkEOF(t)
	})
}

// Testcase is the wallet of privnet validator.
func TestWalletConvert(t *testing.T) {
	tmpDir := t.TempDir()
	e := newExecutor(t, false)

	outPath := filepath.Join(tmpDir, "wallet.json")
	cmd := []string{"neo-go", "wallet", "convert"}
	t.Run("missing wallet", func(t *testing.T) {
		e.RunWithError(t, cmd...)
	})
	cmd = append(cmd, "--wallet", "testdata/wallets/testwallet_NEO2.json")
	t.Run("missing out path", func(t *testing.T) {
		e.RunWithError(t, cmd...)
	})
	t.Run("invalid out path", func(t *testing.T) {
		dir := t.TempDir()
		e.RunWithError(t, append(cmd, "--out", dir)...)
	})

	cmd = append(cmd, "--out", outPath)
	t.Run("invalid password", func(t *testing.T) {
		// missing password
		e.RunWithError(t, cmd...)
		// invalid password
		e.In.WriteString("two\r")
		e.RunWithError(t, cmd...)
	})

	// 2 accounts.
	e.In.WriteString("one\r")
	e.In.WriteString("one\r")
	e.Run(t, "neo-go", "wallet", "convert",
		"--wallet", "testdata/wallets/testwallet_NEO2.json",
		"--out", outPath)

	actual, err := wallet.NewWalletFromFile(outPath)
	require.NoError(t, err)
	expected, err := wallet.NewWalletFromFile("testdata/wallets/testwallet_NEO3.json")
	require.NoError(t, err)
	require.Equal(t, len(actual.Accounts), len(expected.Accounts))
	for _, exp := range expected.Accounts {
		addr, err := address.StringToUint160(exp.Address)
		require.NoError(t, err)

		act := actual.GetAccount(addr)
		require.NotNil(t, act)
		require.Equal(t, exp, act)
	}
}