From 0c1a9dcc421e547122513083eecd54f42d02064e Mon Sep 17 00:00:00 2001 From: Federico Kunze Date: Sun, 8 Jul 2018 19:50:24 -0400 Subject: [PATCH 01/38] Update with Gov CLI for gaia-7000 --- cmd/gaia/testnets/README.md | 69 +++++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) diff --git a/cmd/gaia/testnets/README.md b/cmd/gaia/testnets/README.md index e8d1f83e4d..7d72d2de2f 100644 --- a/cmd/gaia/testnets/README.md +++ b/cmd/gaia/testnets/README.md @@ -353,6 +353,75 @@ gaiacli stake delegation \ --chain-id=gaia-6002 ``` +## Governance + +Governace is the process from which users in Cosmos can come to consensus on software updates, parameters of the mainnet or on custom proposals for independent sovereign zones/hubs. + +Governance is done through voting on proposals, which will be submitted by `Atom` holders on the mainnet. For more information about the governance process and how it works, please check out the Governance module [specification](https://github.com/cosmos/cosmos-sdk/tree/develop/docs/spec/governance). + +### Create a Governance proposal + +In order to create a governance proposal, you must submit an initial deposit along with the proposal details (_i.e_ `title`, `description` and `type`, which must be of value _Text_, _ParameterChange_ or _SoftwareUpgrade_): + +```bash +gaiacli gov submit-proposal \ + --title= \ + --description=<description> \ + --type=<Text/ParameterChange/SoftwareUpgrade> \ + --proposer=<account_cosmosaccaddr> \ + --deposit=<40steak> \ + --from=<name> \ + --chain-id=gaia-7000 +``` + + +### Rise deposit + +In order for a proposal to be broadcasted to the network, the amount deposited must be above a `minDeposit` value (default: `10 steak`). If the proposal you previously created didn't meet this requirement, you can still rise the total amount deposited to make it valid. Once the minimum deposit is reached, proposal enters voting period: + +```bash +gaiacli gov deposit \ + --proposalID=<proposal_id> \ + --depositer=<account_cosmosaccaddr> \ + --deposit=<200steak> \ + --from=<name> \ + --chain-id=gaia-7000 +``` + +_NOTE_: Proposals that don't meet this requirement will be deleted. + +#### Query proposal + +Once created, you can now query information of the proposal: + +```bash +gaiacli gov query-proposal \ + --proposalID=<proposal_id> \ + --chain-id=gaia-7000 +``` + +### Vote on a proposal + +```bash +gaiacli gov vote \ + --proposalID=<proposal_id> \ + --voter=<account_cosmosaccaddr> \ + --option=<Yes/No/NoWithVeto/Abstain> \ + --from=<name> \ + --chain-id=gaia-7000 +``` + +#### Query vote + +Check the vote with the option you just submitted: + +```bash +gaiacli gov query-vote \ + --proposalID=<proposal_id> \ + --voter=<account_cosmosaccaddr> \ + --chain-id=gaia-7000 +``` + ## Other Operations ### Send Tokens From e894fbe4b6c8b7c68e7fde412395580e4e6eb873 Mon Sep 17 00:00:00 2001 From: sunnya97 <sunnya97@protonmail.ch> Date: Tue, 3 Jul 2018 21:52:48 -0700 Subject: [PATCH 02/38] in progress --- types/account.go | 73 ++++++++++++++++++++++++++++++++++++------- types/account_test.go | 1 + 2 files changed, 62 insertions(+), 12 deletions(-) create mode 100644 types/account_test.go diff --git a/types/account.go b/types/account.go index 38d59e066e..04905ac2f4 100644 --- a/types/account.go +++ b/types/account.go @@ -7,13 +7,9 @@ import ( "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/libs/bech32" - cmn "github.com/tendermint/tendermint/libs/common" ) -//Address is a go crypto-style Address -type Address = cmn.HexBytes - -// nolint +// Bech32 prefixes const ( // expected address length AddrLen = 20 @@ -25,18 +21,71 @@ const ( Bech32PrefixValPub = "cosmosvalpub" ) -// Bech32ifyAcc takes Address and returns the bech32 encoded string -func Bech32ifyAcc(addr Address) (string, error) { - return bech32.ConvertAndEncode(Bech32PrefixAccAddr, addr.Bytes()) +//Address is a go crypto-style Address +type Address []byte + +func NewAddress(bech32String string) (Address, error) { + return GetAccAddressHex(bech32String) } -// MustBech32ifyAcc panics on bech32-encoding failure -func MustBech32ifyAcc(addr Address) string { - enc, err := Bech32ifyAcc(addr) +// Marshal needed for protobuf compatibility +func (bz Address) Marshal() ([]byte, error) { + return bz, nil +} + +// Unmarshal needed for protobuf compatibility +func (bz *Address) Unmarshal(data []byte) error { + *bz = data + return nil +} + +// Marshals to JSON using Bech32 +func (bz Address) MarshalJSON() ([]byte, error) { + s := bz.String() + jbz := make([]byte, len(s)+2) + jbz[0] = '"' + copy(jbz[1:], []byte(s)) + jbz[len(jbz)-1] = '"' + return jbz, nil +} + +// Unmarshals from JSON assuming Bech32 encoding +func (bz *Address) UnmarshalJSON(data []byte) error { + if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' { + return fmt.Errorf("Invalid bech32 string: %s", data) + } + + bz2, err := GetAccAddressHex(string(data[1 : len(data)-1])) + if err != nil { + return err + } + *bz = bz2 + return nil +} + +// Allow it to fulfill various interfaces in light-client, etc... +func (bz Address) Bytes() []byte { + return bz +} + +func (bz Address) String() string { + bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixAccAddr, bz.Bytes()) if err != nil { panic(err) } - return enc + return bech32Addr +} + +// For Printf / Sprintf, returns bech32 when using %s +func (bz Address) Format(s fmt.State, verb rune) { + switch verb { + case 's': + s.Write([]byte(fmt.Sprintf("%s", bz.String()))) + case 'p': + s.Write([]byte(fmt.Sprintf("%p", bz))) + default: + s.Write([]byte(fmt.Sprintf("%X", []byte(bz)))) + } } // Bech32ifyAccPub takes AccountPubKey and returns the bech32 encoded string diff --git a/types/account_test.go b/types/account_test.go new file mode 100644 index 0000000000..ab1254f4c2 --- /dev/null +++ b/types/account_test.go @@ -0,0 +1 @@ +package types From 50ed0fa1ae9970080b2aec6852350d24ec0b8a9c Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Thu, 5 Jul 2018 13:36:51 -0700 Subject: [PATCH 03/38] asdf --- client/context/helpers.go | 2 +- client/keys/add.go | 22 +++---- client/keys/utils.go | 17 +++-- client/lcd/lcd_test.go | 16 +++-- client/lcd/test_helpers.go | 4 +- types/account.go | 10 +-- x/auth/mock/app.go | 110 +++++++++++++++++++++++++++++++++ x/bank/app_test.go | 8 +-- x/bank/client/rest/sendtx.go | 2 +- x/bank/msgs.go | 20 ++---- x/gov/depositsvotes.go | 18 +++--- x/gov/errors.go | 3 +- x/ibc/app_test.go | 2 +- x/ibc/client/rest/transfer.go | 2 +- x/ibc/types.go | 18 +----- x/slashing/app_test.go | 4 +- x/slashing/client/cli/query.go | 2 +- x/slashing/handler.go | 2 +- x/slashing/keeper.go | 4 +- x/stake/app_test.go | 15 ++++- x/stake/keeper/test_common.go | 7 +-- x/stake/types/delegation.go | 30 ++++----- x/stake/types/msg.go | 46 +++++++------- x/stake/types/test_utils.go | 6 +- x/stake/types/validator.go | 7 +-- 25 files changed, 226 insertions(+), 151 deletions(-) create mode 100644 x/auth/mock/app.go diff --git a/client/context/helpers.go b/client/context/helpers.go index e0fa45580b..f7845f696e 100644 --- a/client/context/helpers.go +++ b/client/context/helpers.go @@ -126,7 +126,7 @@ func (ctx CoreContext) GetFromAddress() (from sdk.Address, err error) { return nil, errors.Errorf("no key for: %s", name) } - return info.GetPubKey().Address(), nil + return sdk.Address(info.GetPubKey().Address()), nil } // sign and build the transaction from the msg diff --git a/client/keys/add.go b/client/keys/add.go index b763546850..404934d5fe 100644 --- a/client/keys/add.go +++ b/client/keys/add.go @@ -161,6 +161,12 @@ type NewKeyBody struct { Password string `json:"password"` } +// new key response REST body +type NewKeyResponse struct { + Address sdk.Address `json:"address"` + Mnemonic string `json:"mnemonic"` +} + // add new key REST handler func AddNewKeyRequestHandler(w http.ResponseWriter, r *http.Request) { var kb keys.Keybase @@ -209,17 +215,11 @@ func AddNewKeyRequestHandler(w http.ResponseWriter, r *http.Request) { w.Write([]byte(err.Error())) return } - - keyOutput, err := Bech32KeyOutput(info) - if err != nil { - w.WriteHeader(http.StatusInternalServerError) - w.Write([]byte(err.Error())) - return - } - - keyOutput.Seed = mnemonic - - output, err := json.MarshalIndent(keyOutput, "", " ") + address := sdk.Address(info.GetPubKey().Address().Bytes()) + bz, err := json.Marshal(NewKeyResponse{ + Address: address, + Mnemonic: mnemonic, + }) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(err.Error())) diff --git a/client/keys/utils.go b/client/keys/utils.go index aaa7c37f83..76ac591ef7 100644 --- a/client/keys/utils.go +++ b/client/keys/utils.go @@ -48,11 +48,11 @@ func SetKeyBase(kb keys.Keybase) { // used for outputting keys.Info over REST type KeyOutput struct { - Name string `json:"name"` - Type string `json:"type"` - Address string `json:"address"` - PubKey string `json:"pub_key"` - Seed string `json:"seed,omitempty"` + Name string `json:"name"` + Type string `json:"type"` + Address sdk.Address `json:"address"` + PubKey string `json:"pub_key"` + Seed string `json:"seed,omitempty"` } // create a list of KeyOutput in bech32 format @@ -70,10 +70,7 @@ func Bech32KeysOutput(infos []keys.Info) ([]KeyOutput, error) { // create a KeyOutput in bech32 format func Bech32KeyOutput(info keys.Info) (KeyOutput, error) { - bechAccount, err := sdk.Bech32ifyAcc(sdk.Address(info.GetPubKey().Address().Bytes())) - if err != nil { - return KeyOutput{}, err - } + account := sdk.Address(info.GetPubKey().Address().Bytes()) bechPubKey, err := sdk.Bech32ifyAccPub(info.GetPubKey()) if err != nil { return KeyOutput{}, err @@ -81,7 +78,7 @@ func Bech32KeyOutput(info keys.Info) (KeyOutput, error) { return KeyOutput{ Name: info.GetName(), Type: info.GetType(), - Address: bechAccount, + Address: account, PubKey: bechPubKey, }, nil } diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go index 234ed57b01..de8269c10e 100644 --- a/client/lcd/lcd_test.go +++ b/client/lcd/lcd_test.go @@ -60,7 +60,7 @@ func TestKeys(t *testing.T) { err = wire.Cdc.UnmarshalJSON([]byte(body), &resp) require.Nil(t, err, body) - addr2Bech32 := resp.Address + addr2Bech32 := resp.Address.String() _, err = sdk.GetAccAddressBech32(addr2Bech32) require.NoError(t, err, "Failed to return a correct bech32 address") @@ -71,7 +71,7 @@ func TestKeys(t *testing.T) { err = cdc.UnmarshalJSON([]byte(body), &m) require.Nil(t, err) - addrBech32 := sdk.MustBech32ifyAcc(addr) + addrBech32 := addr.String() require.Equal(t, name, m[0].Name, "Did not serve keys name correctly") require.Equal(t, addrBech32, m[0].Address, "Did not serve keys Address correctly") @@ -224,10 +224,10 @@ func TestCoinSend(t *testing.T) { bz, err := hex.DecodeString("8FA6AB57AD6870F6B5B2E57735F38F2F30E73CB6") require.NoError(t, err) - someFakeAddr := sdk.MustBech32ifyAcc(bz) + someFakeAddr := sdk.Address(bz) // query empty - res, body := Request(t, port, "GET", "/accounts/"+someFakeAddr, nil) + res, body := Request(t, port, "GET", fmt.Sprintf("/accounts/%s", someFakeAddr), nil) require.Equal(t, http.StatusNoContent, res.StatusCode, body) acc := getAccount(t, port, addr) @@ -334,8 +334,7 @@ func TestTxs(t *testing.T) { // query sender // also tests url decoding - addrBech := sdk.MustBech32ifyAcc(addr) - res, body = Request(t, port, "GET", "/txs?tag=sender_bech32=%27"+addrBech+"%27", nil) + res, body = Request(t, port, "GET", fmt.Sprintf("/txs?tag=sender_bech32=%%27%s%%27", addr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) err = cdc.UnmarshalJSON([]byte(body), &indexedTxs) @@ -344,8 +343,7 @@ func TestTxs(t *testing.T) { require.Equal(t, resultTx.Height, indexedTxs[0].Height) // query recipient - receiveAddrBech := sdk.MustBech32ifyAcc(receiveAddr) - res, body = Request(t, port, "GET", fmt.Sprintf("/txs?tag=recipient_bech32='%s'", receiveAddrBech), nil) + res, body = Request(t, port, "GET", fmt.Sprintf("/txs?tag=recipient_bech32='%s'", receiveAddr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) err = cdc.UnmarshalJSON([]byte(body), &indexedTxs) @@ -382,7 +380,7 @@ func TestBonding(t *testing.T) { cleanup, pks, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) defer cleanup() - validator1Owner := pks[0].Address() + validator1Owner := sdk.Address(pks[0].Address()) // create bond TX resultTx := doDelegate(t, port, seed, name, password, addr, validator1Owner) diff --git a/client/lcd/test_helpers.go b/client/lcd/test_helpers.go index 5499f25beb..9116211bc8 100644 --- a/client/lcd/test_helpers.go +++ b/client/lcd/test_helpers.go @@ -85,7 +85,7 @@ func CreateAddr(t *testing.T, name, password string, kb crkeys.Keybase) (addr sd var err error info, seed, err = kb.CreateMnemonic(name, crkeys.English, password, crkeys.Secp256k1) require.NoError(t, err) - addr = info.GetPubKey().Address() + addr = sdk.Address(info.GetPubKey().Address()) return } @@ -132,7 +132,7 @@ func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.Address) ( for _, gdValidator := range genDoc.Validators { pk := gdValidator.PubKey validatorsPKs = append(validatorsPKs, pk) // append keys for output - appGenTx, _, _, err := gapp.GaiaAppGenTxNF(cdc, pk, sdk.MustBech32ifyAcc(pk.Address()), "test_val1") + appGenTx, _, _, err := gapp.GaiaAppGenTxNF(cdc, pk, sdk.Address(pk.Address()), "test_val1") require.NoError(t, err) appGenTxs = append(appGenTxs, appGenTx) } diff --git a/types/account.go b/types/account.go index 04905ac2f4..e8e4c541d8 100644 --- a/types/account.go +++ b/types/account.go @@ -21,7 +21,7 @@ const ( Bech32PrefixValPub = "cosmosvalpub" ) -//Address is a go crypto-style Address +// Address is a go crypto-style Address type Address []byte func NewAddress(bech32String string) (Address, error) { @@ -103,13 +103,13 @@ func MustBech32ifyAccPub(pub crypto.PubKey) string { } // Bech32ifyVal returns the bech32 encoded string for a validator address -func Bech32ifyVal(addr Address) (string, error) { - return bech32.ConvertAndEncode(Bech32PrefixValAddr, addr.Bytes()) +func Bech32ifyVal(bz []byte) (string, error) { + return bech32.ConvertAndEncode(Bech32PrefixValAddr, bz) } // MustBech32ifyVal panics on bech32-encoding failure -func MustBech32ifyVal(addr Address) string { - enc, err := Bech32ifyVal(addr) +func MustBech32ifyVal(bz []byte) string { + enc, err := Bech32ifyVal(bz) if err != nil { panic(err) } diff --git a/x/auth/mock/app.go b/x/auth/mock/app.go new file mode 100644 index 0000000000..fe8fd4ee42 --- /dev/null +++ b/x/auth/mock/app.go @@ -0,0 +1,110 @@ +package mock + +import ( + "os" + + abci "github.com/tendermint/tendermint/abci/types" + "github.com/tendermint/tendermint/crypto" + dbm "github.com/tendermint/tendermint/libs/db" + "github.com/tendermint/tendermint/libs/log" + + bam "github.com/cosmos/cosmos-sdk/baseapp" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/wire" + "github.com/cosmos/cosmos-sdk/x/auth" +) + +// Extended ABCI application +type App struct { + *bam.BaseApp + Cdc *wire.Codec // public since the codec is passed into the module anyways. + KeyMain *sdk.KVStoreKey + KeyAccount *sdk.KVStoreKey + + // TODO: Abstract this out from not needing to be auth specifically + AccountMapper auth.AccountMapper + FeeCollectionKeeper auth.FeeCollectionKeeper + + GenesisAccounts []auth.Account +} + +// partially construct a new app on the memstore for module and genesis testing +func NewApp() *App { + logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "sdk/app") + db := dbm.NewMemDB() + + // create the cdc with some standard codecs + cdc := wire.NewCodec() + sdk.RegisterWire(cdc) + wire.RegisterCrypto(cdc) + auth.RegisterWire(cdc) + + // create your application object + app := &App{ + BaseApp: bam.NewBaseApp("mock", cdc, logger, db), + Cdc: cdc, + KeyMain: sdk.NewKVStoreKey("main"), + KeyAccount: sdk.NewKVStoreKey("acc"), + } + + // define the accountMapper + app.AccountMapper = auth.NewAccountMapper( + app.Cdc, + app.KeyAccount, // target store + &auth.BaseAccount{}, // prototype + ) + + // initialize the app, the chainers and blockers can be overwritten before calling complete setup + app.SetInitChainer(app.InitChainer) + + app.SetAnteHandler(auth.NewAnteHandler(app.AccountMapper, app.FeeCollectionKeeper)) + + return app +} + +// complete the application setup after the routes have been registered +func (app *App) CompleteSetup(newKeys []*sdk.KVStoreKey) error { + newKeys = append(newKeys, app.KeyMain) + newKeys = append(newKeys, app.KeyAccount) + app.MountStoresIAVL(newKeys...) + err := app.LoadLatestVersion(app.KeyMain) + return err +} + +// custom logic for initialization +func (app *App) InitChainer(ctx sdk.Context, _ abci.RequestInitChain) abci.ResponseInitChain { + + // load the accounts + for _, genacc := range app.GenesisAccounts { + acc := app.AccountMapper.NewAccountWithAddress(ctx, genacc.GetAddress()) + err := acc.SetCoins(genacc.GetCoins()) + if err != nil { + // TODO: Handle with #870 + panic(err) + } + app.AccountMapper.SetAccount(ctx, acc) + } + + return abci.ResponseInitChain{} +} + +// Generate genesis accounts loaded with coins, and returns their addresses, pubkeys, and privkeys +func CreateGenAccounts(numAccs int64, genCoins sdk.Coins) (genAccs []auth.Account, addrs []sdk.Address, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) { + for i := int64(0); i < numAccs; i++ { + privKey := crypto.GenPrivKeyEd25519() + pubKey := privKey.PubKey() + addr := sdk.Address(pubKey.Address()) + + genAcc := &auth.BaseAccount{ + Address: addr, + Coins: genCoins, + } + + genAccs = append(genAccs, genAcc) + privKeys = append(privKeys, privKey) + pubKeys = append(pubKeys, pubKey) + addrs = append(addrs, addr) + } + + return +} diff --git a/x/bank/app_test.go b/x/bank/app_test.go index a89806d123..7280ec93a6 100644 --- a/x/bank/app_test.go +++ b/x/bank/app_test.go @@ -18,12 +18,12 @@ import ( // test bank module in a mock application var ( priv1 = crypto.GenPrivKeyEd25519() - addr1 = priv1.PubKey().Address() + addr1 = sdk.Address(priv1.PubKey().Address()) priv2 = crypto.GenPrivKeyEd25519() - addr2 = priv2.PubKey().Address() - addr3 = crypto.GenPrivKeyEd25519().PubKey().Address() + addr2 = sdk.Address(priv2.PubKey().Address()) + addr3 = sdk.Address(crypto.GenPrivKeyEd25519().PubKey().Address()) priv4 = crypto.GenPrivKeyEd25519() - addr4 = priv4.PubKey().Address() + addr4 = sdk.Address(priv4.PubKey().Address()) coins = sdk.Coins{sdk.NewCoin("foocoin", 10)} halfCoins = sdk.Coins{sdk.NewCoin("foocoin", 5)} manyCoins = sdk.Coins{sdk.NewCoin("foocoin", 1), sdk.NewCoin("barcoin", 1)} diff --git a/x/bank/client/rest/sendtx.go b/x/bank/client/rest/sendtx.go index 3dd7656ccc..a93c0a2c7f 100644 --- a/x/bank/client/rest/sendtx.go +++ b/x/bank/client/rest/sendtx.go @@ -80,7 +80,7 @@ func SendRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.CoreCont } // build message - msg := client.BuildMsg(info.GetPubKey().Address(), to, m.Amount) + msg := client.BuildMsg(sdk.Address(info.GetPubKey().Address()), to, m.Amount) if err != nil { // XXX rechecking same error ? w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(err.Error())) diff --git a/x/bank/msgs.go b/x/bank/msgs.go index 46b1995633..d8160fe904 100644 --- a/x/bank/msgs.go +++ b/x/bank/msgs.go @@ -124,10 +124,10 @@ func (msg MsgIssue) GetSignBytes() []byte { outputs = append(outputs, output.GetSignBytes()) } b, err := msgCdc.MarshalJSON(struct { - Banker string `json:"banker"` + Banker sdk.Address `json:"banker"` Outputs []json.RawMessage `json:"outputs"` }{ - Banker: sdk.MustBech32ifyAcc(msg.Banker), + Banker: msg.Banker, Outputs: outputs, }) if err != nil { @@ -152,13 +152,7 @@ type Input struct { // Return bytes to sign for Input func (in Input) GetSignBytes() []byte { - bin, err := msgCdc.MarshalJSON(struct { - Address string `json:"address"` - Coins sdk.Coins `json:"coins"` - }{ - Address: sdk.MustBech32ifyAcc(in.Address), - Coins: in.Coins, - }) + bin, err := msgCdc.MarshalJSON(in) if err != nil { panic(err) } @@ -199,13 +193,7 @@ type Output struct { // Return bytes to sign for Output func (out Output) GetSignBytes() []byte { - bin, err := msgCdc.MarshalJSON(struct { - Address string `json:"address"` - Coins sdk.Coins `json:"coins"` - }{ - Address: sdk.MustBech32ifyAcc(out.Address), - Coins: out.Coins, - }) + bin, err := msgCdc.MarshalJSON(out) if err != nil { panic(err) } diff --git a/x/gov/depositsvotes.go b/x/gov/depositsvotes.go index 5fbdc1600b..f45f5b557c 100644 --- a/x/gov/depositsvotes.go +++ b/x/gov/depositsvotes.go @@ -77,16 +77,15 @@ func StringToVoteOption(str string) (VoteOption, sdk.Error) { // Rest Deposits type DepositRest struct { - Depositer string `json:"voter"` // address of the voter - ProposalID int64 `json:"proposal_id"` // proposalID of the proposal - Amount sdk.Coins `json:"option"` + Depositer sdk.Address `json:"depositer"` // address of the depositer + ProposalID int64 `json:"proposal_id"` // proposalID of the proposal + Amount sdk.Coins `json:"option"` } // Turn any Deposit to a DepositRest func DepositToRest(deposit Deposit) DepositRest { - bechAddr := sdk.MustBech32ifyAcc(deposit.Depositer) return DepositRest{ - Depositer: bechAddr, + Depositer: deposit.Depositer, ProposalID: deposit.ProposalID, Amount: deposit.Amount, } @@ -94,16 +93,15 @@ func DepositToRest(deposit Deposit) DepositRest { // Rest Votes type VoteRest struct { - Voter string `json:"voter"` // address of the voter - ProposalID int64 `json:"proposal_id"` // proposalID of the proposal - Option string `json:"option"` + Voter sdk.Address `json:"voter"` // address of the voter + ProposalID int64 `json:"proposal_id"` // proposalID of the proposal + Option string `json:"option"` } // Turn any Vote to a VoteRest func VoteToRest(vote Vote) VoteRest { - bechAddr, _ := sdk.Bech32ifyAcc(vote.Voter) return VoteRest{ - Voter: bechAddr, + Voter: vote.Voter, ProposalID: vote.ProposalID, Option: VoteOptionToString(vote.Option), } diff --git a/x/gov/errors.go b/x/gov/errors.go index 9a389dc9cb..cd7c72bf51 100644 --- a/x/gov/errors.go +++ b/x/gov/errors.go @@ -42,8 +42,7 @@ func ErrAlreadyFinishedProposal(codespace sdk.CodespaceType, proposalID int64) s } func ErrAddressNotStaked(codespace sdk.CodespaceType, address sdk.Address) sdk.Error { - bechAddr, _ := sdk.Bech32ifyAcc(address) - return sdk.NewError(codespace, CodeAddressNotStaked, fmt.Sprintf("Address %s is not staked and is thus ineligible to vote", bechAddr)) + return sdk.NewError(codespace, CodeAddressNotStaked, fmt.Sprintf("Address %s is not staked and is thus ineligible to vote", address)) } func ErrInvalidTitle(codespace sdk.CodespaceType, title string) sdk.Error { diff --git a/x/ibc/app_test.go b/x/ibc/app_test.go index 3671cd3e19..3002f5ed61 100644 --- a/x/ibc/app_test.go +++ b/x/ibc/app_test.go @@ -35,7 +35,7 @@ func TestIBCMsgs(t *testing.T) { destChain := "dest-chain" priv1 := crypto.GenPrivKeyEd25519() - addr1 := priv1.PubKey().Address() + addr1 := sdk.Address(priv1.PubKey().Address()) coins := sdk.Coins{sdk.NewCoin("foocoin", 10)} var emptyCoins sdk.Coins diff --git a/x/ibc/client/rest/transfer.go b/x/ibc/client/rest/transfer.go index cac0ca80b1..f9173a153d 100644 --- a/x/ibc/client/rest/transfer.go +++ b/x/ibc/client/rest/transfer.go @@ -76,7 +76,7 @@ func TransferRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.Core to := sdk.Address(bz) // build message - packet := ibc.NewIBCPacket(info.GetPubKey().Address(), to, m.Amount, m.SrcChainID, destChainID) + packet := ibc.NewIBCPacket(sdk.Address(info.GetPubKey().Address()), to, m.Amount, m.SrcChainID, destChainID) msg := ibc.IBCTransferMsg{packet} // add gas to context diff --git a/x/ibc/types.go b/x/ibc/types.go index 33f2a9a8d3..1356e4e36f 100644 --- a/x/ibc/types.go +++ b/x/ibc/types.go @@ -43,19 +43,7 @@ func NewIBCPacket(srcAddr sdk.Address, destAddr sdk.Address, coins sdk.Coins, //nolint func (p IBCPacket) GetSignBytes() []byte { - b, err := msgCdc.MarshalJSON(struct { - SrcAddr string - DestAddr string - Coins sdk.Coins - SrcChain string - DestChain string - }{ - SrcAddr: sdk.MustBech32ifyAcc(p.SrcAddr), - DestAddr: sdk.MustBech32ifyAcc(p.DestAddr), - Coins: p.Coins, - SrcChain: p.SrcChain, - DestChain: p.DestChain, - }) + b, err := msgCdc.MarshalJSON(p) if err != nil { panic(err) } @@ -121,11 +109,11 @@ func (msg IBCReceiveMsg) GetSigners() []sdk.Address { return []sdk.Address{msg.R func (msg IBCReceiveMsg) GetSignBytes() []byte { b, err := msgCdc.MarshalJSON(struct { IBCPacket json.RawMessage - Relayer string + Relayer sdk.Address Sequence int64 }{ IBCPacket: json.RawMessage(msg.IBCPacket.GetSignBytes()), - Relayer: sdk.MustBech32ifyAcc(msg.Relayer), + Relayer: msg.Relayer, Sequence: msg.Sequence, }) if err != nil { diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go index d6fb0d9fe8..fa9548c484 100644 --- a/x/slashing/app_test.go +++ b/x/slashing/app_test.go @@ -15,7 +15,7 @@ import ( var ( priv1 = crypto.GenPrivKeyEd25519() - addr1 = priv1.PubKey().Address() + addr1 = sdk.Address(priv1.PubKey().Address()) coins = sdk.Coins{sdk.NewCoin("foocoin", 10)} ) @@ -100,7 +100,7 @@ func TestSlashingMsgs(t *testing.T) { require.Equal(t, addr1, validator.Owner) require.Equal(t, sdk.Bonded, validator.Status()) require.True(sdk.RatEq(t, sdk.NewRat(10), validator.PoolShares.Bonded())) - unrevokeMsg := MsgUnrevoke{ValidatorAddr: validator.PubKey.Address()} + unrevokeMsg := MsgUnrevoke{ValidatorAddr: sdk.Address(validator.PubKey.Address())} checkValidatorSigningInfo(t, mapp, keeper, addr1, false) diff --git a/x/slashing/client/cli/query.go b/x/slashing/client/cli/query.go index 3e2023f5eb..5ff1c704c1 100644 --- a/x/slashing/client/cli/query.go +++ b/x/slashing/client/cli/query.go @@ -25,7 +25,7 @@ func GetCmdQuerySigningInfo(storeName string, cdc *wire.Codec) *cobra.Command { if err != nil { return err } - key := slashing.GetValidatorSigningInfoKey(pk.Address()) + key := slashing.GetValidatorSigningInfoKey(sdk.Address(pk.Address())) ctx := context.NewCoreContextFromViper() res, err := ctx.QueryStore(key, storeName) if err != nil { diff --git a/x/slashing/handler.go b/x/slashing/handler.go index 21d50aef8f..6ba0be0473 100644 --- a/x/slashing/handler.go +++ b/x/slashing/handler.go @@ -30,7 +30,7 @@ func handleMsgUnrevoke(ctx sdk.Context, msg MsgUnrevoke, k Keeper) sdk.Result { return ErrValidatorNotRevoked(k.codespace).Result() } - addr := validator.GetPubKey().Address() + addr := sdk.Address(validator.GetPubKey().Address()) // Signing info must exist info, found := k.getValidatorSigningInfo(ctx, addr) diff --git a/x/slashing/keeper.go b/x/slashing/keeper.go index 9ad1c1ea25..fb17739832 100644 --- a/x/slashing/keeper.go +++ b/x/slashing/keeper.go @@ -34,7 +34,7 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, pubkey crypto.PubKey, infracti logger := ctx.Logger().With("module", "x/slashing") time := ctx.BlockHeader().Time age := time - timestamp - address := pubkey.Address() + address := sdk.Address(pubkey.Address()) // Double sign too old if age > MaxEvidenceAge { @@ -64,7 +64,7 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, pubkey crypto.PubKey, infracti func (k Keeper) handleValidatorSignature(ctx sdk.Context, pubkey crypto.PubKey, power int64, signed bool) { logger := ctx.Logger().With("module", "x/slashing") height := ctx.BlockHeight() - address := pubkey.Address() + address := sdk.Address(pubkey.Address()) // Local index, so counts blocks validator *should* have signed // Will use the 0-value default signing info if not present, except for start height diff --git a/x/stake/app_test.go b/x/stake/app_test.go index 02dd091341..be4dc90cc0 100644 --- a/x/stake/app_test.go +++ b/x/stake/app_test.go @@ -14,14 +14,23 @@ import ( var ( priv1 = crypto.GenPrivKeyEd25519() - addr1 = priv1.PubKey().Address() + addr1 = sdk.Address(priv1.PubKey().Address()) priv2 = crypto.GenPrivKeyEd25519() - addr2 = priv2.PubKey().Address() - addr3 = crypto.GenPrivKeyEd25519().PubKey().Address() + addr2 = sdk.Address(priv2.PubKey().Address()) + addr3 = sdk.Address(crypto.GenPrivKeyEd25519().PubKey().Address()) priv4 = crypto.GenPrivKeyEd25519() +<<<<<<< HEAD addr4 = priv4.PubKey().Address() coins = sdk.NewCoin("foocoin", 10) fee = auth.StdFee{sdk.Coins{sdk.NewCoin("foocoin", 0)}, 100000} +======= + addr4 = sdk.Address(priv4.PubKey().Address()) + coins = sdk.Coins{{"foocoin", sdk.NewInt(10)}} + fee = auth.StdFee{ + sdk.Coins{{"foocoin", sdk.NewInt(0)}}, + 100000, + } +>>>>>>> asdf ) // getMockApp returns an initialized mock application for this module. diff --git a/x/stake/keeper/test_common.go b/x/stake/keeper/test_common.go index aa3c25aba9..211b37ec16 100644 --- a/x/stake/keeper/test_common.go +++ b/x/stake/keeper/test_common.go @@ -143,10 +143,7 @@ func TestAddr(addr string, bech string) sdk.Address { if err != nil { panic(err) } - bechexpected, err := sdk.Bech32ifyAcc(res) - if err != nil { - panic(err) - } + bechexpected := res.String() if bech != bechexpected { panic("Bech encoding doesn't match reference") } @@ -174,7 +171,7 @@ func createTestAddrs(numAddrs int) []sdk.Address { buffer.WriteString(numString) //adding on final two digits to make addresses unique res, _ := sdk.GetAccAddressHex(buffer.String()) - bech, _ := sdk.Bech32ifyAcc(res) + bech := res.String() addresses = append(addresses, TestAddr(buffer.String(), bech)) buffer.Reset() } diff --git a/x/stake/types/delegation.go b/x/stake/types/delegation.go index f7d31a6407..8439e3da3d 100644 --- a/x/stake/types/delegation.go +++ b/x/stake/types/delegation.go @@ -86,19 +86,9 @@ func (d Delegation) GetBondShares() sdk.Rat { return d.Shares } // Delegation. An error is returned if the Delegation's delegator or validator // addresses cannot be Bech32 encoded. func (d Delegation) HumanReadableString() (string, error) { - bechAcc, err := sdk.Bech32ifyAcc(d.DelegatorAddr) - if err != nil { - return "", err - } - - bechVal, err := sdk.Bech32ifyAcc(d.ValidatorAddr) - if err != nil { - return "", err - } - resp := "Delegation \n" - resp += fmt.Sprintf("Delegator: %s\n", bechAcc) - resp += fmt.Sprintf("Validator: %s\n", bechVal) + resp += fmt.Sprintf("Delegator: %s\n", d.DelegatorAddr) + resp += fmt.Sprintf("Validator: %s\n", d.ValidatorAddr) resp += fmt.Sprintf("Shares: %s", d.Shares.String()) resp += fmt.Sprintf("Height: %d", d.Height) @@ -179,6 +169,7 @@ func (d UnbondingDelegation) Equal(d2 UnbondingDelegation) bool { // UnbondingDelegation. An error is returned if the UnbondingDelegation's // delegator or validator addresses cannot be Bech32 encoded. func (d UnbondingDelegation) HumanReadableString() (string, error) { +<<<<<<< HEAD bechAcc, err := sdk.Bech32ifyAcc(d.DelegatorAddr) if err != nil { return "", err @@ -189,9 +180,11 @@ func (d UnbondingDelegation) HumanReadableString() (string, error) { return "", err } +======= +>>>>>>> asdf resp := "Unbonding Delegation \n" - resp += fmt.Sprintf("Delegator: %s\n", bechAcc) - resp += fmt.Sprintf("Validator: %s\n", bechVal) + resp += fmt.Sprintf("Delegator: %s\n", d.DelegatorAddr) + resp += fmt.Sprintf("Validator: %s\n", d.ValidatorAddr) resp += fmt.Sprintf("Creation height: %v\n", d.CreationHeight) resp += fmt.Sprintf("Min time to unbond (unix): %v\n", d.MinTime) resp += fmt.Sprintf("Expected balance: %s", d.Balance.String()) @@ -285,6 +278,7 @@ func (d Redelegation) Equal(d2 Redelegation) bool { // Redelegation. An error is returned if the UnbondingDelegation's delegator or // validator addresses cannot be Bech32 encoded. func (d Redelegation) HumanReadableString() (string, error) { +<<<<<<< HEAD bechAcc, err := sdk.Bech32ifyAcc(d.DelegatorAddr) if err != nil { return "", err @@ -300,10 +294,12 @@ func (d Redelegation) HumanReadableString() (string, error) { return "", err } +======= +>>>>>>> asdf resp := "Redelegation \n" - resp += fmt.Sprintf("Delegator: %s\n", bechAcc) - resp += fmt.Sprintf("Source Validator: %s\n", bechValSrc) - resp += fmt.Sprintf("Destination Validator: %s\n", bechValDst) + resp += fmt.Sprintf("Delegator: %s\n", d.DelegatorAddr) + resp += fmt.Sprintf("Source Validator: %s\n", d.ValidatorSrcAddr) + resp += fmt.Sprintf("Destination Validator: %s\n", d.ValidatorDstAddr) resp += fmt.Sprintf("Creation height: %v\n", d.CreationHeight) resp += fmt.Sprintf("Min time to unbond (unix): %v\n", d.MinTime) resp += fmt.Sprintf("Source shares: %s", d.SharesSrc.String()) diff --git a/x/stake/types/msg.go b/x/stake/types/msg.go index aa9eea8cbb..1fc6a84bab 100644 --- a/x/stake/types/msg.go +++ b/x/stake/types/msg.go @@ -155,11 +155,11 @@ func (msg MsgDelegate) GetSigners() []sdk.Address { // get the bytes for the message signer to sign on func (msg MsgDelegate) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr string `json:"delegator_addr"` - ValidatorAddr string `json:"validator_addr"` - Bond sdk.Coin `json:"bond"` + DelegatorAddr sdk.Address `json:"delegator_addr"` + ValidatorAddr string `json:"validator_addr"` + Bond sdk.Coin `json:"bond"` }{ - DelegatorAddr: sdk.MustBech32ifyAcc(msg.DelegatorAddr), + DelegatorAddr: msg.DelegatorAddr, ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr), Bond: msg.Bond, }) @@ -213,14 +213,14 @@ func (msg MsgBeginRedelegate) GetSigners() []sdk.Address { // get the bytes for the message signer to sign on func (msg MsgBeginRedelegate) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr string `json:"delegator_addr"` - ValidatorSrcAddr string `json:"validator_src_addr"` - ValidatorDstAddr string `json:"validator_dst_addr"` - SharesAmount string `json:"shares"` + DelegatorAddr sdk.Address `json:"delegator_addr"` + ValidatorSrcAddr string `json:"validator_src_addr"` + ValidatorDstAddr string `json:"validator_dst_addr"` + SharesAmount string `json:"shares"` }{ - DelegatorAddr: sdk.MustBech32ifyAcc(msg.DelegatorAddr), - ValidatorSrcAddr: sdk.MustBech32ifyVal(msg.ValidatorSrcAddr), - ValidatorDstAddr: sdk.MustBech32ifyVal(msg.ValidatorDstAddr), + DelegatorAddr: msg.DelegatorAddr, + ValidatorSrcAddr: sdk.MustBech32ifyVal(msg.ValidatorSrcAddr.Bytes()), + ValidatorDstAddr: sdk.MustBech32ifyVal(msg.ValidatorDstAddr.Bytes()), SharesAmount: msg.SharesAmount.String(), }) if err != nil { @@ -275,11 +275,11 @@ func (msg MsgCompleteRedelegate) GetSigners() []sdk.Address { // get the bytes for the message signer to sign on func (msg MsgCompleteRedelegate) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr string `json:"delegator_addr"` - ValidatorSrcAddr string `json:"validator_src_addr"` - ValidatorDstAddr string `json:"validator_dst_addr"` + DelegatorAddr sdk.Address `json:"delegator_addr"` + ValidatorSrcAddr string `json:"validator_src_addr"` + ValidatorDstAddr string `json:"validator_dst_addr"` }{ - DelegatorAddr: sdk.MustBech32ifyAcc(msg.DelegatorAddr), + DelegatorAddr: msg.DelegatorAddr, ValidatorSrcAddr: sdk.MustBech32ifyVal(msg.ValidatorSrcAddr), ValidatorDstAddr: sdk.MustBech32ifyVal(msg.ValidatorDstAddr), }) @@ -327,11 +327,11 @@ func (msg MsgBeginUnbonding) GetSigners() []sdk.Address { return []sdk.Address{m // get the bytes for the message signer to sign on func (msg MsgBeginUnbonding) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr string `json:"delegator_addr"` - ValidatorAddr string `json:"validator_addr"` - SharesAmount string `json:"shares_amount"` + DelegatorAddr sdk.Address `json:"delegator_addr"` + ValidatorAddr string `json:"validator_addr"` + SharesAmount string `json:"shares_amount"` }{ - DelegatorAddr: sdk.MustBech32ifyAcc(msg.DelegatorAddr), + DelegatorAddr: msg.DelegatorAddr, ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr), SharesAmount: msg.SharesAmount.String(), }) @@ -378,11 +378,11 @@ func (msg MsgCompleteUnbonding) GetSigners() []sdk.Address { return []sdk.Addres // get the bytes for the message signer to sign on func (msg MsgCompleteUnbonding) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr string `json:"delegator_addr"` - ValidatorAddr string `json:"validator_src_addr"` + DelegatorAddr sdk.Address `json:"delegator_addr"` + ValidatorAddr string `json:"validator_src_addr"` }{ - DelegatorAddr: sdk.MustBech32ifyAcc(msg.DelegatorAddr), - ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr), + DelegatorAddr: msg.DelegatorAddr, + ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr.Bytes()), }) if err != nil { panic(err) diff --git a/x/stake/types/test_utils.go b/x/stake/types/test_utils.go index 7912b7fa85..02123ef8e4 100644 --- a/x/stake/types/test_utils.go +++ b/x/stake/types/test_utils.go @@ -14,9 +14,9 @@ var ( pk1 = crypto.GenPrivKeyEd25519().PubKey() pk2 = crypto.GenPrivKeyEd25519().PubKey() pk3 = crypto.GenPrivKeyEd25519().PubKey() - addr1 = pk1.Address() - addr2 = pk2.Address() - addr3 = pk3.Address() + addr1 = sdk.Address(pk1.Address()) + addr2 = sdk.Address(pk2.Address()) + addr3 = sdk.Address(pk3.Address()) emptyAddr sdk.Address emptyPubkey crypto.PubKey diff --git a/x/stake/types/validator.go b/x/stake/types/validator.go index 480416d015..01ddd64f27 100644 --- a/x/stake/types/validator.go +++ b/x/stake/types/validator.go @@ -394,18 +394,13 @@ func (v Validator) GetBondHeight() int64 { return v.BondHeight } // validator. An error is returned if the owner or the owner's public key // cannot be converted to Bech32 format. func (v Validator) HumanReadableString() (string, error) { - bechOwner, err := sdk.Bech32ifyAcc(v.Owner) - if err != nil { - return "", err - } - bechVal, err := sdk.Bech32ifyValPub(v.PubKey) if err != nil { return "", err } resp := "Validator \n" - resp += fmt.Sprintf("Owner: %s\n", bechOwner) + resp += fmt.Sprintf("Owner: %s\n", v.Owner) resp += fmt.Sprintf("Validator: %s\n", bechVal) resp += fmt.Sprintf("Shares: Status %s, Amount: %s\n", sdk.BondStatusToString(v.PoolShares.Status), v.PoolShares.Amount.FloatString()) resp += fmt.Sprintf("Delegator Shares: %s\n", v.DelegatorShares.FloatString()) From 7ac220beb6d2a371f372aa07c224ebc223ec905d Mon Sep 17 00:00:00 2001 From: sunnya97 <sunnya97@protonmail.ch> Date: Fri, 6 Jul 2018 00:06:53 -0700 Subject: [PATCH 04/38] asdf --- baseapp/baseapp_test.go | 2 +- client/context/helpers.go | 4 +- client/keys/add.go | 6 +- client/keys/utils.go | 12 +- client/lcd/lcd_test.go | 136 +++++------- client/lcd/test_helpers.go | 8 +- client/rpc/validators.go | 14 +- client/tx/search.go | 2 +- cmd/gaia/app/genesis.go | 14 +- cmd/gaia/app/genesis_test.go | 2 +- cmd/gaia/cli_test/cli_test.go | 66 +++--- cmd/gaia/cmd/gaiadebug/main.go | 13 +- docs/core/examples/app1.go | 16 +- docs/core/examples/app2.go | 12 +- docs/core/examples/app4.go | 4 +- examples/basecoin/app/app_test.go | 2 +- examples/basecoin/types/account.go | 6 +- examples/democoin/app/app_test.go | 2 +- examples/democoin/mock/validator.go | 8 +- examples/democoin/types/account.go | 6 +- examples/democoin/x/assoc/validator_set.go | 22 +- examples/democoin/x/cool/app_test.go | 2 +- examples/democoin/x/cool/types.go | 16 +- examples/democoin/x/oracle/errors.go | 2 +- examples/democoin/x/oracle/keeper.go | 4 +- examples/democoin/x/oracle/keeper_keys.go | 2 +- examples/democoin/x/oracle/types.go | 6 +- examples/democoin/x/pow/app_test.go | 2 +- examples/democoin/x/pow/handler_test.go | 2 +- examples/democoin/x/pow/keeper.go | 2 +- examples/democoin/x/pow/mine.go | 6 +- examples/democoin/x/pow/types.go | 16 +- examples/democoin/x/pow/types_test.go | 14 +- examples/democoin/x/simplestake/keeper.go | 14 +- .../democoin/x/simplestake/keeper_test.go | 4 +- examples/democoin/x/simplestake/msgs.go | 22 +- examples/democoin/x/simplestake/msgs_test.go | 4 +- examples/kvstore/tx.go | 2 +- server/init.go | 16 +- server/mock/tx.go | 2 +- types/account.go | 203 ++++++++++-------- types/account_test.go | 1 - types/stake.go | 20 +- types/tx_msg.go | 8 +- x/auth/account.go | 20 +- x/auth/account_test.go | 4 +- x/auth/ante.go | 2 +- x/auth/ante_test.go | 8 +- x/auth/mapper.go | 12 +- x/auth/mapper_test.go | 2 +- x/auth/mock/app.go | 4 +- x/auth/mock/auth_app_test.go | 92 ++++++++ x/auth/mock/simulate_block.go | 110 ++++++++++ x/auth/stdtx.go | 6 +- x/auth/stdtx_test.go | 2 +- x/bank/app_test.go | 8 +- x/bank/client/rest/sendtx.go | 2 +- x/bank/client/util.go | 2 +- x/bank/keeper.go | 34 +-- x/bank/keeper_test.go | 14 +- x/bank/msgs.go | 28 +-- x/bank/msgs_test.go | 44 ++-- x/gov/client/rest/rest.go | 4 +- x/gov/depositsvotes.go | 24 +-- x/gov/errors.go | 2 +- x/gov/handler.go | 2 +- x/gov/keeper.go | 14 +- x/gov/keeper_keys.go | 4 +- x/gov/msgs.go | 68 +++--- x/gov/msgs_test.go | 12 +- x/gov/tally.go | 14 +- x/gov/test_common.go | 4 +- x/ibc/app_test.go | 2 +- x/ibc/client/cli/ibctx.go | 4 +- x/ibc/client/cli/relay.go | 2 +- x/ibc/client/rest/transfer.go | 4 +- x/ibc/ibc_test.go | 6 +- x/ibc/types.go | 14 +- x/ibc/types_test.go | 10 +- x/slashing/app_test.go | 11 +- x/slashing/client/cli/query.go | 2 +- x/slashing/handler.go | 2 +- x/slashing/keeper.go | 4 +- x/slashing/keeper_test.go | 12 +- x/slashing/msg.go | 14 +- x/slashing/msg_test.go | 2 +- x/slashing/signing_info.go | 12 +- x/slashing/signing_info_test.go | 14 +- x/slashing/test_common.go | 6 +- x/slashing/tick_test.go | 2 +- x/stake/app_test.go | 27 ++- x/stake/client/cli/query.go | 4 +- x/stake/client/cli/tx.go | 2 +- x/stake/client/rest/query.go | 22 +- x/stake/client/rest/tx.go | 14 +- x/stake/handler_test.go | 6 +- x/stake/keeper/delegation.go | 30 ++- x/stake/keeper/key.go | 40 ++-- x/stake/keeper/sdk_types.go | 6 +- x/stake/keeper/test_common.go | 12 +- x/stake/keeper/validator.go | 4 +- x/stake/types/delegation.go | 75 ++----- x/stake/types/msg.go | 138 ++++++------ x/stake/types/msg_test.go | 28 +-- x/stake/types/test_utils.go | 8 +- x/stake/types/validator.go | 10 +- 106 files changed, 982 insertions(+), 836 deletions(-) delete mode 100644 types/account_test.go create mode 100644 x/auth/mock/auth_app_test.go create mode 100644 x/auth/mock/simulate_block.go diff --git a/baseapp/baseapp_test.go b/baseapp/baseapp_test.go index eacc673503..66695bbf39 100644 --- a/baseapp/baseapp_test.go +++ b/baseapp/baseapp_test.go @@ -325,7 +325,7 @@ type msgCounter2 struct { // Implements Msg func (msg msgCounter2) Type() string { return typeMsgCounter2 } func (msg msgCounter2) GetSignBytes() []byte { return nil } -func (msg msgCounter2) GetSigners() []sdk.Address { return nil } +func (msg msgCounter2) GetSigners() []sdk.AccAddress { return nil } func (msg msgCounter2) ValidateBasic() sdk.Error { if msg.Counter >= 0 { return nil diff --git a/client/context/helpers.go b/client/context/helpers.go index f7845f696e..00ff8a81c7 100644 --- a/client/context/helpers.go +++ b/client/context/helpers.go @@ -109,7 +109,7 @@ func (ctx CoreContext) queryStore(key cmn.HexBytes, storeName, endPath string) ( } // Get the from address from the name flag -func (ctx CoreContext) GetFromAddress() (from sdk.Address, err error) { +func (ctx CoreContext) GetFromAddress() (from sdk.AccAddress, err error) { keybase, err := keys.GetKeyBase() if err != nil { @@ -126,7 +126,7 @@ func (ctx CoreContext) GetFromAddress() (from sdk.Address, err error) { return nil, errors.Errorf("no key for: %s", name) } - return sdk.Address(info.GetPubKey().Address()), nil + return sdk.AccAddress(info.GetPubKey().Address()), nil } // sign and build the transaction from the msg diff --git a/client/keys/add.go b/client/keys/add.go index 404934d5fe..d21f106380 100644 --- a/client/keys/add.go +++ b/client/keys/add.go @@ -163,8 +163,8 @@ type NewKeyBody struct { // new key response REST body type NewKeyResponse struct { - Address sdk.Address `json:"address"` - Mnemonic string `json:"mnemonic"` + Address sdk.AccAddress `json:"address"` + Mnemonic string `json:"mnemonic"` } // add new key REST handler @@ -215,7 +215,7 @@ func AddNewKeyRequestHandler(w http.ResponseWriter, r *http.Request) { w.Write([]byte(err.Error())) return } - address := sdk.Address(info.GetPubKey().Address().Bytes()) + address := sdk.AccAddress(info.GetPubKey().Address().Bytes()) bz, err := json.Marshal(NewKeyResponse{ Address: address, Mnemonic: mnemonic, diff --git a/client/keys/utils.go b/client/keys/utils.go index 76ac591ef7..5462597bac 100644 --- a/client/keys/utils.go +++ b/client/keys/utils.go @@ -48,11 +48,11 @@ func SetKeyBase(kb keys.Keybase) { // used for outputting keys.Info over REST type KeyOutput struct { - Name string `json:"name"` - Type string `json:"type"` - Address sdk.Address `json:"address"` - PubKey string `json:"pub_key"` - Seed string `json:"seed,omitempty"` + Name string `json:"name"` + Type string `json:"type"` + Address sdk.AccAddress `json:"address"` + PubKey string `json:"pub_key"` + Seed string `json:"seed,omitempty"` } // create a list of KeyOutput in bech32 format @@ -70,7 +70,7 @@ func Bech32KeysOutput(infos []keys.Info) ([]KeyOutput, error) { // create a KeyOutput in bech32 format func Bech32KeyOutput(info keys.Info) (KeyOutput, error) { - account := sdk.Address(info.GetPubKey().Address().Bytes()) + account := sdk.AccAddress(info.GetPubKey().Address().Bytes()) bechPubKey, err := sdk.Bech32ifyAccPub(info.GetPubKey()) if err != nil { return KeyOutput{}, err diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go index de8269c10e..e09e274023 100644 --- a/client/lcd/lcd_test.go +++ b/client/lcd/lcd_test.go @@ -36,7 +36,7 @@ func init() { func TestKeys(t *testing.T) { name, password := "test", "1234567890" addr, seed := CreateAddr(t, "test", password, GetKB(t)) - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() // get seed @@ -109,7 +109,7 @@ func TestKeys(t *testing.T) { } func TestVersion(t *testing.T) { - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}) defer cleanup() // node info @@ -132,7 +132,7 @@ func TestVersion(t *testing.T) { } func TestNodeStatus(t *testing.T) { - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}) defer cleanup() // node info @@ -154,7 +154,7 @@ func TestNodeStatus(t *testing.T) { } func TestBlock(t *testing.T) { - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}) defer cleanup() var resultBlock ctypes.ResultBlock @@ -184,7 +184,7 @@ func TestBlock(t *testing.T) { } func TestValidators(t *testing.T) { - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}) defer cleanup() var resultVals rpc.ResultValidatorsOutput @@ -219,12 +219,12 @@ func TestValidators(t *testing.T) { func TestCoinSend(t *testing.T) { name, password := "test", "1234567890" addr, seed := CreateAddr(t, "test", password, GetKB(t)) - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() bz, err := hex.DecodeString("8FA6AB57AD6870F6B5B2E57735F38F2F30E73CB6") require.NoError(t, err) - someFakeAddr := sdk.Address(bz) + someFakeAddr := sdk.AccAddress(bz) // query empty res, body := Request(t, port, "GET", fmt.Sprintf("/accounts/%s", someFakeAddr), nil) @@ -261,7 +261,7 @@ func TestCoinSend(t *testing.T) { func TestIBCTransfer(t *testing.T) { name, password := "test", "1234567890" addr, seed := CreateAddr(t, "test", password, GetKB(t)) - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() acc := getAccount(t, port, addr) @@ -290,7 +290,7 @@ func TestIBCTransfer(t *testing.T) { func TestTxs(t *testing.T) { name, password := "test", "1234567890" addr, seed := CreateAddr(t, "test", password, GetKB(t)) - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() // query wrong @@ -353,7 +353,7 @@ func TestTxs(t *testing.T) { } func TestValidatorsQuery(t *testing.T) { - cleanup, pks, port := InitializeTestLCD(t, 2, []sdk.Address{}) + cleanup, pks, port := InitializeTestLCD(t, 2, []sdk.AccAddress{}) defer cleanup() require.Equal(t, 2, len(pks)) @@ -377,10 +377,10 @@ func TestValidatorsQuery(t *testing.T) { func TestBonding(t *testing.T) { name, password, denom := "test", "1234567890", "steak" addr, seed := CreateAddr(t, "test", password, GetKB(t)) - cleanup, pks, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, pks, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() - validator1Owner := sdk.Address(pks[0].Address()) + validator1Owner := sdk.AccAddress(pks[0].Address()) // create bond TX resultTx := doDelegate(t, port, seed, name, password, addr, validator1Owner) @@ -427,7 +427,7 @@ func TestBonding(t *testing.T) { func TestSubmitProposal(t *testing.T) { name, password := "test", "1234567890" addr, seed := CreateAddr(t, "test", password, GetKB(t)) - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() // create SubmitProposal TX @@ -449,7 +449,7 @@ func TestSubmitProposal(t *testing.T) { func TestDeposit(t *testing.T) { name, password := "test", "1234567890" addr, seed := CreateAddr(t, "test", password, GetKB(t)) - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() // create SubmitProposal TX @@ -483,7 +483,7 @@ func TestDeposit(t *testing.T) { func TestVote(t *testing.T) { name, password := "test", "1234567890" addr, seed := CreateAddr(t, "test", password, GetKB(t)) - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() // create SubmitProposal TX @@ -521,13 +521,13 @@ func TestVote(t *testing.T) { func TestUnrevoke(t *testing.T) { _, password := "test", "1234567890" addr, _ := CreateAddr(t, "test", password, GetKB(t)) - cleanup, pks, port := InitializeTestLCD(t, 1, []sdk.Address{addr}) + cleanup, pks, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}) defer cleanup() // XXX: any less than this and it fails tests.WaitForHeight(3, port) - signingInfo := getSigningInfo(t, port, pks[0].Address()) + signingInfo := getSigningInfo(t, port, sdk.ValAddress(pks[0].Address())) tests.WaitForHeight(4, port) require.Equal(t, true, signingInfo.IndexOffset > 0) require.Equal(t, int64(0), signingInfo.JailedUntil) @@ -539,7 +539,7 @@ func TestProposalsQuery(t *testing.T) { name2, password2 := "test2", "1234567890" addr, seed := CreateAddr(t, "test", password1, GetKB(t)) addr2, seed2 := CreateAddr(t, "test2", password2, GetKB(t)) - cleanup, _, port := InitializeTestLCD(t, 1, []sdk.Address{addr, addr2}) + cleanup, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr, addr2}) defer cleanup() // Addr1 proposes (and deposits) proposals #1 and #2 @@ -605,9 +605,8 @@ func TestProposalsQuery(t *testing.T) { //_____________________________________________________________________________ // get the account to get the sequence -func getAccount(t *testing.T, port string, addr sdk.Address) auth.Account { - addrBech32 := sdk.MustBech32ifyAcc(addr) - res, body := Request(t, port, "GET", "/accounts/"+addrBech32, nil) +func getAccount(t *testing.T, port string, addr sdk.AccAddress) auth.Account { + res, body := Request(t, port, "GET", fmt.Sprintf("/accounts/%s", addr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) var acc auth.Account err := cdc.UnmarshalJSON([]byte(body), &acc) @@ -615,14 +614,13 @@ func getAccount(t *testing.T, port string, addr sdk.Address) auth.Account { return acc } -func doSend(t *testing.T, port, seed, name, password string, addr sdk.Address) (receiveAddr sdk.Address, resultTx ctypes.ResultBroadcastTxCommit) { +func doSend(t *testing.T, port, seed, name, password string, addr sdk.AccAddress) (receiveAddr sdk.AccAddress, resultTx ctypes.ResultBroadcastTxCommit) { // create receive address kb := client.MockKeyBase() receiveInfo, _, err := kb.CreateMnemonic("receive_address", cryptoKeys.English, "1234567890", cryptoKeys.SigningAlgo("secp256k1")) require.Nil(t, err) - receiveAddr = receiveInfo.GetPubKey().Address() - receiveAddrBech := sdk.MustBech32ifyAcc(receiveAddr) + receiveAddr = sdk.AccAddress(receiveInfo.GetPubKey().Address()) acc := getAccount(t, port, addr) accnum := acc.GetAccountNumber() @@ -644,7 +642,7 @@ func doSend(t *testing.T, port, seed, name, password string, addr sdk.Address) ( "amount":[%s], "chain_id":"%s" }`, name, password, accnum, sequence, coinbz, chainID)) - res, body := Request(t, port, "POST", "/accounts/"+receiveAddrBech+"/send", jsonStr) + res, body := Request(t, port, "POST", fmt.Sprintf("/accounts/%s/send", receiveAddr), jsonStr) require.Equal(t, http.StatusOK, res.StatusCode, body) err = cdc.UnmarshalJSON([]byte(body), &resultTx) @@ -653,13 +651,12 @@ func doSend(t *testing.T, port, seed, name, password string, addr sdk.Address) ( return receiveAddr, resultTx } -func doIBCTransfer(t *testing.T, port, seed, name, password string, addr sdk.Address) (resultTx ctypes.ResultBroadcastTxCommit) { +func doIBCTransfer(t *testing.T, port, seed, name, password string, addr sdk.AccAddress) (resultTx ctypes.ResultBroadcastTxCommit) { // create receive address kb := client.MockKeyBase() receiveInfo, _, err := kb.CreateMnemonic("receive_address", cryptoKeys.English, "1234567890", cryptoKeys.SigningAlgo("secp256k1")) require.Nil(t, err) - receiveAddr := receiveInfo.GetPubKey().Address() - receiveAddrBech := sdk.MustBech32ifyAcc(receiveAddr) + receiveAddr := sdk.AccAddress(receiveInfo.GetPubKey().Address()) chainID := viper.GetString(client.FlagChainID) @@ -683,7 +680,7 @@ func doIBCTransfer(t *testing.T, port, seed, name, password string, addr sdk.Add } ] }`, name, password, accnum, sequence, chainID, "steak")) - res, body := Request(t, port, "POST", "/ibc/testchain/"+receiveAddrBech+"/send", jsonStr) + res, body := Request(t, port, "POST", fmt.Sprintf("/ibc/testchain/%s/send", receiveAddr), jsonStr) require.Equal(t, http.StatusOK, res.StatusCode, body) err = cdc.UnmarshalJSON([]byte(body), &resultTx) @@ -692,9 +689,8 @@ func doIBCTransfer(t *testing.T, port, seed, name, password string, addr sdk.Add return resultTx } -func getSigningInfo(t *testing.T, port string, validatorAddr sdk.Address) slashing.ValidatorSigningInfo { - validatorAddrBech := sdk.MustBech32ifyVal(validatorAddr) - res, body := Request(t, port, "GET", "/slashing/signing_info/"+validatorAddrBech, nil) +func getSigningInfo(t *testing.T, port string, validatorAddr sdk.ValAddress) slashing.ValidatorSigningInfo { + res, body := Request(t, port, "GET", fmt.Sprintf("/slashing/signing_info/%s", validatorAddr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) var signingInfo slashing.ValidatorSigningInfo err := cdc.UnmarshalJSON([]byte(body), &signingInfo) @@ -702,13 +698,10 @@ func getSigningInfo(t *testing.T, port string, validatorAddr sdk.Address) slashi return signingInfo } -func getDelegation(t *testing.T, port string, delegatorAddr, validatorAddr sdk.Address) stake.Delegation { - - delegatorAddrBech := sdk.MustBech32ifyAcc(delegatorAddr) - validatorAddrBech := sdk.MustBech32ifyVal(validatorAddr) +func getDelegation(t *testing.T, port string, delegatorAddr, validatorAddr sdk.AccAddress) stake.Delegation { // get the account to get the sequence - res, body := Request(t, port, "GET", "/stake/"+delegatorAddrBech+"/delegation/"+validatorAddrBech, nil) + res, body := Request(t, port, "GET", fmt.Sprintf("/stake/%s/delegation/%s", delegatorAddr, validatorAddr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) var bond stake.Delegation err := cdc.UnmarshalJSON([]byte(body), &bond) @@ -716,15 +709,12 @@ func getDelegation(t *testing.T, port string, delegatorAddr, validatorAddr sdk.A return bond } -func doDelegate(t *testing.T, port, seed, name, password string, delegatorAddr, validatorAddr sdk.Address) (resultTx ctypes.ResultBroadcastTxCommit) { +func doDelegate(t *testing.T, port, seed, name, password string, delegatorAddr, validatorAddr sdk.AccAddress) (resultTx ctypes.ResultBroadcastTxCommit) { // get the account to get the sequence acc := getAccount(t, port, delegatorAddr) accnum := acc.GetAccountNumber() sequence := acc.GetSequence() - delegatorAddrBech := sdk.MustBech32ifyAcc(delegatorAddr) - validatorAddrBech := sdk.MustBech32ifyVal(validatorAddr) - chainID := viper.GetString(client.FlagChainID) // send @@ -746,7 +736,7 @@ func doDelegate(t *testing.T, port, seed, name, password string, delegatorAddr, "complete_unbondings": [], "begin_redelegates": [], "complete_redelegates": [] - }`, name, password, accnum, sequence, chainID, delegatorAddrBech, validatorAddrBech, "steak")) + }`, name, password, accnum, sequence, chainID, delegatorAddr, validatorAddr, "steak")) res, body := Request(t, port, "POST", "/stake/delegations", jsonStr) require.Equal(t, http.StatusOK, res.StatusCode, body) @@ -758,16 +748,13 @@ func doDelegate(t *testing.T, port, seed, name, password string, delegatorAddr, } func doBeginUnbonding(t *testing.T, port, seed, name, password string, - delegatorAddr, validatorAddr sdk.Address) (resultTx ctypes.ResultBroadcastTxCommit) { + delegatorAddr, validatorAddr sdk.AccAddress) (resultTx ctypes.ResultBroadcastTxCommit) { // get the account to get the sequence acc := getAccount(t, port, delegatorAddr) accnum := acc.GetAccountNumber() sequence := acc.GetSequence() - delegatorAddrBech := sdk.MustBech32ifyAcc(delegatorAddr) - validatorAddrBech := sdk.MustBech32ifyVal(validatorAddr) - chainID := viper.GetString(client.FlagChainID) // send @@ -789,7 +776,7 @@ func doBeginUnbonding(t *testing.T, port, seed, name, password string, "complete_unbondings": [], "begin_redelegates": [], "complete_redelegates": [] - }`, name, password, accnum, sequence, chainID, delegatorAddrBech, validatorAddrBech)) + }`, name, password, accnum, sequence, chainID, delegatorAddr, validatorAddr)) res, body := Request(t, port, "POST", "/stake/delegations", jsonStr) require.Equal(t, http.StatusOK, res.StatusCode, body) @@ -801,17 +788,13 @@ func doBeginUnbonding(t *testing.T, port, seed, name, password string, } func doBeginRedelegation(t *testing.T, port, seed, name, password string, - delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.Address) (resultTx ctypes.ResultBroadcastTxCommit) { + delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) (resultTx ctypes.ResultBroadcastTxCommit) { // get the account to get the sequence acc := getAccount(t, port, delegatorAddr) accnum := acc.GetAccountNumber() sequence := acc.GetSequence() - delegatorAddrBech := sdk.MustBech32ifyAcc(delegatorAddr) - validatorSrcAddrBech := sdk.MustBech32ifyVal(validatorSrcAddr) - validatorDstAddrBech := sdk.MustBech32ifyVal(validatorDstAddr) - chainID := viper.GetString(client.FlagChainID) // send @@ -834,7 +817,7 @@ func doBeginRedelegation(t *testing.T, port, seed, name, password string, } ], "complete_redelegates": [] - }`, name, password, accnum, sequence, chainID, delegatorAddrBech, validatorSrcAddrBech, validatorDstAddrBech)) + }`, name, password, accnum, sequence, chainID, delegatorAddr, validatorSrcAddr, validatorDstAddr)) res, body := Request(t, port, "POST", "/stake/delegations", jsonStr) require.Equal(t, http.StatusOK, res.StatusCode, body) @@ -864,9 +847,8 @@ func getProposal(t *testing.T, port string, proposalID int64) gov.ProposalRest { return proposal } -func getDeposit(t *testing.T, port string, proposalID int64, depositerAddr sdk.Address) gov.DepositRest { - bechDepositerAddr := sdk.MustBech32ifyAcc(depositerAddr) - res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals/%d/deposits/%s", proposalID, bechDepositerAddr), nil) +func getDeposit(t *testing.T, port string, proposalID int64, depositerAddr sdk.AccAddress) gov.DepositRest { + res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals/%d/deposits/%s", proposalID, depositerAddr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) var deposit gov.DepositRest err := cdc.UnmarshalJSON([]byte(body), &deposit) @@ -874,9 +856,8 @@ func getDeposit(t *testing.T, port string, proposalID int64, depositerAddr sdk.A return deposit } -func getVote(t *testing.T, port string, proposalID int64, voterAddr sdk.Address) gov.VoteRest { - bechVoterAddr := sdk.MustBech32ifyAcc(voterAddr) - res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals/%d/votes/%s", proposalID, bechVoterAddr), nil) +func getVote(t *testing.T, port string, proposalID int64, voterAddr sdk.AccAddress) gov.VoteRest { + res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals/%d/votes/%s", proposalID, voterAddr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) var vote gov.VoteRest err := cdc.UnmarshalJSON([]byte(body), &vote) @@ -894,10 +875,8 @@ func getProposalsAll(t *testing.T, port string) []gov.ProposalRest { return proposals } -func getProposalsFilterDepositer(t *testing.T, port string, depositerAddr sdk.Address) []gov.ProposalRest { - bechDepositerAddr := sdk.MustBech32ifyAcc(depositerAddr) - - res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals?depositer=%s", bechDepositerAddr), nil) +func getProposalsFilterDepositer(t *testing.T, port string, depositerAddr sdk.AccAddress) []gov.ProposalRest { + res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals?depositer=%s", depositerAddr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) var proposals []gov.ProposalRest @@ -906,10 +885,8 @@ func getProposalsFilterDepositer(t *testing.T, port string, depositerAddr sdk.Ad return proposals } -func getProposalsFilterVoter(t *testing.T, port string, voterAddr sdk.Address) []gov.ProposalRest { - bechVoterAddr := sdk.MustBech32ifyAcc(voterAddr) - - res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals?voter=%s", bechVoterAddr), nil) +func getProposalsFilterVoter(t *testing.T, port string, voterAddr sdk.AccAddress) []gov.ProposalRest { + res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals?voter=%s", voterAddr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) var proposals []gov.ProposalRest @@ -918,11 +895,8 @@ func getProposalsFilterVoter(t *testing.T, port string, voterAddr sdk.Address) [ return proposals } -func getProposalsFilterVoterDepositer(t *testing.T, port string, voterAddr sdk.Address, depositerAddr sdk.Address) []gov.ProposalRest { - bechVoterAddr := sdk.MustBech32ifyAcc(voterAddr) - bechDepositerAddr := sdk.MustBech32ifyAcc(depositerAddr) - - res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals?depositer=%s&voter=%s", bechDepositerAddr, bechVoterAddr), nil) +func getProposalsFilterVoterDepositer(t *testing.T, port string, voterAddr, depositerAddr sdk.AccAddress) []gov.ProposalRest { + res, body := Request(t, port, "GET", fmt.Sprintf("/gov/proposals?depositer=%s&voter=%s", depositerAddr, voterAddr), nil) require.Equal(t, http.StatusOK, res.StatusCode, body) var proposals []gov.ProposalRest @@ -931,7 +905,7 @@ func getProposalsFilterVoterDepositer(t *testing.T, port string, voterAddr sdk.A return proposals } -func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerAddr sdk.Address) (resultTx ctypes.ResultBroadcastTxCommit) { +func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress) (resultTx ctypes.ResultBroadcastTxCommit) { // get the account to get the sequence acc := getAccount(t, port, proposerAddr) accnum := acc.GetAccountNumber() @@ -939,8 +913,6 @@ func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerA chainID := viper.GetString(client.FlagChainID) - bechProposerAddr := sdk.MustBech32ifyAcc(proposerAddr) - // submitproposal jsonStr := []byte(fmt.Sprintf(`{ "title": "Test", @@ -956,7 +928,7 @@ func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerA "sequence":"%d", "gas":"100000" } - }`, bechProposerAddr, name, password, chainID, accnum, sequence)) + }`, proposerAddr, name, password, chainID, accnum, sequence)) res, body := Request(t, port, "POST", "/gov/proposals", jsonStr) require.Equal(t, http.StatusOK, res.StatusCode, body) @@ -967,7 +939,7 @@ func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerA return results } -func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk.Address, proposalID int64) (resultTx ctypes.ResultBroadcastTxCommit) { +func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress, proposalID int64) (resultTx ctypes.ResultBroadcastTxCommit) { // get the account to get the sequence acc := getAccount(t, port, proposerAddr) accnum := acc.GetAccountNumber() @@ -975,8 +947,6 @@ func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk chainID := viper.GetString(client.FlagChainID) - bechProposerAddr := sdk.MustBech32ifyAcc(proposerAddr) - // deposit on proposal jsonStr := []byte(fmt.Sprintf(`{ "depositer": "%s", @@ -989,7 +959,7 @@ func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk "sequence": "%d", "gas":"100000" } - }`, bechProposerAddr, name, password, chainID, accnum, sequence)) + }`, proposerAddr, name, password, chainID, accnum, sequence)) res, body := Request(t, port, "POST", fmt.Sprintf("/gov/proposals/%d/deposits", proposalID), jsonStr) require.Equal(t, http.StatusOK, res.StatusCode, body) @@ -1000,7 +970,7 @@ func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk return results } -func doVote(t *testing.T, port, seed, name, password string, proposerAddr sdk.Address, proposalID int64) (resultTx ctypes.ResultBroadcastTxCommit) { +func doVote(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress, proposalID int64) (resultTx ctypes.ResultBroadcastTxCommit) { // get the account to get the sequence acc := getAccount(t, port, proposerAddr) accnum := acc.GetAccountNumber() @@ -1008,8 +978,6 @@ func doVote(t *testing.T, port, seed, name, password string, proposerAddr sdk.Ad chainID := viper.GetString(client.FlagChainID) - bechProposerAddr := sdk.MustBech32ifyAcc(proposerAddr) - // vote on proposal jsonStr := []byte(fmt.Sprintf(`{ "voter": "%s", @@ -1022,7 +990,7 @@ func doVote(t *testing.T, port, seed, name, password string, proposerAddr sdk.Ad "sequence": "%d", "gas":"100000" } - }`, bechProposerAddr, name, password, chainID, accnum, sequence)) + }`, proposerAddr, name, password, chainID, accnum, sequence)) res, body := Request(t, port, "POST", fmt.Sprintf("/gov/proposals/%d/votes", proposalID), jsonStr) fmt.Println(res) require.Equal(t, http.StatusOK, res.StatusCode, body) diff --git a/client/lcd/test_helpers.go b/client/lcd/test_helpers.go index 9116211bc8..5967b2319f 100644 --- a/client/lcd/test_helpers.go +++ b/client/lcd/test_helpers.go @@ -80,19 +80,19 @@ func GetKB(t *testing.T) crkeys.Keybase { } // add an address to the store return name and password -func CreateAddr(t *testing.T, name, password string, kb crkeys.Keybase) (addr sdk.Address, seed string) { +func CreateAddr(t *testing.T, name, password string, kb crkeys.Keybase) (addr sdk.AccAddress, seed string) { var info crkeys.Info var err error info, seed, err = kb.CreateMnemonic(name, crkeys.English, password, crkeys.Secp256k1) require.NoError(t, err) - addr = sdk.Address(info.GetPubKey().Address()) + addr = sdk.AccAddress(info.GetPubKey().Address()) return } // strt TM and the LCD in process, listening on their respective sockets // nValidators = number of validators // initAddrs = accounts to initialize with some steaks -func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.Address) (cleanup func(), validatorsPKs []crypto.PubKey, port string) { +func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress) (cleanup func(), validatorsPKs []crypto.PubKey, port string) { config := GetConfig() config.Consensus.TimeoutCommit = 100 @@ -132,7 +132,7 @@ func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.Address) ( for _, gdValidator := range genDoc.Validators { pk := gdValidator.PubKey validatorsPKs = append(validatorsPKs, pk) // append keys for output - appGenTx, _, _, err := gapp.GaiaAppGenTxNF(cdc, pk, sdk.Address(pk.Address()), "test_val1") + appGenTx, _, _, err := gapp.GaiaAppGenTxNF(cdc, pk, sdk.AccAddress(pk.Address()), "test_val1") require.NoError(t, err) appGenTxs = append(appGenTxs, appGenTx) } diff --git a/client/rpc/validators.go b/client/rpc/validators.go index d88fb73173..b8a6c4cc20 100644 --- a/client/rpc/validators.go +++ b/client/rpc/validators.go @@ -32,10 +32,10 @@ func ValidatorCommand() *cobra.Command { // Validator output in bech32 format type ValidatorOutput struct { - Address string `json:"address"` // in bech32 - PubKey string `json:"pub_key"` // in bech32 - Accum int64 `json:"accum"` - VotingPower int64 `json:"voting_power"` + Address sdk.ValAddress `json:"address"` // in bech32 + PubKey string `json:"pub_key"` // in bech32 + Accum int64 `json:"accum"` + VotingPower int64 `json:"voting_power"` } // Validators at a certain height output in bech32 format @@ -45,17 +45,13 @@ type ResultValidatorsOutput struct { } func bech32ValidatorOutput(validator *tmtypes.Validator) (ValidatorOutput, error) { - bechAddress, err := sdk.Bech32ifyVal(validator.Address) - if err != nil { - return ValidatorOutput{}, err - } bechValPubkey, err := sdk.Bech32ifyValPub(validator.PubKey) if err != nil { return ValidatorOutput{}, err } return ValidatorOutput{ - Address: bechAddress, + Address: sdk.ValAddress(validator.Address), PubKey: bechValPubkey, Accum: validator.Accum, VotingPower: validator.VotingPower, diff --git a/client/tx/search.go b/client/tx/search.go index 2e164700db..76c394f928 100644 --- a/client/tx/search.go +++ b/client/tx/search.go @@ -124,7 +124,7 @@ func SearchTxRequestHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.Han return } - tag = strings.TrimRight(key, "_bech32") + "='" + sdk.Address(bz).String() + "'" + tag = strings.TrimRight(key, "_bech32") + "='" + sdk.AccAddress(bz).String() + "'" } txs, err := searchTxs(ctx, cdc, []string{tag}) diff --git a/cmd/gaia/app/genesis.go b/cmd/gaia/app/genesis.go index eb4c259514..baa363a448 100644 --- a/cmd/gaia/app/genesis.go +++ b/cmd/gaia/app/genesis.go @@ -30,8 +30,8 @@ type GenesisState struct { // GenesisAccount doesn't need pubkey or sequence type GenesisAccount struct { - Address string `json:"address"` - Coins sdk.Coins `json:"coins"` + Address sdk.AccAddress `json:"address"` + Coins sdk.Coins `json:"coins"` } func NewGenesisAccount(acc *auth.BaseAccount) GenesisAccount { @@ -76,9 +76,9 @@ func GaiaAppInit() server.AppInit { // simple genesis tx type GaiaGenTx struct { - Name string `json:"name"` - Address string `json:"address"` - PubKey string `json:"pub_key"` + Name string `json:"name"` + Address sdk.AccAddress `json:"address"` + PubKey string `json:"pub_key"` } // Generate a gaia genesis transaction with flags @@ -88,7 +88,7 @@ func GaiaAppGenTx(cdc *wire.Codec, pk crypto.PubKey, genTxConfig config.GenTx) ( return nil, nil, tmtypes.GenesisValidator{}, errors.New("Must specify --name (validator moniker)") } - var addr string + var addr sdk.AccAddress var secret string addr, secret, err = server.GenerateSaveCoinKey(genTxConfig.CliRoot, genTxConfig.Name, "1234567890", genTxConfig.Overwrite) if err != nil { @@ -108,7 +108,7 @@ func GaiaAppGenTx(cdc *wire.Codec, pk crypto.PubKey, genTxConfig config.GenTx) ( } // Generate a gaia genesis transaction without flags -func GaiaAppGenTxNF(cdc *wire.Codec, pk crypto.PubKey, addr string, name string) ( +func GaiaAppGenTxNF(cdc *wire.Codec, pk crypto.PubKey, addr sdk.AccAddress, name string) ( appGenTx, cliPrint json.RawMessage, validator tmtypes.GenesisValidator, err error) { var bz []byte diff --git a/cmd/gaia/app/genesis_test.go b/cmd/gaia/app/genesis_test.go index 7f0da29901..d0e080376b 100644 --- a/cmd/gaia/app/genesis_test.go +++ b/cmd/gaia/app/genesis_test.go @@ -11,7 +11,7 @@ import ( func TestToAccount(t *testing.T) { priv := crypto.GenPrivKeyEd25519() - addr := sdk.Address(priv.PubKey().Address()) + addr := sdk.AccAddress(priv.PubKey().Address()) authAcc := auth.NewBaseAccountWithAddress(addr) genAcc := NewGenesisAccount(&authAcc) require.Equal(t, authAcc, *genAcc.ToAccount()) diff --git a/cmd/gaia/cli_test/cli_test.go b/cmd/gaia/cli_test/cli_test.go index 18e967bd3f..0f82b38ee2 100644 --- a/cmd/gaia/cli_test/cli_test.go +++ b/cmd/gaia/cli_test/cli_test.go @@ -52,37 +52,35 @@ func TestGaiaCLISend(t *testing.T) { tests.WaitForNextHeightTM(port) fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome)) - fooCech := sdk.MustBech32ifyAcc(fooAddr) barAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome)) - barCech := sdk.MustBech32ifyAcc(barAddr) - - fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags)) + + fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64()) - executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --from=foo", flags, barCech), pass) + executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo", flags, barAddr), pass) tests.WaitForNextHeightTM(port) - barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags)) + barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags)) require.Equal(t, int64(10), barAcc.GetCoins().AmountOf("steak").Int64()) - fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags)) + fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64()) // test autosequencing - executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --from=foo", flags, barCech), pass) + executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo", flags, barAddr), pass) tests.WaitForNextHeightTM(port) - barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags)) + barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags)) require.Equal(t, int64(20), barAcc.GetCoins().AmountOf("steak").Int64()) - fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags)) + fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(30), fooAcc.GetCoins().AmountOf("steak").Int64()) // test memo - executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --from=foo --memo 'testmemo'", flags, barCech), pass) + executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo --memo 'testmemo'", flags, barAddr), pass) tests.WaitForNextHeightTM(port) - barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags)) + barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags)) require.Equal(t, int64(30), barAcc.GetCoins().AmountOf("steak").Int64()) - fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags)) + fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(20), fooAcc.GetCoins().AmountOf("steak").Int64()) } @@ -106,23 +104,21 @@ func TestGaiaCLICreateValidator(t *testing.T) { tests.WaitForNextHeightTM(port) fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome)) - fooCech := sdk.MustBech32ifyAcc(fooAddr) barAddr, barPubKey := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome)) - barCech := sdk.MustBech32ifyAcc(barAddr) barCeshPubKey := sdk.MustBech32ifyValPub(barPubKey) - executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --from=foo", flags, barCech), pass) + executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --from=foo", flags, barAddr), pass) tests.WaitForNextHeightTM(port) - barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags)) + barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags)) require.Equal(t, int64(10), barAcc.GetCoins().AmountOf("steak").Int64()) - fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags)) + fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf("steak").Int64()) // create validator cvStr := fmt.Sprintf("gaiacli stake create-validator %v", flags) cvStr += fmt.Sprintf(" --from=%v", "bar") - cvStr += fmt.Sprintf(" --address-validator=%v", barCech) + cvStr += fmt.Sprintf(" --address-validator=%v", barAddr) cvStr += fmt.Sprintf(" --pubkey=%v", barCeshPubKey) cvStr += fmt.Sprintf(" --amount=%v", "2steak") cvStr += fmt.Sprintf(" --moniker=%v", "bar-vally") @@ -130,18 +126,18 @@ func TestGaiaCLICreateValidator(t *testing.T) { executeWrite(t, cvStr, pass) tests.WaitForNextHeightTM(port) - barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags)) + barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags)) require.Equal(t, int64(8), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc) - validator := executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %v --output=json %v", barCech, flags)) + validator := executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", barAddr, flags)) require.Equal(t, validator.Owner, barAddr) require.Equal(t, "2/1", validator.PoolShares.Amount.String()) // unbond a single share unbondStr := fmt.Sprintf("gaiacli stake unbond begin %v", flags) unbondStr += fmt.Sprintf(" --from=%v", "bar") - unbondStr += fmt.Sprintf(" --address-validator=%v", barCech) - unbondStr += fmt.Sprintf(" --address-delegator=%v", barCech) + unbondStr += fmt.Sprintf(" --address-validator=%s", barAddr) + unbondStr += fmt.Sprintf(" --address-delegator=%s", barAddr) unbondStr += fmt.Sprintf(" --shares-amount=%v", "1") success := executeWrite(t, unbondStr, pass) @@ -152,7 +148,7 @@ func TestGaiaCLICreateValidator(t *testing.T) { barAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", barCech, flags)) require.Equal(t, int64(9), barAcc.GetCoins().AmountOf("steak").Int64(), "%v", barAcc) */ - validator = executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %v --output=json %v", barCech, flags)) + validator = executeGetValidator(t, fmt.Sprintf("gaiacli stake validator %s --output=json %v", barAddr, flags)) require.Equal(t, "1/1", validator.PoolShares.Amount.String()) } @@ -176,34 +172,33 @@ func TestGaiaCLISubmitProposal(t *testing.T) { tests.WaitForNextHeightTM(port) fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome)) - fooCech := sdk.MustBech32ifyAcc(fooAddr) - fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags)) + fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64()) - executeWrite(t, fmt.Sprintf("gaiacli gov submit-proposal %v --proposer=%v --deposit=5steak --type=Text --title=Test --description=test --from=foo", flags, fooCech), pass) + executeWrite(t, fmt.Sprintf("gaiacli gov submit-proposal %v --proposer=%s --deposit=5steak --type=Text --title=Test --description=test --from=foo", flags, fooAddr), pass) tests.WaitForNextHeightTM(port) - fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags)) + fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(45), fooAcc.GetCoins().AmountOf("steak").Int64()) proposal1 := executeGetProposal(t, fmt.Sprintf("gaiacli gov query-proposal --proposalID=1 --output=json %v", flags)) require.Equal(t, int64(1), proposal1.ProposalID) require.Equal(t, gov.StatusToString(gov.StatusDepositPeriod), proposal1.Status) - executeWrite(t, fmt.Sprintf("gaiacli gov deposit %v --depositer=%v --deposit=10steak --proposalID=1 --from=foo", flags, fooCech), pass) + executeWrite(t, fmt.Sprintf("gaiacli gov deposit %v --depositer=%s --deposit=10steak --proposalID=1 --from=foo", flags, fooAddr), pass) tests.WaitForNextHeightTM(port) - fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %v %v", fooCech, flags)) + fooAcc = executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(35), fooAcc.GetCoins().AmountOf("steak").Int64()) proposal1 = executeGetProposal(t, fmt.Sprintf("gaiacli gov query-proposal --proposalID=1 --output=json %v", flags)) require.Equal(t, int64(1), proposal1.ProposalID) require.Equal(t, gov.StatusToString(gov.StatusVotingPeriod), proposal1.Status) - executeWrite(t, fmt.Sprintf("gaiacli gov vote %v --proposalID=1 --voter=%v --option=Yes --from=foo", flags, fooCech), pass) + executeWrite(t, fmt.Sprintf("gaiacli gov vote %v --proposalID=1 --voter=%s --option=Yes --from=foo", flags, fooAddr), pass) tests.WaitForNextHeightTM(port) - vote := executeGetVote(t, fmt.Sprintf("gaiacli gov query-vote --proposalID=1 --voter=%v --output=json %v", fooCech, flags)) + vote := executeGetVote(t, fmt.Sprintf("gaiacli gov query-vote --proposalID=1 --voter=%s --output=json %v", fooAddr, flags)) require.Equal(t, int64(1), vote.ProposalID) require.Equal(t, gov.VoteOptionToString(gov.OptionYes), vote.Option) } @@ -259,18 +254,15 @@ func executeInit(t *testing.T, cmdStr string) (chainID string) { return } -func executeGetAddrPK(t *testing.T, cmdStr string) (sdk.Address, crypto.PubKey) { +func executeGetAddrPK(t *testing.T, cmdStr string) (sdk.AccAddress, crypto.PubKey) { out := tests.ExecuteT(t, cmdStr) var ko keys.KeyOutput keys.UnmarshalJSON([]byte(out), &ko) - address, err := sdk.GetAccAddressBech32(ko.Address) - require.NoError(t, err) - pk, err := sdk.GetAccPubKeyBech32(ko.PubKey) require.NoError(t, err) - return address, pk + return ko.Address, pk } func executeGetAccount(t *testing.T, cmdStr string) auth.BaseAccount { diff --git a/cmd/gaia/cmd/gaiadebug/main.go b/cmd/gaia/cmd/gaiadebug/main.go index 7139ae5faa..f56a757a8a 100644 --- a/cmd/gaia/cmd/gaiadebug/main.go +++ b/cmd/gaia/cmd/gaiadebug/main.go @@ -151,7 +151,7 @@ func runAddrCmd(cmd *cobra.Command, args []string) error { } addrString := args[0] - var addr sdk.Address + var addr []byte // try hex, then bech32 var err error @@ -174,14 +174,9 @@ func runAddrCmd(cmd *cobra.Command, args []string) error { } } - accAddr, err := sdk.Bech32ifyAcc(addr) - if err != nil { - return err - } - valAddr, err := sdk.Bech32ifyVal(addr) - if err != nil { - return err - } + accAddr := sdk.AccAddress(addr) + valAddr := sdk.ValAddress(addr) + fmt.Println("Address:", addr) fmt.Println("Bech32 Acc:", accAddr) fmt.Println("Bech32 Val:", valAddr) diff --git a/docs/core/examples/app1.go b/docs/core/examples/app1.go index a9580fcc29..b208f75cf7 100644 --- a/docs/core/examples/app1.go +++ b/docs/core/examples/app1.go @@ -51,13 +51,13 @@ var _ sdk.Msg = MsgSend{} // MsgSend to send coins from Input to Output type MsgSend struct { - From sdk.Address `json:"from"` - To sdk.Address `json:"to"` - Amount sdk.Coins `json:"amount"` + From sdk.AccAddress `json:"from"` + To sdk.AccAddress `json:"to"` + Amount sdk.Coins `json:"amount"` } // NewMsgSend -func NewMsgSend(from, to sdk.Address, amt sdk.Coins) MsgSend { +func NewMsgSend(from, to sdk.AccAddress, amt sdk.Coins) MsgSend { return MsgSend{from, to, amt} } @@ -89,8 +89,8 @@ func (msg MsgSend) GetSignBytes() []byte { } // Implements Msg. Return the signer. -func (msg MsgSend) GetSigners() []sdk.Address { - return []sdk.Address{msg.From} +func (msg MsgSend) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.From} } // Returns the sdk.Tags for the message @@ -136,7 +136,7 @@ func handleMsgSend(key *sdk.KVStoreKey) sdk.Handler { } // Convenience Handlers -func handleFrom(store sdk.KVStore, from sdk.Address, amt sdk.Coins) sdk.Result { +func handleFrom(store sdk.KVStore, from sdk.AccAddress, amt sdk.Coins) sdk.Result { // Get sender account from the store. accBytes := store.Get(from) if accBytes == nil { @@ -174,7 +174,7 @@ func handleFrom(store sdk.KVStore, from sdk.Address, amt sdk.Coins) sdk.Result { return sdk.Result{} } -func handleTo(store sdk.KVStore, to sdk.Address, amt sdk.Coins) sdk.Result { +func handleTo(store sdk.KVStore, to sdk.AccAddress, amt sdk.Coins) sdk.Result { // Add msg amount to receiver account accBytes := store.Get(to) var acc appAccount diff --git a/docs/core/examples/app2.go b/docs/core/examples/app2.go index c96a1022fa..4c20c17c3a 100644 --- a/docs/core/examples/app2.go +++ b/docs/core/examples/app2.go @@ -68,8 +68,8 @@ func NewApp2(logger log.Logger, db dbm.DB) *bapp.BaseApp { // MsgIssue to allow a registered issuer // to issue new coins. type MsgIssue struct { - Issuer sdk.Address - Receiver sdk.Address + Issuer sdk.AccAddress + Receiver sdk.AccAddress Coin sdk.Coin } @@ -104,8 +104,8 @@ func (msg MsgIssue) GetSignBytes() []byte { } // Implements Msg. Return the signer. -func (msg MsgIssue) GetSigners() []sdk.Address { - return []sdk.Address{msg.Issuer} +func (msg MsgIssue) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.Issuer} } // Returns the sdk.Tags for the message @@ -146,7 +146,7 @@ func handleMsgIssue(keyIssue *sdk.KVStoreKey, keyAcc *sdk.KVStoreKey) sdk.Handle } } -func handleIssuer(store sdk.KVStore, issuer sdk.Address, coin sdk.Coin) sdk.Result { +func handleIssuer(store sdk.KVStore, issuer sdk.AccAddress, coin sdk.Coin) sdk.Result { // the issuer address is stored directly under the coin denomination denom := []byte(coin.Denom) infoBytes := store.Get(denom) @@ -170,7 +170,7 @@ func handleIssuer(store sdk.KVStore, issuer sdk.Address, coin sdk.Coin) sdk.Resu // coinInfo stores meta data about a coin type coinInfo struct { - Issuer sdk.Address `json:"issuer"` + Issuer sdk.AccAddress `json:"issuer"` } //------------------------------------------------------------------ diff --git a/docs/core/examples/app4.go b/docs/core/examples/app4.go index 22282738f6..daabe1561e 100644 --- a/docs/core/examples/app4.go +++ b/docs/core/examples/app4.go @@ -61,8 +61,8 @@ type GenesisState struct { // GenesisAccount doesn't need pubkey or sequence type GenesisAccount struct { - Address sdk.Address `json:"address"` - Coins sdk.Coins `json:"coins"` + Address sdk.AccAddress `json:"address"` + Coins sdk.Coins `json:"coins"` } // Converts GenesisAccount to auth.BaseAccount for storage in account store diff --git a/examples/basecoin/app/app_test.go b/examples/basecoin/app/app_test.go index cd316c7d65..78f9e35a83 100644 --- a/examples/basecoin/app/app_test.go +++ b/examples/basecoin/app/app_test.go @@ -43,7 +43,7 @@ func TestGenesis(t *testing.T) { // construct a pubkey and an address for the test account pubkey := crypto.GenPrivKeyEd25519().PubKey() - addr := pubkey.Address() + addr := sdk.AccAddress(pubkey.Address()) // construct some test coins coins, err := sdk.ParseCoins("77foocoin,99barcoin") diff --git a/examples/basecoin/types/account.go b/examples/basecoin/types/account.go index 8047ed68da..671494311f 100644 --- a/examples/basecoin/types/account.go +++ b/examples/basecoin/types/account.go @@ -54,9 +54,9 @@ type GenesisState struct { // GenesisAccount reflects a genesis account the application expects in it's // genesis state. type GenesisAccount struct { - Name string `json:"name"` - Address sdk.Address `json:"address"` - Coins sdk.Coins `json:"coins"` + Name string `json:"name"` + Address sdk.AccAddress `json:"address"` + Coins sdk.Coins `json:"coins"` } // NewGenesisAccount returns a reference to a new GenesisAccount given an diff --git a/examples/democoin/app/app_test.go b/examples/democoin/app/app_test.go index 60005713ef..b786af816e 100644 --- a/examples/democoin/app/app_test.go +++ b/examples/democoin/app/app_test.go @@ -47,7 +47,7 @@ func TestGenesis(t *testing.T) { // Construct some genesis bytes to reflect democoin/types/AppAccount pk := crypto.GenPrivKeyEd25519().PubKey() - addr := pk.Address() + addr := sdk.AccAddress(pk.Address()) coins, err := sdk.ParseCoins("77foocoin,99barcoin") require.Nil(t, err) baseAcc := auth.BaseAccount{ diff --git a/examples/democoin/mock/validator.go b/examples/democoin/mock/validator.go index 8b1d34c7b4..84d41d4880 100644 --- a/examples/democoin/mock/validator.go +++ b/examples/democoin/mock/validator.go @@ -9,7 +9,7 @@ import ( // Validator implements sdk.Validator type Validator struct { - Address sdk.Address + Address sdk.AccAddress Power sdk.Rat } @@ -19,7 +19,7 @@ func (v Validator) GetStatus() sdk.BondStatus { } // Implements sdk.Validator -func (v Validator) GetOwner() sdk.Address { +func (v Validator) GetOwner() sdk.AccAddress { return v.Address } @@ -73,7 +73,7 @@ func (vs *ValidatorSet) IterateValidatorsBonded(ctx sdk.Context, fn func(index i } // Validator implements sdk.ValidatorSet -func (vs *ValidatorSet) Validator(ctx sdk.Context, addr sdk.Address) sdk.Validator { +func (vs *ValidatorSet) Validator(ctx sdk.Context, addr sdk.AccAddress) sdk.Validator { for _, val := range vs.Validators { if bytes.Equal(val.Address, addr) { return val @@ -97,7 +97,7 @@ func (vs *ValidatorSet) AddValidator(val Validator) { } // Helper function for removing exsting validator -func (vs *ValidatorSet) RemoveValidator(addr sdk.Address) { +func (vs *ValidatorSet) RemoveValidator(addr sdk.AccAddress) { pos := -1 for i, val := range vs.Validators { if bytes.Equal(val.Address, addr) { diff --git a/examples/democoin/types/account.go b/examples/democoin/types/account.go index e01b63c318..e491912579 100644 --- a/examples/democoin/types/account.go +++ b/examples/democoin/types/account.go @@ -51,9 +51,9 @@ type GenesisState struct { // GenesisAccount doesn't need pubkey or sequence type GenesisAccount struct { - Name string `json:"name"` - Address sdk.Address `json:"address"` - Coins sdk.Coins `json:"coins"` + Name string `json:"name"` + Address sdk.AccAddress `json:"address"` + Coins sdk.Coins `json:"coins"` } func NewGenesisAccount(aa *AppAccount) *GenesisAccount { diff --git a/examples/democoin/x/assoc/validator_set.go b/examples/democoin/x/assoc/validator_set.go index 019ac87952..94a0ef6306 100644 --- a/examples/democoin/x/assoc/validator_set.go +++ b/examples/democoin/x/assoc/validator_set.go @@ -37,7 +37,7 @@ func NewValidatorSet(cdc *wire.Codec, key sdk.KVStoreGetter, valset sdk.Validato } // Implements sdk.ValidatorSet -func (valset ValidatorSet) Validator(ctx sdk.Context, addr sdk.Address) (res sdk.Validator) { +func (valset ValidatorSet) Validator(ctx sdk.Context, addr sdk.AccAddress) (res sdk.Validator) { store := valset.key.KVStore(ctx) base := store.Get(GetBaseKey(addr)) res = valset.ValidatorSet.Validator(ctx, base) @@ -47,23 +47,23 @@ func (valset ValidatorSet) Validator(ctx sdk.Context, addr sdk.Address) (res sdk return } -// GetBaseKey :: sdk.Address -> sdk.Address -func GetBaseKey(addr sdk.Address) []byte { +// GetBaseKey :: sdk.AccAddress -> sdk.AccAddress +func GetBaseKey(addr sdk.AccAddress) []byte { return append([]byte{0x00}, addr...) } -// GetAssocPrefix :: sdk.Address -> (sdk.Address -> byte) -func GetAssocPrefix(base sdk.Address) []byte { +// GetAssocPrefix :: sdk.AccAddress -> (sdk.AccAddress -> byte) +func GetAssocPrefix(base sdk.AccAddress) []byte { return append([]byte{0x01}, base...) } -// GetAssocKey :: (sdk.Address, sdk.Address) -> byte -func GetAssocKey(base sdk.Address, assoc sdk.Address) []byte { +// GetAssocKey :: (sdk.AccAddress, sdk.AccAddress) -> byte +func GetAssocKey(base sdk.AccAddress, assoc sdk.AccAddress) []byte { return append(append([]byte{0x01}, base...), assoc...) } // Associate associates new address with validator address -func (valset ValidatorSet) Associate(ctx sdk.Context, base sdk.Address, assoc sdk.Address) bool { +func (valset ValidatorSet) Associate(ctx sdk.Context, base sdk.AccAddress, assoc sdk.AccAddress) bool { if len(base) != valset.addrLen || len(assoc) != valset.addrLen { return false } @@ -78,7 +78,7 @@ func (valset ValidatorSet) Associate(ctx sdk.Context, base sdk.Address, assoc sd } // Dissociate removes association between addresses -func (valset ValidatorSet) Dissociate(ctx sdk.Context, base sdk.Address, assoc sdk.Address) bool { +func (valset ValidatorSet) Dissociate(ctx sdk.Context, base sdk.AccAddress, assoc sdk.AccAddress) bool { if len(base) != valset.addrLen || len(assoc) != valset.addrLen { return false } @@ -93,9 +93,9 @@ func (valset ValidatorSet) Dissociate(ctx sdk.Context, base sdk.Address, assoc s } // Associations returns all associated addresses with a validator -func (valset ValidatorSet) Associations(ctx sdk.Context, base sdk.Address) (res []sdk.Address) { +func (valset ValidatorSet) Associations(ctx sdk.Context, base sdk.AccAddress) (res []sdk.AccAddress) { store := valset.key.KVStore(ctx) - res = make([]sdk.Address, valset.maxAssoc) + res = make([]sdk.AccAddress, valset.maxAssoc) iter := sdk.KVStorePrefixIterator(store, GetAssocPrefix(base)) i := 0 for ; iter.Valid(); iter.Next() { diff --git a/examples/democoin/x/cool/app_test.go b/examples/democoin/x/cool/app_test.go index df5786a043..269f0ae49c 100644 --- a/examples/democoin/x/cool/app_test.go +++ b/examples/democoin/x/cool/app_test.go @@ -15,7 +15,7 @@ import ( var ( priv1 = crypto.GenPrivKeyEd25519() pubKey = priv1.PubKey() - addr1 = pubKey.Address() + addr1 = sdk.AccAddress(pubKey.Address()) quizMsg1 = MsgQuiz{ Sender: addr1, diff --git a/examples/democoin/x/cool/types.go b/examples/democoin/x/cool/types.go index 82c9286c68..d335f9c913 100644 --- a/examples/democoin/x/cool/types.go +++ b/examples/democoin/x/cool/types.go @@ -11,7 +11,7 @@ import ( // a really cool msg type, these fields are can be entirely arbitrary and // custom to your message type MsgSetTrend struct { - Sender sdk.Address + Sender sdk.AccAddress Cool string } @@ -21,7 +21,7 @@ type Genesis struct { } // new cool message -func NewMsgSetTrend(sender sdk.Address, cool string) MsgSetTrend { +func NewMsgSetTrend(sender sdk.AccAddress, cool string) MsgSetTrend { return MsgSetTrend{ Sender: sender, Cool: cool, @@ -32,8 +32,8 @@ func NewMsgSetTrend(sender sdk.Address, cool string) MsgSetTrend { var _ sdk.Msg = MsgSetTrend{} // nolint -func (msg MsgSetTrend) Type() string { return "cool" } -func (msg MsgSetTrend) GetSigners() []sdk.Address { return []sdk.Address{msg.Sender} } +func (msg MsgSetTrend) Type() string { return "cool" } +func (msg MsgSetTrend) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Sender} } func (msg MsgSetTrend) String() string { return fmt.Sprintf("MsgSetTrend{Sender: %v, Cool: %v}", msg.Sender, msg.Cool) } @@ -66,12 +66,12 @@ func (msg MsgSetTrend) GetSignBytes() []byte { // A message type to quiz how cool you are. these fields are can be entirely // arbitrary and custom to your message type MsgQuiz struct { - Sender sdk.Address + Sender sdk.AccAddress CoolAnswer string } // New cool message -func NewMsgQuiz(sender sdk.Address, coolerthancool string) MsgQuiz { +func NewMsgQuiz(sender sdk.AccAddress, coolerthancool string) MsgQuiz { return MsgQuiz{ Sender: sender, CoolAnswer: coolerthancool, @@ -82,8 +82,8 @@ func NewMsgQuiz(sender sdk.Address, coolerthancool string) MsgQuiz { var _ sdk.Msg = MsgQuiz{} // nolint -func (msg MsgQuiz) Type() string { return "cool" } -func (msg MsgQuiz) GetSigners() []sdk.Address { return []sdk.Address{msg.Sender} } +func (msg MsgQuiz) Type() string { return "cool" } +func (msg MsgQuiz) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Sender} } func (msg MsgQuiz) String() string { return fmt.Sprintf("MsgQuiz{Sender: %v, CoolAnswer: %v}", msg.Sender, msg.CoolAnswer) } diff --git a/examples/democoin/x/oracle/errors.go b/examples/democoin/x/oracle/errors.go index 0507ed2266..1378fa76f5 100644 --- a/examples/democoin/x/oracle/errors.go +++ b/examples/democoin/x/oracle/errors.go @@ -16,7 +16,7 @@ const ( // Error constructors // ErrNotValidator called when the signer of a Msg is not a validator -func ErrNotValidator(codespace sdk.CodespaceType, address sdk.Address) sdk.Error { +func ErrNotValidator(codespace sdk.CodespaceType, address sdk.AccAddress) sdk.Error { return sdk.NewError(codespace, CodeNotValidator, address.String()) } diff --git a/examples/democoin/x/oracle/keeper.go b/examples/democoin/x/oracle/keeper.go index cc15ffdc80..97c68251b1 100644 --- a/examples/democoin/x/oracle/keeper.go +++ b/examples/democoin/x/oracle/keeper.go @@ -84,14 +84,14 @@ func (keeper Keeper) setInfo(ctx sdk.Context, p Payload, info Info) { store.Set(key, bz) } -func (keeper Keeper) sign(ctx sdk.Context, p Payload, signer sdk.Address) { +func (keeper Keeper) sign(ctx sdk.Context, p Payload, signer sdk.AccAddress) { store := keeper.key.KVStore(ctx) key := GetSignKey(p, signer, keeper.cdc) store.Set(key, signer) } -func (keeper Keeper) signed(ctx sdk.Context, p Payload, signer sdk.Address) bool { +func (keeper Keeper) signed(ctx sdk.Context, p Payload, signer sdk.AccAddress) bool { store := keeper.key.KVStore(ctx) key := GetSignKey(p, signer, keeper.cdc) diff --git a/examples/democoin/x/oracle/keeper_keys.go b/examples/democoin/x/oracle/keeper_keys.go index 8c62c95de8..f657e80279 100644 --- a/examples/democoin/x/oracle/keeper_keys.go +++ b/examples/democoin/x/oracle/keeper_keys.go @@ -18,6 +18,6 @@ func GetSignPrefix(p Payload, cdc *wire.Codec) []byte { } // GetSignKey returns the key for sign -func GetSignKey(p Payload, signer sdk.Address, cdc *wire.Codec) []byte { +func GetSignKey(p Payload, signer sdk.AccAddress, cdc *wire.Codec) []byte { return append(GetSignPrefix(p, cdc), signer...) } diff --git a/examples/democoin/x/oracle/types.go b/examples/democoin/x/oracle/types.go index d06f47a4e2..ab4b04a425 100644 --- a/examples/democoin/x/oracle/types.go +++ b/examples/democoin/x/oracle/types.go @@ -9,7 +9,7 @@ import ( // Msg - struct for voting on payloads type Msg struct { Payload - Signer sdk.Address + Signer sdk.AccAddress } // GetSignBytes implements sdk.Msg @@ -22,8 +22,8 @@ func (msg Msg) GetSignBytes() []byte { } // GetSigners implements sdk.Msg -func (msg Msg) GetSigners() []sdk.Address { - return []sdk.Address{msg.Signer} +func (msg Msg) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.Signer} } // Payload defines inner data for actual execution diff --git a/examples/democoin/x/pow/app_test.go b/examples/democoin/x/pow/app_test.go index 076dc20bc6..32f57b8cb3 100644 --- a/examples/democoin/x/pow/app_test.go +++ b/examples/democoin/x/pow/app_test.go @@ -16,7 +16,7 @@ import ( var ( priv1 = crypto.GenPrivKeyEd25519() - addr1 = priv1.PubKey().Address() + addr1 = sdk.AccAddress(priv1.PubKey().Address()) ) // initialize the mock application for this module diff --git a/examples/democoin/x/pow/handler_test.go b/examples/democoin/x/pow/handler_test.go index 283c30ef59..863a0dc6cc 100644 --- a/examples/democoin/x/pow/handler_test.go +++ b/examples/democoin/x/pow/handler_test.go @@ -27,7 +27,7 @@ func TestPowHandler(t *testing.T) { handler := keeper.Handler - addr := sdk.Address([]byte("sender")) + addr := sdk.AccAddress([]byte("sender")) count := uint64(1) difficulty := uint64(2) diff --git a/examples/democoin/x/pow/keeper.go b/examples/democoin/x/pow/keeper.go index 98258a2e9f..e276b87212 100644 --- a/examples/democoin/x/pow/keeper.go +++ b/examples/democoin/x/pow/keeper.go @@ -124,7 +124,7 @@ func (k Keeper) CheckValid(ctx sdk.Context, difficulty uint64, count uint64) (ui } // Add some coins for a POW well done -func (k Keeper) ApplyValid(ctx sdk.Context, sender sdk.Address, newDifficulty uint64, newCount uint64) sdk.Error { +func (k Keeper) ApplyValid(ctx sdk.Context, sender sdk.AccAddress, newDifficulty uint64, newCount uint64) sdk.Error { _, _, ckErr := k.ck.AddCoins(ctx, sender, []sdk.Coin{sdk.NewCoin(k.config.Denomination, k.config.Reward)}) if ckErr != nil { return ckErr diff --git a/examples/democoin/x/pow/mine.go b/examples/democoin/x/pow/mine.go index b4b536a525..bf1c64cd43 100644 --- a/examples/democoin/x/pow/mine.go +++ b/examples/democoin/x/pow/mine.go @@ -10,12 +10,12 @@ import ( ) // generate the mine message -func GenerateMsgMine(sender sdk.Address, count uint64, difficulty uint64) MsgMine { +func GenerateMsgMine(sender sdk.AccAddress, count uint64, difficulty uint64) MsgMine { nonce, hash := mine(sender, count, difficulty) return NewMsgMine(sender, difficulty, count, nonce, hash) } -func hash(sender sdk.Address, count uint64, nonce uint64) []byte { +func hash(sender sdk.AccAddress, count uint64, nonce uint64) []byte { var bytes []byte bytes = append(bytes, []byte(sender)...) countBytes := strconv.FormatUint(count, 16) @@ -30,7 +30,7 @@ func hash(sender sdk.Address, count uint64, nonce uint64) []byte { return ret[:16] } -func mine(sender sdk.Address, count uint64, difficulty uint64) (uint64, []byte) { +func mine(sender sdk.AccAddress, count uint64, difficulty uint64) (uint64, []byte) { target := math.MaxUint64 / difficulty for nonce := uint64(0); ; nonce++ { hash := hash(sender, count, nonce) diff --git a/examples/democoin/x/pow/types.go b/examples/democoin/x/pow/types.go index 3529917dce..52098d7875 100644 --- a/examples/democoin/x/pow/types.go +++ b/examples/democoin/x/pow/types.go @@ -15,24 +15,24 @@ import ( // MsgMine - mine some coins with PoW type MsgMine struct { - Sender sdk.Address `json:"sender"` - Difficulty uint64 `json:"difficulty"` - Count uint64 `json:"count"` - Nonce uint64 `json:"nonce"` - Proof []byte `json:"proof"` + Sender sdk.AccAddress `json:"sender"` + Difficulty uint64 `json:"difficulty"` + Count uint64 `json:"count"` + Nonce uint64 `json:"nonce"` + Proof []byte `json:"proof"` } // enforce the msg type at compile time var _ sdk.Msg = MsgMine{} // NewMsgMine - construct mine message -func NewMsgMine(sender sdk.Address, difficulty uint64, count uint64, nonce uint64, proof []byte) MsgMine { +func NewMsgMine(sender sdk.AccAddress, difficulty uint64, count uint64, nonce uint64, proof []byte) MsgMine { return MsgMine{sender, difficulty, count, nonce, proof} } // nolint -func (msg MsgMine) Type() string { return "pow" } -func (msg MsgMine) GetSigners() []sdk.Address { return []sdk.Address{msg.Sender} } +func (msg MsgMine) Type() string { return "pow" } +func (msg MsgMine) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Sender} } func (msg MsgMine) String() string { return fmt.Sprintf("MsgMine{Sender: %v, Difficulty: %d, Count: %d, Nonce: %d, Proof: %s}", msg.Sender, msg.Difficulty, msg.Count, msg.Nonce, msg.Proof) } diff --git a/examples/democoin/x/pow/types_test.go b/examples/democoin/x/pow/types_test.go index 1291cb96a6..8c0f16b15b 100644 --- a/examples/democoin/x/pow/types_test.go +++ b/examples/democoin/x/pow/types_test.go @@ -10,21 +10,21 @@ import ( ) func TestNewMsgMine(t *testing.T) { - addr := sdk.Address([]byte("sender")) + addr := sdk.AccAddress([]byte("sender")) msg := MsgMine{addr, 0, 0, 0, []byte("")} equiv := NewMsgMine(addr, 0, 0, 0, []byte("")) require.Equal(t, msg, equiv, "%s != %s", msg, equiv) } func TestMsgMineType(t *testing.T) { - addr := sdk.Address([]byte("sender")) + addr := sdk.AccAddress([]byte("sender")) msg := MsgMine{addr, 0, 0, 0, []byte("")} require.Equal(t, msg.Type(), "pow") } func TestMsgMineValidation(t *testing.T) { - addr := sdk.Address([]byte("sender")) - otherAddr := sdk.Address([]byte("another")) + addr := sdk.AccAddress([]byte("sender")) + otherAddr := sdk.AccAddress([]byte("another")) count := uint64(0) for difficulty := uint64(1); difficulty < 1000; difficulty += 100 { @@ -52,21 +52,21 @@ func TestMsgMineValidation(t *testing.T) { } func TestMsgMineString(t *testing.T) { - addr := sdk.Address([]byte("sender")) + addr := sdk.AccAddress([]byte("sender")) msg := MsgMine{addr, 0, 0, 0, []byte("abc")} res := msg.String() require.Equal(t, res, "MsgMine{Sender: 73656E646572, Difficulty: 0, Count: 0, Nonce: 0, Proof: abc}") } func TestMsgMineGetSignBytes(t *testing.T) { - addr := sdk.Address([]byte("sender")) + addr := sdk.AccAddress([]byte("sender")) msg := MsgMine{addr, 1, 1, 1, []byte("abc")} res := msg.GetSignBytes() require.Equal(t, string(res), `{"count":1,"difficulty":1,"nonce":1,"proof":"YWJj","sender":"73656E646572"}`) } func TestMsgMineGetSigners(t *testing.T) { - addr := sdk.Address([]byte("sender")) + addr := sdk.AccAddress([]byte("sender")) msg := MsgMine{addr, 1, 1, 1, []byte("abc")} res := msg.GetSigners() require.Equal(t, fmt.Sprintf("%v", res), "[73656E646572]") diff --git a/examples/democoin/x/simplestake/keeper.go b/examples/democoin/x/simplestake/keeper.go index 122b44bfed..a6e3704dba 100644 --- a/examples/democoin/x/simplestake/keeper.go +++ b/examples/democoin/x/simplestake/keeper.go @@ -32,7 +32,7 @@ func NewKeeper(key sdk.StoreKey, coinKeeper bank.Keeper, codespace sdk.Codespace } } -func (k Keeper) getBondInfo(ctx sdk.Context, addr sdk.Address) bondInfo { +func (k Keeper) getBondInfo(ctx sdk.Context, addr sdk.AccAddress) bondInfo { store := ctx.KVStore(k.key) bz := store.Get(addr) if bz == nil { @@ -46,7 +46,7 @@ func (k Keeper) getBondInfo(ctx sdk.Context, addr sdk.Address) bondInfo { return bi } -func (k Keeper) setBondInfo(ctx sdk.Context, addr sdk.Address, bi bondInfo) { +func (k Keeper) setBondInfo(ctx sdk.Context, addr sdk.AccAddress, bi bondInfo) { store := ctx.KVStore(k.key) bz, err := k.cdc.MarshalBinary(bi) if err != nil { @@ -55,13 +55,13 @@ func (k Keeper) setBondInfo(ctx sdk.Context, addr sdk.Address, bi bondInfo) { store.Set(addr, bz) } -func (k Keeper) deleteBondInfo(ctx sdk.Context, addr sdk.Address) { +func (k Keeper) deleteBondInfo(ctx sdk.Context, addr sdk.AccAddress) { store := ctx.KVStore(k.key) store.Delete(addr) } // register a bond with the keeper -func (k Keeper) Bond(ctx sdk.Context, addr sdk.Address, pubKey crypto.PubKey, stake sdk.Coin) (int64, sdk.Error) { +func (k Keeper) Bond(ctx sdk.Context, addr sdk.AccAddress, pubKey crypto.PubKey, stake sdk.Coin) (int64, sdk.Error) { if stake.Denom != stakingToken { return 0, ErrIncorrectStakingToken(k.codespace) } @@ -86,7 +86,7 @@ func (k Keeper) Bond(ctx sdk.Context, addr sdk.Address, pubKey crypto.PubKey, st } // register an unbond with the keeper -func (k Keeper) Unbond(ctx sdk.Context, addr sdk.Address) (crypto.PubKey, int64, sdk.Error) { +func (k Keeper) Unbond(ctx sdk.Context, addr sdk.AccAddress) (crypto.PubKey, int64, sdk.Error) { bi := k.getBondInfo(ctx, addr) if bi.isEmpty() { return nil, 0, ErrInvalidUnbond(k.codespace) @@ -105,7 +105,7 @@ func (k Keeper) Unbond(ctx sdk.Context, addr sdk.Address) (crypto.PubKey, int64, // FOR TESTING PURPOSES ------------------------------------------------- -func (k Keeper) bondWithoutCoins(ctx sdk.Context, addr sdk.Address, pubKey crypto.PubKey, stake sdk.Coin) (int64, sdk.Error) { +func (k Keeper) bondWithoutCoins(ctx sdk.Context, addr sdk.AccAddress, pubKey crypto.PubKey, stake sdk.Coin) (int64, sdk.Error) { if stake.Denom != stakingToken { return 0, ErrIncorrectStakingToken(k.codespace) } @@ -124,7 +124,7 @@ func (k Keeper) bondWithoutCoins(ctx sdk.Context, addr sdk.Address, pubKey crypt return bi.Power, nil } -func (k Keeper) unbondWithoutCoins(ctx sdk.Context, addr sdk.Address) (crypto.PubKey, int64, sdk.Error) { +func (k Keeper) unbondWithoutCoins(ctx sdk.Context, addr sdk.AccAddress) (crypto.PubKey, int64, sdk.Error) { bi := k.getBondInfo(ctx, addr) if bi.isEmpty() { return nil, 0, ErrInvalidUnbond(k.codespace) diff --git a/examples/democoin/x/simplestake/keeper_test.go b/examples/democoin/x/simplestake/keeper_test.go index 4496eb369c..35910b921c 100644 --- a/examples/democoin/x/simplestake/keeper_test.go +++ b/examples/democoin/x/simplestake/keeper_test.go @@ -38,7 +38,7 @@ func TestKeeperGetSet(t *testing.T) { accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{}) stakeKeeper := NewKeeper(capKey, bank.NewKeeper(accountMapper), DefaultCodespace) ctx := sdk.NewContext(ms, abci.Header{}, false, log.NewNopLogger()) - addr := sdk.Address([]byte("some-address")) + addr := sdk.AccAddress([]byte("some-address")) bi := stakeKeeper.getBondInfo(ctx, addr) require.Equal(t, bi, bondInfo{}) @@ -68,7 +68,7 @@ func TestBonding(t *testing.T) { accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{}) coinKeeper := bank.NewKeeper(accountMapper) stakeKeeper := NewKeeper(capKey, coinKeeper, DefaultCodespace) - addr := sdk.Address([]byte("some-address")) + addr := sdk.AccAddress([]byte("some-address")) privKey := crypto.GenPrivKeyEd25519() pubKey := privKey.PubKey() diff --git a/examples/democoin/x/simplestake/msgs.go b/examples/democoin/x/simplestake/msgs.go index 91729e3ef7..9f4c4f5f67 100644 --- a/examples/democoin/x/simplestake/msgs.go +++ b/examples/democoin/x/simplestake/msgs.go @@ -12,12 +12,12 @@ import ( // simple bond message type MsgBond struct { - Address sdk.Address `json:"address"` - Stake sdk.Coin `json:"coins"` - PubKey crypto.PubKey `json:"pub_key"` + Address sdk.AccAddress `json:"address"` + Stake sdk.Coin `json:"coins"` + PubKey crypto.PubKey `json:"pub_key"` } -func NewMsgBond(addr sdk.Address, stake sdk.Coin, pubKey crypto.PubKey) MsgBond { +func NewMsgBond(addr sdk.AccAddress, stake sdk.Coin, pubKey crypto.PubKey) MsgBond { return MsgBond{ Address: addr, Stake: stake, @@ -26,8 +26,8 @@ func NewMsgBond(addr sdk.Address, stake sdk.Coin, pubKey crypto.PubKey) MsgBond } //nolint -func (msg MsgBond) Type() string { return moduleName } //TODO update "stake/createvalidator" -func (msg MsgBond) GetSigners() []sdk.Address { return []sdk.Address{msg.Address} } +func (msg MsgBond) Type() string { return moduleName } //TODO update "stake/createvalidator" +func (msg MsgBond) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Address} } // basic validation of the bond message func (msg MsgBond) ValidateBasic() sdk.Error { @@ -55,19 +55,19 @@ func (msg MsgBond) GetSignBytes() []byte { // simple unbond message type MsgUnbond struct { - Address sdk.Address `json:"address"` + Address sdk.AccAddress `json:"address"` } -func NewMsgUnbond(addr sdk.Address) MsgUnbond { +func NewMsgUnbond(addr sdk.AccAddress) MsgUnbond { return MsgUnbond{ Address: addr, } } //nolint -func (msg MsgUnbond) Type() string { return moduleName } //TODO update "stake/createvalidator" -func (msg MsgUnbond) GetSigners() []sdk.Address { return []sdk.Address{msg.Address} } -func (msg MsgUnbond) ValidateBasic() sdk.Error { return nil } +func (msg MsgUnbond) Type() string { return moduleName } //TODO update "stake/createvalidator" +func (msg MsgUnbond) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Address} } +func (msg MsgUnbond) ValidateBasic() sdk.Error { return nil } // get unbond message sign bytes func (msg MsgUnbond) GetSignBytes() []byte { diff --git a/examples/democoin/x/simplestake/msgs_test.go b/examples/democoin/x/simplestake/msgs_test.go index 9baf0dd1a9..fd6f3612a1 100644 --- a/examples/democoin/x/simplestake/msgs_test.go +++ b/examples/democoin/x/simplestake/msgs_test.go @@ -16,8 +16,8 @@ func TestBondMsgValidation(t *testing.T) { valid bool msgBond MsgBond }{ - {true, NewMsgBond(sdk.Address{}, sdk.NewCoin("mycoin", 5), privKey.PubKey())}, - {false, NewMsgBond(sdk.Address{}, sdk.NewCoin("mycoin", 0), privKey.PubKey())}, + {true, NewMsgBond(sdk.AccAddress{}, sdk.NewCoin("mycoin", 5), privKey.PubKey())}, + {false, NewMsgBond(sdk.AccAddress{}, sdk.NewCoin("mycoin", 0), privKey.PubKey())}, } for i, tc := range cases { diff --git a/examples/kvstore/tx.go b/examples/kvstore/tx.go index e1c5cab3a8..0d8312fab5 100644 --- a/examples/kvstore/tx.go +++ b/examples/kvstore/tx.go @@ -35,7 +35,7 @@ func (tx kvstoreTx) ValidateBasic() sdk.Error { return nil } -func (tx kvstoreTx) GetSigners() []sdk.Address { +func (tx kvstoreTx) GetSigners() []sdk.AccAddress { return nil } diff --git a/server/init.go b/server/init.go index 5a504515ff..ff8565c8a4 100644 --- a/server/init.go +++ b/server/init.go @@ -376,22 +376,22 @@ var DefaultAppInit = AppInit{ // simple genesis tx type SimpleGenTx struct { - Addr string `json:"addr"` + Addr sdk.AccAddress `json:"addr"` } // Generate a genesis transaction func SimpleAppGenTx(cdc *wire.Codec, pk crypto.PubKey, genTxConfig serverconfig.GenTx) ( appGenTx, cliPrint json.RawMessage, validator tmtypes.GenesisValidator, err error) { - var bech32Addr string + var addr sdk.AccAddress var secret string - bech32Addr, secret, err = GenerateCoinKey() + addr, secret, err = GenerateCoinKey() if err != nil { return } var bz []byte - simpleGenTx := SimpleGenTx{bech32Addr} + simpleGenTx := SimpleGenTx{addr} bz, err = cdc.MarshalJSON(simpleGenTx) if err != nil { return @@ -444,7 +444,7 @@ func SimpleAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (appState j // GenerateCoinKey returns the address of a public key, along with the secret // phrase to recover the private key. -func GenerateCoinKey() (string, string, error) { +func GenerateCoinKey() (sdk.AccAddress, string, error) { // construct an in-memory key store keybase := keys.New( @@ -457,12 +457,12 @@ func GenerateCoinKey() (string, string, error) { return "", "", err } addr := info.GetPubKey().Address() - return sdk.MustBech32ifyAcc(sdk.Address(addr)), secret, nil + return sdk.AccAddress(addr), secret, nil } // GenerateSaveCoinKey returns the address of a public key, along with the secret // phrase to recover the private key. -func GenerateSaveCoinKey(clientRoot, keyName, keyPass string, overwrite bool) (string, string, error) { +func GenerateSaveCoinKey(clientRoot, keyName, keyPass string, overwrite bool) (sdk.AccAddress, string, error) { // get the keystore from the client keybase, err := clkeys.GetKeyBaseFromDir(clientRoot) @@ -484,5 +484,5 @@ func GenerateSaveCoinKey(clientRoot, keyName, keyPass string, overwrite bool) (s return "", "", err } addr := info.GetPubKey().Address() - return sdk.MustBech32ifyAcc(sdk.Address(addr)), secret, nil + return sdk.AccAddress(addr), secret, nil } diff --git a/server/mock/tx.go b/server/mock/tx.go index 6b539b29c2..c15e0ab2cb 100644 --- a/server/mock/tx.go +++ b/server/mock/tx.go @@ -48,7 +48,7 @@ func (tx kvstoreTx) ValidateBasic() sdk.Error { return nil } -func (tx kvstoreTx) GetSigners() []sdk.Address { +func (tx kvstoreTx) GetSigners() []sdk.AccAddress { return nil } diff --git a/types/account.go b/types/account.go index e8e4c541d8..4cfc7e9d43 100644 --- a/types/account.go +++ b/types/account.go @@ -21,26 +21,45 @@ const ( Bech32PrefixValPub = "cosmosvalpub" ) -// Address is a go crypto-style Address -type Address []byte +//__________________________________________________________ -func NewAddress(bech32String string) (Address, error) { - return GetAccAddressHex(bech32String) +// AccAddress is a go crypto-style Address +type AccAddress []byte + +// create an Address from a hex string +func GetAccAddressHex(address string) (addr AccAddress, err error) { + if len(address) == 0 { + return addr, errors.New("decoding bech32 address failed: must provide an address") + } + bz, err := hex.DecodeString(address) + if err != nil { + return nil, err + } + return AccAddress(bz), nil +} + +// create an Address from a bech32 string +func GetAccAddressBech32(address string) (addr AccAddress, err error) { + bz, err := GetFromBech32(address, Bech32PrefixAccAddr) + if err != nil { + return nil, err + } + return AccAddress(bz), nil } // Marshal needed for protobuf compatibility -func (bz Address) Marshal() ([]byte, error) { +func (bz AccAddress) Marshal() ([]byte, error) { return bz, nil } // Unmarshal needed for protobuf compatibility -func (bz *Address) Unmarshal(data []byte) error { +func (bz *AccAddress) Unmarshal(data []byte) error { *bz = data return nil } // Marshals to JSON using Bech32 -func (bz Address) MarshalJSON() ([]byte, error) { +func (bz AccAddress) MarshalJSON() ([]byte, error) { s := bz.String() jbz := make([]byte, len(s)+2) jbz[0] = '"' @@ -50,12 +69,12 @@ func (bz Address) MarshalJSON() ([]byte, error) { } // Unmarshals from JSON assuming Bech32 encoding -func (bz *Address) UnmarshalJSON(data []byte) error { +func (bz *AccAddress) UnmarshalJSON(data []byte) error { if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' { return fmt.Errorf("Invalid bech32 string: %s", data) } - bz2, err := GetAccAddressHex(string(data[1 : len(data)-1])) + bz2, err := GetAccAddressBech32(string(data[1 : len(data)-1])) if err != nil { return err } @@ -64,11 +83,11 @@ func (bz *Address) UnmarshalJSON(data []byte) error { } // Allow it to fulfill various interfaces in light-client, etc... -func (bz Address) Bytes() []byte { +func (bz AccAddress) Bytes() []byte { return bz } -func (bz Address) String() string { +func (bz AccAddress) String() string { bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixAccAddr, bz.Bytes()) if err != nil { panic(err) @@ -77,7 +96,93 @@ func (bz Address) String() string { } // For Printf / Sprintf, returns bech32 when using %s -func (bz Address) Format(s fmt.State, verb rune) { +func (bz AccAddress) Format(s fmt.State, verb rune) { + switch verb { + case 's': + s.Write([]byte(fmt.Sprintf("%s", bz.String()))) + case 'p': + s.Write([]byte(fmt.Sprintf("%p", bz))) + default: + s.Write([]byte(fmt.Sprintf("%X", []byte(bz)))) + } +} + +//__________________________________________________________ + +// Address is a go crypto-style Address +type ValAddress []byte + +// create a ValAddress from a hex string +func GetValAddressHex(address string) (addr ValAddress, err error) { + if len(address) == 0 { + return addr, errors.New("decoding bech32 address failed: must provide an address") + } + bz, err := hex.DecodeString(address) + if err != nil { + return nil, err + } + return ValAddress(bz), nil +} + +// create a ValAddress from a bech32 string +func GetValAddressBech32(address string) (addr ValAddress, err error) { + bz, err := GetFromBech32(address, Bech32PrefixValAddr) + if err != nil { + return nil, err + } + return ValAddress(bz), nil +} + +// Marshal needed for protobuf compatibility +func (bz ValAddress) Marshal() ([]byte, error) { + return bz, nil +} + +// Unmarshal needed for protobuf compatibility +func (bz *ValAddress) Unmarshal(data []byte) error { + *bz = data + return nil +} + +// Marshals to JSON using Bech32 +func (bz ValAddress) MarshalJSON() ([]byte, error) { + s := bz.String() + jbz := make([]byte, len(s)+2) + jbz[0] = '"' + copy(jbz[1:], []byte(s)) + jbz[len(jbz)-1] = '"' + return jbz, nil +} + +// Unmarshals from JSON assuming Bech32 encoding +func (bz *ValAddress) UnmarshalJSON(data []byte) error { + if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' { + return fmt.Errorf("Invalid bech32 string: %s", data) + } + + bz2, err := GetValAddressBech32(string(data[1 : len(data)-1])) + if err != nil { + return err + } + *bz = bz2 + return nil +} + +// Allow it to fulfill various interfaces in light-client, etc... +func (bz ValAddress) Bytes() []byte { + return bz +} + +func (bz ValAddress) String() string { + bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixValAddr, bz.Bytes()) + if err != nil { + panic(err) + } + return bech32Addr +} + +// For Printf / Sprintf, returns bech32 when using %s +func (bz ValAddress) Format(s fmt.State, verb rune) { switch verb { case 's': s.Write([]byte(fmt.Sprintf("%s", bz.String()))) @@ -102,20 +207,6 @@ func MustBech32ifyAccPub(pub crypto.PubKey) string { return enc } -// Bech32ifyVal returns the bech32 encoded string for a validator address -func Bech32ifyVal(bz []byte) (string, error) { - return bech32.ConvertAndEncode(Bech32PrefixValAddr, bz) -} - -// MustBech32ifyVal panics on bech32-encoding failure -func MustBech32ifyVal(bz []byte) string { - enc, err := Bech32ifyVal(bz) - if err != nil { - panic(err) - } - return enc -} - // Bech32ifyValPub returns the bech32 encoded string for a validator pubkey func Bech32ifyValPub(pub crypto.PubKey) (string, error) { return bech32.ConvertAndEncode(Bech32PrefixValPub, pub.Bytes()) @@ -130,36 +221,6 @@ func MustBech32ifyValPub(pub crypto.PubKey) string { return enc } -// create an Address from a string -func GetAccAddressHex(address string) (addr Address, err error) { - if len(address) == 0 { - return addr, errors.New("decoding bech32 address failed: must provide an address") - } - bz, err := hex.DecodeString(address) - if err != nil { - return nil, err - } - return Address(bz), nil -} - -// create an Address from a string -func GetAccAddressBech32(address string) (addr Address, err error) { - bz, err := GetFromBech32(address, Bech32PrefixAccAddr) - if err != nil { - return nil, err - } - return Address(bz), nil -} - -// create an Address from a string, panics on error -func MustGetAccAddressBech32(address string) (addr Address) { - addr, err := GetAccAddressBech32(address) - if err != nil { - panic(err) - } - return addr -} - // create a Pubkey from a string func GetAccPubKeyBech32(address string) (pk crypto.PubKey, err error) { bz, err := GetFromBech32(address, Bech32PrefixAccPub) @@ -184,36 +245,6 @@ func MustGetAccPubKeyBech32(address string) (pk crypto.PubKey) { return pk } -// create an Address from a hex string -func GetValAddressHex(address string) (addr Address, err error) { - if len(address) == 0 { - return addr, errors.New("decoding bech32 address failed: must provide an address") - } - bz, err := hex.DecodeString(address) - if err != nil { - return nil, err - } - return Address(bz), nil -} - -// create an Address from a bech32 string -func GetValAddressBech32(address string) (addr Address, err error) { - bz, err := GetFromBech32(address, Bech32PrefixValAddr) - if err != nil { - return nil, err - } - return Address(bz), nil -} - -// create an Address from a string, panics on error -func MustGetValAddressBech32(address string) (addr Address) { - addr, err := GetValAddressBech32(address) - if err != nil { - panic(err) - } - return addr -} - // decode a validator public key into a PubKey func GetValPubKeyBech32(pubkey string) (pk crypto.PubKey, err error) { bz, err := GetFromBech32(pubkey, Bech32PrefixValPub) diff --git a/types/account_test.go b/types/account_test.go deleted file mode 100644 index ab1254f4c2..0000000000 --- a/types/account_test.go +++ /dev/null @@ -1 +0,0 @@ -package types diff --git a/types/stake.go b/types/stake.go index 7cb7ccf6d8..35eeaba1f0 100644 --- a/types/stake.go +++ b/types/stake.go @@ -35,7 +35,7 @@ type Validator interface { GetRevoked() bool // whether the validator is revoked GetMoniker() string // moniker of the validator GetStatus() BondStatus // status of the validator - GetOwner() Address // owner address to receive/return validators coins + GetOwner() AccAddress // owner AccAddress to receive/return validators coins GetPubKey() crypto.PubKey // validation pubkey GetPower() Rat // validation power GetDelegatorShares() Rat // Total out standing delegator shares @@ -52,16 +52,16 @@ func ABCIValidator(v Validator) abci.Validator { // properties for the set of all validators type ValidatorSet interface { - // iterate through validator by owner-address, execute func for each validator + // iterate through validator by owner-AccAddress, execute func for each validator IterateValidators(Context, func(index int64, validator Validator) (stop bool)) - // iterate through bonded validator by pubkey-address, execute func for each validator + // iterate through bonded validator by pubkey-AccAddress, execute func for each validator IterateValidatorsBonded(Context, func(index int64, validator Validator) (stop bool)) - Validator(Context, Address) Validator // get a particular validator by owner address - TotalPower(Context) Rat // total power of the validator set + Validator(Context, AccAddress) Validator // get a particular validator by owner AccAddress + TotalPower(Context) Rat // total power of the validator set // slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction Slash(Context, crypto.PubKey, int64, int64, Rat) @@ -73,17 +73,17 @@ type ValidatorSet interface { // delegation bond for a delegated proof of stake system type Delegation interface { - GetDelegator() Address // delegator address for the bond - GetValidator() Address // validator owner address for the bond - GetBondShares() Rat // amount of validator's shares + GetDelegator() AccAddress // delegator AccAddress for the bond + GetValidator() AccAddress // validator owner AccAddress for the bond + GetBondShares() Rat // amount of validator's shares } // properties for the set of all delegations for a particular type DelegationSet interface { GetValidatorSet() ValidatorSet // validator set for which delegation set is based upon - // iterate through all delegations from one delegator by validator-address, + // iterate through all delegations from one delegator by validator-AccAddress, // execute func for each validator - IterateDelegations(ctx Context, delegator Address, + IterateDelegations(ctx Context, delegator AccAddress, fn func(index int64, delegation Delegation) (stop bool)) } diff --git a/types/tx_msg.go b/types/tx_msg.go index fbadfb49d0..b0f5c78f4b 100644 --- a/types/tx_msg.go +++ b/types/tx_msg.go @@ -21,7 +21,7 @@ type Msg interface { // Signers returns the addrs of signers that must sign. // CONTRACT: All signatures must be present to be valid. // CONTRACT: Returns addrs in some deterministic order. - GetSigners() []Address + GetSigners() []AccAddress } //__________________________________________________________ @@ -44,10 +44,10 @@ var _ Msg = (*TestMsg)(nil) // msg type for testing type TestMsg struct { - signers []Address + signers []AccAddress } -func NewTestMsg(addrs ...Address) *TestMsg { +func NewTestMsg(addrs ...AccAddress) *TestMsg { return &TestMsg{ signers: addrs, } @@ -63,6 +63,6 @@ func (msg *TestMsg) GetSignBytes() []byte { return MustSortJSON(bz) } func (msg *TestMsg) ValidateBasic() Error { return nil } -func (msg *TestMsg) GetSigners() []Address { +func (msg *TestMsg) GetSigners() []AccAddress { return msg.signers } diff --git a/x/auth/account.go b/x/auth/account.go index 2cee668688..0e9e3075cf 100644 --- a/x/auth/account.go +++ b/x/auth/account.go @@ -11,8 +11,8 @@ import ( // Account is a standard account using a sequence number for replay protection // and a pubkey for authentication. type Account interface { - GetAddress() sdk.Address - SetAddress(sdk.Address) error // errors if already set. + GetAddress() sdk.AccAddress + SetAddress(sdk.AccAddress) error // errors if already set. GetPubKey() crypto.PubKey // can return nil. SetPubKey(crypto.PubKey) error @@ -39,26 +39,26 @@ var _ Account = (*BaseAccount)(nil) // Extend this by embedding this in your AppAccount. // See the examples/basecoin/types/account.go for an example. type BaseAccount struct { - Address sdk.Address `json:"address"` - Coins sdk.Coins `json:"coins"` - PubKey crypto.PubKey `json:"public_key"` - AccountNumber int64 `json:"account_number"` - Sequence int64 `json:"sequence"` + Address sdk.AccAddress `json:"address"` + Coins sdk.Coins `json:"coins"` + PubKey crypto.PubKey `json:"public_key"` + AccountNumber int64 `json:"account_number"` + Sequence int64 `json:"sequence"` } -func NewBaseAccountWithAddress(addr sdk.Address) BaseAccount { +func NewBaseAccountWithAddress(addr sdk.AccAddress) BaseAccount { return BaseAccount{ Address: addr, } } // Implements sdk.Account. -func (acc BaseAccount) GetAddress() sdk.Address { +func (acc BaseAccount) GetAddress() sdk.AccAddress { return acc.Address } // Implements sdk.Account. -func (acc *BaseAccount) SetAddress(addr sdk.Address) error { +func (acc *BaseAccount) SetAddress(addr sdk.AccAddress) error { if len(acc.Address) != 0 { return errors.New("cannot override BaseAccount address") } diff --git a/x/auth/account_test.go b/x/auth/account_test.go index bc7a195097..871f7f1c24 100644 --- a/x/auth/account_test.go +++ b/x/auth/account_test.go @@ -11,10 +11,10 @@ import ( wire "github.com/cosmos/cosmos-sdk/wire" ) -func keyPubAddr() (crypto.PrivKey, crypto.PubKey, sdk.Address) { +func keyPubAddr() (crypto.PrivKey, crypto.PubKey, sdk.AccAddress) { key := crypto.GenPrivKeyEd25519() pub := key.PubKey() - addr := pub.Address() + addr := sdk.AccAddress(pub.Address()) return key, pub, addr } diff --git a/x/auth/ante.go b/x/auth/ante.go index ff3145d456..cae931c7c4 100644 --- a/x/auth/ante.go +++ b/x/auth/ante.go @@ -118,7 +118,7 @@ func NewAnteHandler(am AccountMapper, fck FeeCollectionKeeper) sdk.AnteHandler { // if the account doesn't have a pubkey, set it. func processSig( ctx sdk.Context, am AccountMapper, - addr sdk.Address, sig StdSignature, signBytes []byte) ( + addr sdk.AccAddress, sig StdSignature, signBytes []byte) ( acc Account, res sdk.Result) { // Get the account. diff --git a/x/auth/ante_test.go b/x/auth/ante_test.go index aebf66f9a2..8147edb2cd 100644 --- a/x/auth/ante_test.go +++ b/x/auth/ante_test.go @@ -13,7 +13,7 @@ import ( wire "github.com/cosmos/cosmos-sdk/wire" ) -func newTestMsg(addrs ...sdk.Address) *sdk.TestMsg { +func newTestMsg(addrs ...sdk.AccAddress) *sdk.TestMsg { return sdk.NewTestMsg(addrs...) } @@ -31,9 +31,9 @@ func newCoins() sdk.Coins { } // generate a priv key and return it with its address -func privAndAddr() (crypto.PrivKey, sdk.Address) { +func privAndAddr() (crypto.PrivKey, sdk.AccAddress) { priv := crypto.GenPrivKeyEd25519() - addr := priv.PubKey().Address() + addr := sdk.AccAddress(priv.PubKey().Address()) return priv, addr } @@ -135,7 +135,7 @@ func TestAnteHandlerSigErrors(t *testing.T) { tx = newTestTx(ctx, msgs, privs, accNums, seqs, fee) // tx.GetSigners returns addresses in correct order: addr1, addr2, addr3 - expectedSigners := []sdk.Address{addr1, addr2, addr3} + expectedSigners := []sdk.AccAddress{addr1, addr2, addr3} stdTx := tx.(StdTx) require.Equal(t, expectedSigners, stdTx.GetSigners()) diff --git a/x/auth/mapper.go b/x/auth/mapper.go index ae6a19137b..88cedcb154 100644 --- a/x/auth/mapper.go +++ b/x/auth/mapper.go @@ -37,7 +37,7 @@ func NewAccountMapper(cdc *wire.Codec, key sdk.StoreKey, proto Account) AccountM } // Implaements sdk.AccountMapper. -func (am AccountMapper) NewAccountWithAddress(ctx sdk.Context, addr sdk.Address) Account { +func (am AccountMapper) NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) Account { acc := am.clonePrototype() err := acc.SetAddress(addr) if err != nil { @@ -63,12 +63,12 @@ func (am AccountMapper) NewAccount(ctx sdk.Context, acc Account) Account { } // Turn an address to key used to get it from the account store -func AddressStoreKey(addr sdk.Address) []byte { +func AddressStoreKey(addr sdk.AccAddress) []byte { return append([]byte("account:"), addr.Bytes()...) } // Implements sdk.AccountMapper. -func (am AccountMapper) GetAccount(ctx sdk.Context, addr sdk.Address) Account { +func (am AccountMapper) GetAccount(ctx sdk.Context, addr sdk.AccAddress) Account { store := ctx.KVStore(am.key) bz := store.Get(AddressStoreKey(addr)) if bz == nil { @@ -104,7 +104,7 @@ func (am AccountMapper) IterateAccounts(ctx sdk.Context, process func(Account) ( } // Returns the PubKey of the account at address -func (am AccountMapper) GetPubKey(ctx sdk.Context, addr sdk.Address) (crypto.PubKey, sdk.Error) { +func (am AccountMapper) GetPubKey(ctx sdk.Context, addr sdk.AccAddress) (crypto.PubKey, sdk.Error) { acc := am.GetAccount(ctx, addr) if acc == nil { return nil, sdk.ErrUnknownAddress(addr.String()) @@ -113,7 +113,7 @@ func (am AccountMapper) GetPubKey(ctx sdk.Context, addr sdk.Address) (crypto.Pub } // Returns the Sequence of the account at address -func (am AccountMapper) GetSequence(ctx sdk.Context, addr sdk.Address) (int64, sdk.Error) { +func (am AccountMapper) GetSequence(ctx sdk.Context, addr sdk.AccAddress) (int64, sdk.Error) { acc := am.GetAccount(ctx, addr) if acc == nil { return 0, sdk.ErrUnknownAddress(addr.String()) @@ -121,7 +121,7 @@ func (am AccountMapper) GetSequence(ctx sdk.Context, addr sdk.Address) (int64, s return acc.GetSequence(), nil } -func (am AccountMapper) setSequence(ctx sdk.Context, addr sdk.Address, newSequence int64) sdk.Error { +func (am AccountMapper) setSequence(ctx sdk.Context, addr sdk.AccAddress, newSequence int64) sdk.Error { acc := am.GetAccount(ctx, addr) if acc == nil { return sdk.ErrUnknownAddress(addr.String()) diff --git a/x/auth/mapper_test.go b/x/auth/mapper_test.go index 6b242e683b..e7271a2ae6 100644 --- a/x/auth/mapper_test.go +++ b/x/auth/mapper_test.go @@ -34,7 +34,7 @@ func TestAccountMapperGetSet(t *testing.T) { ctx := sdk.NewContext(ms, abci.Header{}, false, log.NewNopLogger()) mapper := NewAccountMapper(cdc, capKey, &BaseAccount{}) - addr := sdk.Address([]byte("some-address")) + addr := sdk.AccAddress([]byte("some-address")) // no account before its created acc := mapper.GetAccount(ctx, addr) diff --git a/x/auth/mock/app.go b/x/auth/mock/app.go index fe8fd4ee42..1ef99780d3 100644 --- a/x/auth/mock/app.go +++ b/x/auth/mock/app.go @@ -89,11 +89,11 @@ func (app *App) InitChainer(ctx sdk.Context, _ abci.RequestInitChain) abci.Respo } // Generate genesis accounts loaded with coins, and returns their addresses, pubkeys, and privkeys -func CreateGenAccounts(numAccs int64, genCoins sdk.Coins) (genAccs []auth.Account, addrs []sdk.Address, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) { +func CreateGenAccounts(numAccs int64, genCoins sdk.Coins) (genAccs []auth.Account, addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) { for i := int64(0); i < numAccs; i++ { privKey := crypto.GenPrivKeyEd25519() pubKey := privKey.PubKey() - addr := sdk.Address(pubKey.Address()) + addr := sdk.AccAddress(pubKey.Address()) genAcc := &auth.BaseAccount{ Address: addr, diff --git a/x/auth/mock/auth_app_test.go b/x/auth/mock/auth_app_test.go new file mode 100644 index 0000000000..5ee4ff95b5 --- /dev/null +++ b/x/auth/mock/auth_app_test.go @@ -0,0 +1,92 @@ +package mock + +import ( + "testing" + + "github.com/stretchr/testify/require" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth" + + abci "github.com/tendermint/tendermint/abci/types" + "github.com/tendermint/tendermint/crypto" +) + +// A mock transaction that has a validation which can fail. +type testMsg struct { + signers []sdk.AccAddress + positiveNum int64 +} + +// TODO: Clean this up, make it public +const msgType = "testMsg" + +func (tx testMsg) Type() string { return msgType } +func (tx testMsg) GetMsg() sdk.Msg { return tx } +func (tx testMsg) GetMemo() string { return "" } +func (tx testMsg) GetSignBytes() []byte { return nil } +func (tx testMsg) GetSigners() []sdk.AccAddress { return tx.signers } +func (tx testMsg) GetSignatures() []auth.StdSignature { return nil } +func (tx testMsg) ValidateBasic() sdk.Error { + if tx.positiveNum >= 0 { + return nil + } + return sdk.ErrTxDecode("positiveNum should be a non-negative integer.") +} + +// test auth module messages + +var ( + priv1 = crypto.GenPrivKeyEd25519() + addr1 = sdk.AccAddress(priv1.PubKey().Address()) + priv2 = crypto.GenPrivKeyEd25519() + addr2 = sdk.AccAddress(priv2.PubKey().Address()) + + coins = sdk.Coins{sdk.NewCoin("foocoin", 10)} + testMsg1 = testMsg{signers: []sdk.AccAddress{addr1}, positiveNum: 1} +) + +// initialize the mock application for this module +func getMockApp(t *testing.T) *App { + mapp := NewApp() + + mapp.Router().AddRoute(msgType, func(ctx sdk.Context, msg sdk.Msg) (res sdk.Result) { return }) + require.NoError(t, mapp.CompleteSetup([]*sdk.KVStoreKey{})) + return mapp +} + +func TestMsgPrivKeys(t *testing.T) { + mapp := getMockApp(t) + mapp.Cdc.RegisterConcrete(testMsg{}, "mock/testMsg", nil) + + // Construct some genesis bytes to reflect basecoin/types/AppAccount + // Give 77 foocoin to the first key + coins := sdk.Coins{sdk.NewCoin("foocoin", 77)} + acc1 := &auth.BaseAccount{ + Address: addr1, + Coins: coins, + } + accs := []auth.Account{acc1} + + // Construct genesis state + SetGenesis(mapp, accs) + + // A checkTx context (true) + ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{}) + res1 := mapp.AccountMapper.GetAccount(ctxCheck, addr1) + require.Equal(t, acc1, res1.(*auth.BaseAccount)) + + // Run a CheckDeliver + SignCheckDeliver(t, mapp.BaseApp, []sdk.Msg{testMsg1}, []int64{0}, []int64{0}, true, priv1) + + // signing a SendMsg with the wrong privKey should be an auth error + mapp.BeginBlock(abci.RequestBeginBlock{}) + tx := GenTx([]sdk.Msg{testMsg1}, []int64{0}, []int64{1}, priv2) + res := mapp.Deliver(tx) + require.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeUnauthorized), res.Code, res.Log) + + // resigning the tx with the correct priv key should still work + res = SignCheckDeliver(t, mapp.BaseApp, []sdk.Msg{testMsg1}, []int64{0}, []int64{1}, true, priv1) + + require.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeOK), res.Code, res.Log) +} diff --git a/x/auth/mock/simulate_block.go b/x/auth/mock/simulate_block.go new file mode 100644 index 0000000000..90241ae816 --- /dev/null +++ b/x/auth/mock/simulate_block.go @@ -0,0 +1,110 @@ +package mock + +import ( + "testing" + + "github.com/cosmos/cosmos-sdk/baseapp" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/crypto" + + abci "github.com/tendermint/tendermint/abci/types" +) + +var chainID = "" // TODO + +// set the mock app genesis +func SetGenesis(app *App, accs []auth.Account) { + + // pass the accounts in via the application (lazy) instead of through RequestInitChain + app.GenesisAccounts = accs + + app.InitChain(abci.RequestInitChain{}) + app.Commit() +} + +// check an account balance +func CheckBalance(t *testing.T, app *App, addr sdk.AccAddress, exp sdk.Coins) { + ctxCheck := app.BaseApp.NewContext(true, abci.Header{}) + res := app.AccountMapper.GetAccount(ctxCheck, addr) + require.Equal(t, exp, res.GetCoins()) +} + +// generate a signed transaction +func GenTx(msgs []sdk.Msg, accnums []int64, seq []int64, priv ...crypto.PrivKeyEd25519) auth.StdTx { + + // make the transaction free + fee := auth.StdFee{ + sdk.Coins{sdk.NewCoin("foocoin", 0)}, + 100000, + } + + sigs := make([]auth.StdSignature, len(priv)) + memo := "testmemotestmemo" + for i, p := range priv { + sig, err := p.Sign(auth.StdSignBytes(chainID, accnums[i], seq[i], fee, msgs, memo)) + if err != nil { + panic(err) + } + sigs[i] = auth.StdSignature{ + PubKey: p.PubKey(), + Signature: sig, + AccountNumber: accnums[i], + Sequence: seq[i], + } + } + return auth.NewStdTx(msgs, fee, sigs, memo) +} + +// generate a set of signed transactions a msg, that differ only by having the +// sequence numbers incremented between every transaction. +func GenSequenceOfTxs(msgs []sdk.Msg, accnums []int64, initSeqNums []int64, numToGenerate int, priv ...crypto.PrivKeyEd25519) []auth.StdTx { + txs := make([]auth.StdTx, numToGenerate, numToGenerate) + for i := 0; i < numToGenerate; i++ { + txs[i] = GenTx(msgs, accnums, initSeqNums, priv...) + incrementAllSequenceNumbers(initSeqNums) + } + return txs +} + +func incrementAllSequenceNumbers(initSeqNums []int64) { + for i := 0; i < len(initSeqNums); i++ { + initSeqNums[i]++ + } +} + +// check a transaction result +func SignCheck(app *baseapp.BaseApp, msgs []sdk.Msg, accnums []int64, seq []int64, priv ...crypto.PrivKeyEd25519) sdk.Result { + tx := GenTx(msgs, accnums, seq, priv...) + res := app.Check(tx) + return res +} + +// simulate a block +func SignCheckDeliver(t *testing.T, app *baseapp.BaseApp, msgs []sdk.Msg, accnums []int64, seq []int64, expPass bool, priv ...crypto.PrivKeyEd25519) sdk.Result { + + // Sign the tx + tx := GenTx(msgs, accnums, seq, priv...) + + // Run a Check + res := app.Check(tx) + if expPass { + require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log) + } else { + require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log) + } + + // Simulate a Block + app.BeginBlock(abci.RequestBeginBlock{}) + res = app.Deliver(tx) + if expPass { + require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log) + } else { + require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log) + } + app.EndBlock(abci.RequestEndBlock{}) + + app.Commit() + return res +} diff --git a/x/auth/stdtx.go b/x/auth/stdtx.go index 27d075535e..316ff5e95a 100644 --- a/x/auth/stdtx.go +++ b/x/auth/stdtx.go @@ -35,9 +35,9 @@ func (tx StdTx) GetMsgs() []sdk.Msg { return tx.Msgs } // They are accumulated from the GetSigners method for each Msg // in the order they appear in tx.GetMsgs(). // Duplicate addresses will be omitted. -func (tx StdTx) GetSigners() []sdk.Address { +func (tx StdTx) GetSigners() []sdk.AccAddress { seen := map[string]bool{} - var signers []sdk.Address + var signers []sdk.AccAddress for _, msg := range tx.GetMsgs() { for _, addr := range msg.GetSigners() { if !seen[addr.String()] { @@ -65,7 +65,7 @@ func (tx StdTx) GetSignatures() []StdSignature { return tx.Signatures } // FeePayer returns the address responsible for paying the fees // for the transactions. It's the first address returned by msg.GetSigners(). // If GetSigners() is empty, this panics. -func FeePayer(tx sdk.Tx) sdk.Address { +func FeePayer(tx sdk.Tx) sdk.AccAddress { return tx.GetMsgs()[0].GetSigners()[0] } diff --git a/x/auth/stdtx_test.go b/x/auth/stdtx_test.go index 6e6816f6b9..841470431d 100644 --- a/x/auth/stdtx_test.go +++ b/x/auth/stdtx_test.go @@ -13,7 +13,7 @@ import ( func TestStdTx(t *testing.T) { priv := crypto.GenPrivKeyEd25519() - addr := priv.PubKey().Address() + addr := sdk.AccAddress(priv.PubKey().Address()) msgs := []sdk.Msg{sdk.NewTestMsg(addr)} fee := newStdFee() sigs := []StdSignature{} diff --git a/x/bank/app_test.go b/x/bank/app_test.go index 7280ec93a6..74a421bd7e 100644 --- a/x/bank/app_test.go +++ b/x/bank/app_test.go @@ -18,12 +18,12 @@ import ( // test bank module in a mock application var ( priv1 = crypto.GenPrivKeyEd25519() - addr1 = sdk.Address(priv1.PubKey().Address()) + addr1 = sdk.AccAddress(priv1.PubKey().Address()) priv2 = crypto.GenPrivKeyEd25519() - addr2 = sdk.Address(priv2.PubKey().Address()) - addr3 = sdk.Address(crypto.GenPrivKeyEd25519().PubKey().Address()) + addr2 = sdk.AccAddress(priv2.PubKey().Address()) + addr3 = sdk.AccAddress(crypto.GenPrivKeyEd25519().PubKey().Address()) priv4 = crypto.GenPrivKeyEd25519() - addr4 = sdk.Address(priv4.PubKey().Address()) + addr4 = sdk.AccAddress(priv4.PubKey().Address()) coins = sdk.Coins{sdk.NewCoin("foocoin", 10)} halfCoins = sdk.Coins{sdk.NewCoin("foocoin", 5)} manyCoins = sdk.Coins{sdk.NewCoin("foocoin", 1), sdk.NewCoin("barcoin", 1)} diff --git a/x/bank/client/rest/sendtx.go b/x/bank/client/rest/sendtx.go index a93c0a2c7f..bba491b52a 100644 --- a/x/bank/client/rest/sendtx.go +++ b/x/bank/client/rest/sendtx.go @@ -80,7 +80,7 @@ func SendRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.CoreCont } // build message - msg := client.BuildMsg(sdk.Address(info.GetPubKey().Address()), to, m.Amount) + msg := client.BuildMsg(sdk.AccAddress(info.GetPubKey().Address()), to, m.Amount) if err != nil { // XXX rechecking same error ? w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(err.Error())) diff --git a/x/bank/client/util.go b/x/bank/client/util.go index 4d461b34f0..c733517a84 100644 --- a/x/bank/client/util.go +++ b/x/bank/client/util.go @@ -6,7 +6,7 @@ import ( ) // build the sendTx msg -func BuildMsg(from sdk.Address, to sdk.Address, coins sdk.Coins) sdk.Msg { +func BuildMsg(from sdk.AccAddress, to sdk.AccAddress, coins sdk.Coins) sdk.Msg { input := bank.NewInput(from, coins) output := bank.NewOutput(to, coins) msg := bank.NewMsgSend([]bank.Input{input}, []bank.Output{output}) diff --git a/x/bank/keeper.go b/x/bank/keeper.go index 0c8bb24f0e..1494c8cafa 100644 --- a/x/bank/keeper.go +++ b/x/bank/keeper.go @@ -26,32 +26,32 @@ func NewKeeper(am auth.AccountMapper) Keeper { } // GetCoins returns the coins at the addr. -func (keeper Keeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins { +func (keeper Keeper) GetCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins { return getCoins(ctx, keeper.am, addr) } // SetCoins sets the coins at the addr. -func (keeper Keeper) SetCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) sdk.Error { +func (keeper Keeper) SetCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) sdk.Error { return setCoins(ctx, keeper.am, addr, amt) } // HasCoins returns whether or not an account has at least amt coins. -func (keeper Keeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool { +func (keeper Keeper) HasCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) bool { return hasCoins(ctx, keeper.am, addr, amt) } // SubtractCoins subtracts amt from the coins at the addr. -func (keeper Keeper) SubtractCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { +func (keeper Keeper) SubtractCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { return subtractCoins(ctx, keeper.am, addr, amt) } // AddCoins adds amt to the coins at the addr. -func (keeper Keeper) AddCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { +func (keeper Keeper) AddCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { return addCoins(ctx, keeper.am, addr, amt) } // SendCoins moves coins from one account to another -func (keeper Keeper) SendCoins(ctx sdk.Context, fromAddr sdk.Address, toAddr sdk.Address, amt sdk.Coins) (sdk.Tags, sdk.Error) { +func (keeper Keeper) SendCoins(ctx sdk.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) (sdk.Tags, sdk.Error) { return sendCoins(ctx, keeper.am, fromAddr, toAddr, amt) } @@ -73,17 +73,17 @@ func NewSendKeeper(am auth.AccountMapper) SendKeeper { } // GetCoins returns the coins at the addr. -func (keeper SendKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins { +func (keeper SendKeeper) GetCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins { return getCoins(ctx, keeper.am, addr) } // HasCoins returns whether or not an account has at least amt coins. -func (keeper SendKeeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool { +func (keeper SendKeeper) HasCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) bool { return hasCoins(ctx, keeper.am, addr, amt) } // SendCoins moves coins from one account to another -func (keeper SendKeeper) SendCoins(ctx sdk.Context, fromAddr sdk.Address, toAddr sdk.Address, amt sdk.Coins) (sdk.Tags, sdk.Error) { +func (keeper SendKeeper) SendCoins(ctx sdk.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) (sdk.Tags, sdk.Error) { return sendCoins(ctx, keeper.am, fromAddr, toAddr, amt) } @@ -105,18 +105,18 @@ func NewViewKeeper(am auth.AccountMapper) ViewKeeper { } // GetCoins returns the coins at the addr. -func (keeper ViewKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins { +func (keeper ViewKeeper) GetCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins { return getCoins(ctx, keeper.am, addr) } // HasCoins returns whether or not an account has at least amt coins. -func (keeper ViewKeeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool { +func (keeper ViewKeeper) HasCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) bool { return hasCoins(ctx, keeper.am, addr, amt) } //______________________________________________________________________________________________ -func getCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address) sdk.Coins { +func getCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.AccAddress) sdk.Coins { ctx.GasMeter().ConsumeGas(costGetCoins, "getCoins") acc := am.GetAccount(ctx, addr) if acc == nil { @@ -125,7 +125,7 @@ func getCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address) sdk.Coin return acc.GetCoins() } -func setCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address, amt sdk.Coins) sdk.Error { +func setCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.AccAddress, amt sdk.Coins) sdk.Error { ctx.GasMeter().ConsumeGas(costSetCoins, "setCoins") acc := am.GetAccount(ctx, addr) if acc == nil { @@ -141,13 +141,13 @@ func setCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address, amt sdk. } // HasCoins returns whether or not an account has at least amt coins. -func hasCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address, amt sdk.Coins) bool { +func hasCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.AccAddress, amt sdk.Coins) bool { ctx.GasMeter().ConsumeGas(costHasCoins, "hasCoins") return getCoins(ctx, am, addr).IsGTE(amt) } // SubtractCoins subtracts amt from the coins at the addr. -func subtractCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { +func subtractCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { ctx.GasMeter().ConsumeGas(costSubtractCoins, "subtractCoins") oldCoins := getCoins(ctx, am, addr) newCoins := oldCoins.Minus(amt) @@ -160,7 +160,7 @@ func subtractCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address, amt } // AddCoins adds amt to the coins at the addr. -func addCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { +func addCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { ctx.GasMeter().ConsumeGas(costAddCoins, "addCoins") oldCoins := getCoins(ctx, am, addr) newCoins := oldCoins.Plus(amt) @@ -174,7 +174,7 @@ func addCoins(ctx sdk.Context, am auth.AccountMapper, addr sdk.Address, amt sdk. // SendCoins moves coins from one account to another // NOTE: Make sure to revert state changes from tx on error -func sendCoins(ctx sdk.Context, am auth.AccountMapper, fromAddr sdk.Address, toAddr sdk.Address, amt sdk.Coins) (sdk.Tags, sdk.Error) { +func sendCoins(ctx sdk.Context, am auth.AccountMapper, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) (sdk.Tags, sdk.Error) { _, subTags, err := subtractCoins(ctx, am, fromAddr, amt) if err != nil { return nil, err diff --git a/x/bank/keeper_test.go b/x/bank/keeper_test.go index c545b774f0..7b27d45faa 100644 --- a/x/bank/keeper_test.go +++ b/x/bank/keeper_test.go @@ -36,9 +36,9 @@ func TestKeeper(t *testing.T) { accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{}) coinKeeper := NewKeeper(accountMapper) - addr := sdk.Address([]byte("addr1")) - addr2 := sdk.Address([]byte("addr2")) - addr3 := sdk.Address([]byte("addr3")) + addr := sdk.AccAddress([]byte("addr1")) + addr2 := sdk.AccAddress([]byte("addr2")) + addr3 := sdk.AccAddress([]byte("addr3")) acc := accountMapper.NewAccountWithAddress(ctx, addr) // Test GetCoins/SetCoins @@ -122,9 +122,9 @@ func TestSendKeeper(t *testing.T) { coinKeeper := NewKeeper(accountMapper) sendKeeper := NewSendKeeper(accountMapper) - addr := sdk.Address([]byte("addr1")) - addr2 := sdk.Address([]byte("addr2")) - addr3 := sdk.Address([]byte("addr3")) + addr := sdk.AccAddress([]byte("addr1")) + addr2 := sdk.AccAddress([]byte("addr2")) + addr3 := sdk.AccAddress([]byte("addr3")) acc := accountMapper.NewAccountWithAddress(ctx, addr) // Test GetCoins/SetCoins @@ -191,7 +191,7 @@ func TestViewKeeper(t *testing.T) { coinKeeper := NewKeeper(accountMapper) viewKeeper := NewViewKeeper(accountMapper) - addr := sdk.Address([]byte("addr1")) + addr := sdk.AccAddress([]byte("addr1")) acc := accountMapper.NewAccountWithAddress(ctx, addr) // Test GetCoins/SetCoins diff --git a/x/bank/msgs.go b/x/bank/msgs.go index d8160fe904..316d66ba13 100644 --- a/x/bank/msgs.go +++ b/x/bank/msgs.go @@ -76,8 +76,8 @@ func (msg MsgSend) GetSignBytes() []byte { } // Implements Msg. -func (msg MsgSend) GetSigners() []sdk.Address { - addrs := make([]sdk.Address, len(msg.Inputs)) +func (msg MsgSend) GetSigners() []sdk.AccAddress { + addrs := make([]sdk.AccAddress, len(msg.Inputs)) for i, in := range msg.Inputs { addrs[i] = in.Address } @@ -89,14 +89,14 @@ func (msg MsgSend) GetSigners() []sdk.Address { // MsgIssue - high level transaction of the coin module type MsgIssue struct { - Banker sdk.Address `json:"banker"` - Outputs []Output `json:"outputs"` + Banker sdk.AccAddress `json:"banker"` + Outputs []Output `json:"outputs"` } var _ sdk.Msg = MsgIssue{} // NewMsgIssue - construct arbitrary multi-in, multi-out send msg. -func NewMsgIssue(banker sdk.Address, out []Output) MsgIssue { +func NewMsgIssue(banker sdk.AccAddress, out []Output) MsgIssue { return MsgIssue{Banker: banker, Outputs: out} } @@ -124,7 +124,7 @@ func (msg MsgIssue) GetSignBytes() []byte { outputs = append(outputs, output.GetSignBytes()) } b, err := msgCdc.MarshalJSON(struct { - Banker sdk.Address `json:"banker"` + Banker sdk.AccAddress `json:"banker"` Outputs []json.RawMessage `json:"outputs"` }{ Banker: msg.Banker, @@ -137,8 +137,8 @@ func (msg MsgIssue) GetSignBytes() []byte { } // Implements Msg. -func (msg MsgIssue) GetSigners() []sdk.Address { - return []sdk.Address{msg.Banker} +func (msg MsgIssue) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.Banker} } //---------------------------------------- @@ -146,8 +146,8 @@ func (msg MsgIssue) GetSigners() []sdk.Address { // Transaction Input type Input struct { - Address sdk.Address `json:"address"` - Coins sdk.Coins `json:"coins"` + Address sdk.AccAddress `json:"address"` + Coins sdk.Coins `json:"coins"` } // Return bytes to sign for Input @@ -174,7 +174,7 @@ func (in Input) ValidateBasic() sdk.Error { } // NewInput - create a transaction input, used with MsgSend -func NewInput(addr sdk.Address, coins sdk.Coins) Input { +func NewInput(addr sdk.AccAddress, coins sdk.Coins) Input { input := Input{ Address: addr, Coins: coins, @@ -187,8 +187,8 @@ func NewInput(addr sdk.Address, coins sdk.Coins) Input { // Transaction Output type Output struct { - Address sdk.Address `json:"address"` - Coins sdk.Coins `json:"coins"` + Address sdk.AccAddress `json:"address"` + Coins sdk.Coins `json:"coins"` } // Return bytes to sign for Output @@ -215,7 +215,7 @@ func (out Output) ValidateBasic() sdk.Error { } // NewOutput - create a transaction output, used with MsgSend -func NewOutput(addr sdk.Address, coins sdk.Coins) Output { +func NewOutput(addr sdk.AccAddress, coins sdk.Coins) Output { output := Output{ Address: addr, Coins: coins, diff --git a/x/bank/msgs_test.go b/x/bank/msgs_test.go index f4e7363d3b..b60cc65ad0 100644 --- a/x/bank/msgs_test.go +++ b/x/bank/msgs_test.go @@ -13,8 +13,8 @@ func TestNewMsgSend(t *testing.T) {} func TestMsgSendType(t *testing.T) { // Construct a MsgSend - addr1 := sdk.Address([]byte("input")) - addr2 := sdk.Address([]byte("output")) + addr1 := sdk.AccAddress([]byte("input")) + addr2 := sdk.AccAddress([]byte("output")) coins := sdk.Coins{sdk.NewCoin("atom", 10)} var msg = MsgSend{ Inputs: []Input{NewInput(addr1, coins)}, @@ -26,12 +26,12 @@ func TestMsgSendType(t *testing.T) { } func TestInputValidation(t *testing.T) { - addr1 := sdk.Address([]byte{1, 2}) - addr2 := sdk.Address([]byte{7, 8}) + addr1 := sdk.AccAddress([]byte{1, 2}) + addr2 := sdk.AccAddress([]byte{7, 8}) someCoins := sdk.Coins{sdk.NewCoin("atom", 123)} multiCoins := sdk.Coins{sdk.NewCoin("atom", 123), sdk.NewCoin("eth", 20)} - var emptyAddr sdk.Address + var emptyAddr sdk.AccAddress emptyCoins := sdk.Coins{} emptyCoins2 := sdk.Coins{sdk.NewCoin("eth", 0)} someEmptyCoins := sdk.Coins{sdk.NewCoin("eth", 10), sdk.NewCoin("atom", 0)} @@ -68,12 +68,12 @@ func TestInputValidation(t *testing.T) { } func TestOutputValidation(t *testing.T) { - addr1 := sdk.Address([]byte{1, 2}) - addr2 := sdk.Address([]byte{7, 8}) + addr1 := sdk.AccAddress([]byte{1, 2}) + addr2 := sdk.AccAddress([]byte{7, 8}) someCoins := sdk.Coins{sdk.NewCoin("atom", 123)} multiCoins := sdk.Coins{sdk.NewCoin("atom", 123), sdk.NewCoin("eth", 20)} - var emptyAddr sdk.Address + var emptyAddr sdk.AccAddress emptyCoins := sdk.Coins{} emptyCoins2 := sdk.Coins{sdk.NewCoin("eth", 0)} someEmptyCoins := sdk.Coins{sdk.NewCoin("eth", 10), sdk.NewCoin("atom", 0)} @@ -110,8 +110,8 @@ func TestOutputValidation(t *testing.T) { } func TestMsgSendValidation(t *testing.T) { - addr1 := sdk.Address([]byte{1, 2}) - addr2 := sdk.Address([]byte{7, 8}) + addr1 := sdk.AccAddress([]byte{1, 2}) + addr2 := sdk.AccAddress([]byte{7, 8}) atom123 := sdk.Coins{sdk.NewCoin("atom", 123)} atom124 := sdk.Coins{sdk.NewCoin("atom", 124)} eth123 := sdk.Coins{sdk.NewCoin("eth", 123)} @@ -124,7 +124,7 @@ func TestMsgSendValidation(t *testing.T) { output3 := NewOutput(addr2, eth123) outputMulti := NewOutput(addr2, atom123eth123) - var emptyAddr sdk.Address + var emptyAddr sdk.AccAddress cases := []struct { valid bool @@ -178,8 +178,8 @@ func TestMsgSendValidation(t *testing.T) { } func TestMsgSendGetSignBytes(t *testing.T) { - addr1 := sdk.Address([]byte("input")) - addr2 := sdk.Address([]byte("output")) + addr1 := sdk.AccAddress([]byte("input")) + addr2 := sdk.AccAddress([]byte("output")) coins := sdk.Coins{sdk.NewCoin("atom", 10)} var msg = MsgSend{ Inputs: []Input{NewInput(addr1, coins)}, @@ -194,9 +194,9 @@ func TestMsgSendGetSignBytes(t *testing.T) { func TestMsgSendGetSigners(t *testing.T) { var msg = MsgSend{ Inputs: []Input{ - NewInput(sdk.Address([]byte("input1")), nil), - NewInput(sdk.Address([]byte("input2")), nil), - NewInput(sdk.Address([]byte("input3")), nil), + NewInput(sdk.AccAddress([]byte("input1")), nil), + NewInput(sdk.AccAddress([]byte("input2")), nil), + NewInput(sdk.AccAddress([]byte("input3")), nil), }, } res := msg.GetSigners() @@ -207,7 +207,7 @@ func TestMsgSendGetSigners(t *testing.T) { /* // what to do w/ this test? func TestMsgSendSigners(t *testing.T) { - signers := []sdk.Address{ + signers := []sdk.AccAddress{ {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, @@ -233,10 +233,10 @@ func TestNewMsgIssue(t *testing.T) { func TestMsgIssueType(t *testing.T) { // Construct an MsgIssue - addr := sdk.Address([]byte("loan-from-bank")) + addr := sdk.AccAddress([]byte("loan-from-bank")) coins := sdk.Coins{sdk.NewCoin("atom", 10)} var msg = MsgIssue{ - Banker: sdk.Address([]byte("input")), + Banker: sdk.AccAddress([]byte("input")), Outputs: []Output{NewOutput(addr, coins)}, } @@ -249,10 +249,10 @@ func TestMsgIssueValidation(t *testing.T) { } func TestMsgIssueGetSignBytes(t *testing.T) { - addr := sdk.Address([]byte("loan-from-bank")) + addr := sdk.AccAddress([]byte("loan-from-bank")) coins := sdk.Coins{sdk.NewCoin("atom", 10)} var msg = MsgIssue{ - Banker: sdk.Address([]byte("input")), + Banker: sdk.AccAddress([]byte("input")), Outputs: []Output{NewOutput(addr, coins)}, } res := msg.GetSignBytes() @@ -263,7 +263,7 @@ func TestMsgIssueGetSignBytes(t *testing.T) { func TestMsgIssueGetSigners(t *testing.T) { var msg = MsgIssue{ - Banker: sdk.Address([]byte("onlyone")), + Banker: sdk.AccAddress([]byte("onlyone")), } res := msg.GetSigners() require.Equal(t, fmt.Sprintf("%v", res), "[6F6E6C796F6E65]") diff --git a/x/gov/client/rest/rest.go b/x/gov/client/rest/rest.go index 3e185dc914..6ffed71f39 100644 --- a/x/gov/client/rest/rest.go +++ b/x/gov/client/rest/rest.go @@ -375,8 +375,8 @@ func queryProposalsWithParameterFn(cdc *wire.Codec) http.HandlerFunc { bechDepositerAddr := r.URL.Query().Get(RestDepositer) var err error - var voterAddr sdk.Address - var depositerAddr sdk.Address + var voterAddr sdk.AccAddress + var depositerAddr sdk.AccAddress if len(bechVoterAddr) != 0 { voterAddr, err = sdk.GetAccAddressBech32(bechVoterAddr) diff --git a/x/gov/depositsvotes.go b/x/gov/depositsvotes.go index f45f5b557c..5ec5651897 100644 --- a/x/gov/depositsvotes.go +++ b/x/gov/depositsvotes.go @@ -18,16 +18,16 @@ const ( // Vote type Vote struct { - Voter sdk.Address `json:"voter"` // address of the voter - ProposalID int64 `json:"proposal_id"` // proposalID of the proposal - Option VoteOption `json:"option"` // option from OptionSet chosen by the voter + Voter sdk.AccAddress `json:"voter"` // address of the voter + ProposalID int64 `json:"proposal_id"` // proposalID of the proposal + Option VoteOption `json:"option"` // option from OptionSet chosen by the voter } // Deposit type Deposit struct { - Depositer sdk.Address `json:"depositer"` // Address of the depositer - ProposalID int64 `json:"proposal_id"` // proposalID of the proposal - Amount sdk.Coins `json:"amount"` // Deposit amount + Depositer sdk.AccAddress `json:"depositer"` // Address of the depositer + ProposalID int64 `json:"proposal_id"` // proposalID of the proposal + Amount sdk.Coins `json:"amount"` // Deposit amount } // ProposalTypeToString for pretty prints of ProposalType @@ -77,9 +77,9 @@ func StringToVoteOption(str string) (VoteOption, sdk.Error) { // Rest Deposits type DepositRest struct { - Depositer sdk.Address `json:"depositer"` // address of the depositer - ProposalID int64 `json:"proposal_id"` // proposalID of the proposal - Amount sdk.Coins `json:"option"` + Depositer sdk.AccAddress `json:"depositer"` // address of the depositer + ProposalID int64 `json:"proposal_id"` // proposalID of the proposal + Amount sdk.Coins `json:"option"` } // Turn any Deposit to a DepositRest @@ -93,9 +93,9 @@ func DepositToRest(deposit Deposit) DepositRest { // Rest Votes type VoteRest struct { - Voter sdk.Address `json:"voter"` // address of the voter - ProposalID int64 `json:"proposal_id"` // proposalID of the proposal - Option string `json:"option"` + Voter sdk.AccAddress `json:"voter"` // address of the voter + ProposalID int64 `json:"proposal_id"` // proposalID of the proposal + Option string `json:"option"` } // Turn any Vote to a VoteRest diff --git a/x/gov/errors.go b/x/gov/errors.go index cd7c72bf51..e1f2f27937 100644 --- a/x/gov/errors.go +++ b/x/gov/errors.go @@ -41,7 +41,7 @@ func ErrAlreadyFinishedProposal(codespace sdk.CodespaceType, proposalID int64) s return sdk.NewError(codespace, CodeAlreadyFinishedProposal, fmt.Sprintf("Proposal %d has already passed its voting period", proposalID)) } -func ErrAddressNotStaked(codespace sdk.CodespaceType, address sdk.Address) sdk.Error { +func ErrAddressNotStaked(codespace sdk.CodespaceType, address sdk.AccAddress) sdk.Error { return sdk.NewError(codespace, CodeAddressNotStaked, fmt.Sprintf("Address %s is not staked and is thus ineligible to vote", address)) } diff --git a/x/gov/handler.go b/x/gov/handler.go index dc218953ae..636454571d 100644 --- a/x/gov/handler.go +++ b/x/gov/handler.go @@ -93,7 +93,7 @@ func handleMsgVote(ctx sdk.Context, keeper Keeper, msg MsgVote) sdk.Result { } // Called every block, process inflation, update validator set -func EndBlocker(ctx sdk.Context, keeper Keeper) (tags sdk.Tags, nonVotingVals []sdk.Address) { +func EndBlocker(ctx sdk.Context, keeper Keeper) (tags sdk.Tags, nonVotingVals []sdk.AccAddress) { tags = sdk.NewTags() diff --git a/x/gov/keeper.go b/x/gov/keeper.go index c22cd3dfe7..d966a78a2f 100644 --- a/x/gov/keeper.go +++ b/x/gov/keeper.go @@ -156,7 +156,7 @@ func (keeper Keeper) GetTallyingProcedure() TallyingProcedure { // Votes // Adds a vote on a specific proposal -func (keeper Keeper) AddVote(ctx sdk.Context, proposalID int64, voterAddr sdk.Address, option VoteOption) sdk.Error { +func (keeper Keeper) AddVote(ctx sdk.Context, proposalID int64, voterAddr sdk.AccAddress, option VoteOption) sdk.Error { proposal := keeper.GetProposal(ctx, proposalID) if proposal == nil { return ErrUnknownProposal(keeper.codespace, proposalID) @@ -180,7 +180,7 @@ func (keeper Keeper) AddVote(ctx sdk.Context, proposalID int64, voterAddr sdk.Ad } // Gets the vote of a specific voter on a specific proposal -func (keeper Keeper) GetVote(ctx sdk.Context, proposalID int64, voterAddr sdk.Address) (Vote, bool) { +func (keeper Keeper) GetVote(ctx sdk.Context, proposalID int64, voterAddr sdk.AccAddress) (Vote, bool) { store := ctx.KVStore(keeper.storeKey) bz := store.Get(KeyVote(proposalID, voterAddr)) if bz == nil { @@ -191,7 +191,7 @@ func (keeper Keeper) GetVote(ctx sdk.Context, proposalID int64, voterAddr sdk.Ad return vote, true } -func (keeper Keeper) setVote(ctx sdk.Context, proposalID int64, voterAddr sdk.Address, vote Vote) { +func (keeper Keeper) setVote(ctx sdk.Context, proposalID int64, voterAddr sdk.AccAddress, vote Vote) { store := ctx.KVStore(keeper.storeKey) bz := keeper.cdc.MustMarshalBinary(vote) store.Set(KeyVote(proposalID, voterAddr), bz) @@ -203,7 +203,7 @@ func (keeper Keeper) GetVotes(ctx sdk.Context, proposalID int64) sdk.Iterator { return sdk.KVStorePrefixIterator(store, KeyVotesSubspace(proposalID)) } -func (keeper Keeper) deleteVote(ctx sdk.Context, proposalID int64, voterAddr sdk.Address) { +func (keeper Keeper) deleteVote(ctx sdk.Context, proposalID int64, voterAddr sdk.AccAddress) { store := ctx.KVStore(keeper.storeKey) store.Delete(KeyVote(proposalID, voterAddr)) } @@ -212,7 +212,7 @@ func (keeper Keeper) deleteVote(ctx sdk.Context, proposalID int64, voterAddr sdk // Deposits // Gets the deposit of a specific depositer on a specific proposal -func (keeper Keeper) GetDeposit(ctx sdk.Context, proposalID int64, depositerAddr sdk.Address) (Deposit, bool) { +func (keeper Keeper) GetDeposit(ctx sdk.Context, proposalID int64, depositerAddr sdk.AccAddress) (Deposit, bool) { store := ctx.KVStore(keeper.storeKey) bz := store.Get(KeyDeposit(proposalID, depositerAddr)) if bz == nil { @@ -223,7 +223,7 @@ func (keeper Keeper) GetDeposit(ctx sdk.Context, proposalID int64, depositerAddr return deposit, true } -func (keeper Keeper) setDeposit(ctx sdk.Context, proposalID int64, depositerAddr sdk.Address, deposit Deposit) { +func (keeper Keeper) setDeposit(ctx sdk.Context, proposalID int64, depositerAddr sdk.AccAddress, deposit Deposit) { store := ctx.KVStore(keeper.storeKey) bz := keeper.cdc.MustMarshalBinary(deposit) store.Set(KeyDeposit(proposalID, depositerAddr), bz) @@ -231,7 +231,7 @@ func (keeper Keeper) setDeposit(ctx sdk.Context, proposalID int64, depositerAddr // Adds or updates a deposit of a specific depositer on a specific proposal // Activates voting period when appropriate -func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID int64, depositerAddr sdk.Address, depositAmount sdk.Coins) (sdk.Error, bool) { +func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID int64, depositerAddr sdk.AccAddress, depositAmount sdk.Coins) (sdk.Error, bool) { // Checks to see if proposal exists proposal := keeper.GetProposal(ctx, proposalID) if proposal == nil { diff --git a/x/gov/keeper_keys.go b/x/gov/keeper_keys.go index 8150c2b162..7b1bf43f2f 100644 --- a/x/gov/keeper_keys.go +++ b/x/gov/keeper_keys.go @@ -21,12 +21,12 @@ func KeyProposal(proposalID int64) []byte { } // Key for getting a specific deposit from the store -func KeyDeposit(proposalID int64, depositerAddr sdk.Address) []byte { +func KeyDeposit(proposalID int64, depositerAddr sdk.AccAddress) []byte { return []byte(fmt.Sprintf("deposits:%d:%d", proposalID, depositerAddr)) } // Key for getting a specific vote from the store -func KeyVote(proposalID int64, voterAddr sdk.Address) []byte { +func KeyVote(proposalID int64, voterAddr sdk.AccAddress) []byte { return []byte(fmt.Sprintf("votes:%d:%d", proposalID, voterAddr)) } diff --git a/x/gov/msgs.go b/x/gov/msgs.go index 75a8d51e39..5b38861eef 100644 --- a/x/gov/msgs.go +++ b/x/gov/msgs.go @@ -12,14 +12,14 @@ const MsgType = "gov" //----------------------------------------------------------- // MsgSubmitProposal type MsgSubmitProposal struct { - Title string // Title of the proposal - Description string // Description of the proposal - ProposalType ProposalKind // Type of proposal. Initial set {PlainTextProposal, SoftwareUpgradeProposal} - Proposer sdk.Address // Address of the proposer - InitialDeposit sdk.Coins // Initial deposit paid by sender. Must be strictly positive. + Title string // Title of the proposal + Description string // Description of the proposal + ProposalType ProposalKind // Type of proposal. Initial set {PlainTextProposal, SoftwareUpgradeProposal} + Proposer sdk.AccAddress // Address of the proposer + InitialDeposit sdk.Coins // Initial deposit paid by sender. Must be strictly positive. } -func NewMsgSubmitProposal(title string, description string, proposalType ProposalKind, proposer sdk.Address, initialDeposit sdk.Coins) MsgSubmitProposal { +func NewMsgSubmitProposal(title string, description string, proposalType ProposalKind, proposer sdk.AccAddress, initialDeposit sdk.Coins) MsgSubmitProposal { return MsgSubmitProposal{ Title: title, Description: description, @@ -67,16 +67,16 @@ func (msg MsgSubmitProposal) Get(key interface{}) (value interface{}) { // Implements Msg. func (msg MsgSubmitProposal) GetSignBytes() []byte { b, err := msgCdc.MarshalJSON(struct { - Title string `json:"title"` - Description string `json:"description"` - ProposalType string `json:"proposal_type"` - Proposer string `json:"proposer"` - InitialDeposit sdk.Coins `json:"deposit"` + Title string `json:"title"` + Description string `json:"description"` + ProposalType string `json:"proposal_type"` + Proposer sdk.AccAddress `json:"proposer"` + InitialDeposit sdk.Coins `json:"deposit"` }{ Title: msg.Title, Description: msg.Description, ProposalType: ProposalTypeToString(msg.ProposalType), - Proposer: sdk.MustBech32ifyVal(msg.Proposer), + Proposer: msg.Proposer, InitialDeposit: msg.InitialDeposit, }) if err != nil { @@ -86,19 +86,19 @@ func (msg MsgSubmitProposal) GetSignBytes() []byte { } // Implements Msg. -func (msg MsgSubmitProposal) GetSigners() []sdk.Address { - return []sdk.Address{msg.Proposer} +func (msg MsgSubmitProposal) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.Proposer} } //----------------------------------------------------------- // MsgDeposit type MsgDeposit struct { - ProposalID int64 `json:"proposalID"` // ID of the proposal - Depositer sdk.Address `json:"depositer"` // Address of the depositer - Amount sdk.Coins `json:"amount"` // Coins to add to the proposal's deposit + ProposalID int64 `json:"proposalID"` // ID of the proposal + Depositer sdk.AccAddress `json:"depositer"` // Address of the depositer + Amount sdk.Coins `json:"amount"` // Coins to add to the proposal's deposit } -func NewMsgDeposit(depositer sdk.Address, proposalID int64, amount sdk.Coins) MsgDeposit { +func NewMsgDeposit(depositer sdk.AccAddress, proposalID int64, amount sdk.Coins) MsgDeposit { return MsgDeposit{ ProposalID: proposalID, Depositer: depositer, @@ -138,12 +138,12 @@ func (msg MsgDeposit) Get(key interface{}) (value interface{}) { // Implements Msg. func (msg MsgDeposit) GetSignBytes() []byte { b, err := msgCdc.MarshalJSON(struct { - ProposalID int64 `json:"proposalID"` - Depositer string `json:"proposer"` - Amount sdk.Coins `json:"deposit"` + ProposalID int64 `json:"proposalID"` + Depositer sdk.AccAddress `json:"proposer"` + Amount sdk.Coins `json:"deposit"` }{ ProposalID: msg.ProposalID, - Depositer: sdk.MustBech32ifyVal(msg.Depositer), + Depositer: msg.Depositer, Amount: msg.Amount, }) if err != nil { @@ -153,19 +153,19 @@ func (msg MsgDeposit) GetSignBytes() []byte { } // Implements Msg. -func (msg MsgDeposit) GetSigners() []sdk.Address { - return []sdk.Address{msg.Depositer} +func (msg MsgDeposit) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.Depositer} } //----------------------------------------------------------- // MsgVote type MsgVote struct { - ProposalID int64 // proposalID of the proposal - Voter sdk.Address // address of the voter - Option VoteOption // option from OptionSet chosen by the voter + ProposalID int64 // proposalID of the proposal + Voter sdk.AccAddress // address of the voter + Option VoteOption // option from OptionSet chosen by the voter } -func NewMsgVote(voter sdk.Address, proposalID int64, option VoteOption) MsgVote { +func NewMsgVote(voter sdk.AccAddress, proposalID int64, option VoteOption) MsgVote { return MsgVote{ ProposalID: proposalID, Voter: voter, @@ -202,12 +202,12 @@ func (msg MsgVote) Get(key interface{}) (value interface{}) { // Implements Msg. func (msg MsgVote) GetSignBytes() []byte { b, err := msgCdc.MarshalJSON(struct { - ProposalID int64 `json:"proposalID"` - Voter string `json:"voter"` - Option string `json:"option"` + ProposalID int64 `json:"proposalID"` + Voter sdk.AccAddress `json:"voter"` + Option string `json:"option"` }{ ProposalID: msg.ProposalID, - Voter: sdk.MustBech32ifyVal(msg.Voter), + Voter: msg.Voter, Option: VoteOptionToString(msg.Option), }) if err != nil { @@ -217,6 +217,6 @@ func (msg MsgVote) GetSignBytes() []byte { } // Implements Msg. -func (msg MsgVote) GetSigners() []sdk.Address { - return []sdk.Address{msg.Voter} +func (msg MsgVote) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.Voter} } diff --git a/x/gov/msgs_test.go b/x/gov/msgs_test.go index d0a6292997..fd526c7fa7 100644 --- a/x/gov/msgs_test.go +++ b/x/gov/msgs_test.go @@ -23,7 +23,7 @@ func TestMsgSubmitProposal(t *testing.T) { tests := []struct { title, description string proposalType byte - proposerAddr sdk.Address + proposerAddr sdk.AccAddress initialDeposit sdk.Coins expectPass bool }{ @@ -33,7 +33,7 @@ func TestMsgSubmitProposal(t *testing.T) { {"Test Proposal", "the purpose of this proposal is to test", ProposalTypeParameterChange, addrs[0], coinsPos, true}, {"Test Proposal", "the purpose of this proposal is to test", ProposalTypeSoftwareUpgrade, addrs[0], coinsPos, true}, {"Test Proposal", "the purpose of this proposal is to test", 0x05, addrs[0], coinsPos, false}, - {"Test Proposal", "the purpose of this proposal is to test", ProposalTypeText, sdk.Address{}, coinsPos, false}, + {"Test Proposal", "the purpose of this proposal is to test", ProposalTypeText, sdk.AccAddress{}, coinsPos, false}, {"Test Proposal", "the purpose of this proposal is to test", ProposalTypeText, addrs[0], coinsZero, true}, {"Test Proposal", "the purpose of this proposal is to test", ProposalTypeText, addrs[0], coinsNeg, false}, {"Test Proposal", "the purpose of this proposal is to test", ProposalTypeText, addrs[0], coinsMulti, true}, @@ -54,13 +54,13 @@ func TestMsgDeposit(t *testing.T) { _, addrs, _, _ := mock.CreateGenAccounts(1, sdk.Coins{}) tests := []struct { proposalID int64 - depositerAddr sdk.Address + depositerAddr sdk.AccAddress depositAmount sdk.Coins expectPass bool }{ {0, addrs[0], coinsPos, true}, {-1, addrs[0], coinsPos, false}, - {1, sdk.Address{}, coinsPos, false}, + {1, sdk.AccAddress{}, coinsPos, false}, {1, addrs[0], coinsZero, true}, {1, addrs[0], coinsNeg, false}, {1, addrs[0], coinsMulti, true}, @@ -81,13 +81,13 @@ func TestMsgVote(t *testing.T) { _, addrs, _, _ := mock.CreateGenAccounts(1, sdk.Coins{}) tests := []struct { proposalID int64 - voterAddr sdk.Address + voterAddr sdk.AccAddress option VoteOption expectPass bool }{ {0, addrs[0], OptionYes, true}, {-1, addrs[0], OptionYes, false}, - {0, sdk.Address{}, OptionYes, false}, + {0, sdk.AccAddress{}, OptionYes, false}, {0, addrs[0], OptionNo, true}, {0, addrs[0], OptionNoWithVeto, true}, {0, addrs[0], OptionAbstain, true}, diff --git a/x/gov/tally.go b/x/gov/tally.go index c5e0ec763b..38462e72d0 100644 --- a/x/gov/tally.go +++ b/x/gov/tally.go @@ -6,14 +6,14 @@ import ( // validatorGovInfo used for tallying type validatorGovInfo struct { - Address sdk.Address // sdk.Address of the validator owner - Power sdk.Rat // Power of a Validator - DelegatorShares sdk.Rat // Total outstanding delegator shares - Minus sdk.Rat // Minus of validator, used to compute validator's voting power - Vote VoteOption // Vote of the validator + Address sdk.AccAddress // sdk.AccAddress of the validator owner + Power sdk.Rat // Power of a Validator + DelegatorShares sdk.Rat // Total outstanding delegator shares + Minus sdk.Rat // Minus of validator, used to compute validator's voting power + Vote VoteOption // Vote of the validator } -func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, nonVoting []sdk.Address) { +func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, nonVoting []sdk.AccAddress) { results := make(map[VoteOption]sdk.Rat) results[OptionYes] = sdk.ZeroRat() results[OptionAbstain] = sdk.ZeroRat() @@ -67,7 +67,7 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, nonV votesIterator.Close() // Iterate over the validators again to tally their voting power and see who didn't vote - nonVoting = []sdk.Address{} + nonVoting = []sdk.AccAddress{} for _, val := range currValidators { if val.Vote == OptionEmpty { nonVoting = append(nonVoting, val.Address) diff --git a/x/gov/test_common.go b/x/gov/test_common.go index 70e47e86d7..7020a780bf 100644 --- a/x/gov/test_common.go +++ b/x/gov/test_common.go @@ -18,7 +18,7 @@ import ( ) // initialize the mock application for this module -func getMockApp(t *testing.T, numGenAccs int) (*mock.App, Keeper, stake.Keeper, []sdk.Address, []crypto.PubKey, []crypto.PrivKey) { +func getMockApp(t *testing.T, numGenAccs int) (*mock.App, Keeper, stake.Keeper, []sdk.AccAddress, []crypto.PubKey, []crypto.PrivKey) { mapp := mock.NewApp() stake.RegisterWire(mapp.Cdc) @@ -68,7 +68,7 @@ func getInitChainer(mapp *mock.App, keeper Keeper, stakeKeeper stake.Keeper) sdk } // Sorts Addresses -func SortAddresses(addrs []sdk.Address) { +func SortAddresses(addrs []sdk.AccAddress) { var byteAddrs [][]byte for _, addr := range addrs { byteAddrs = append(byteAddrs, addr.Bytes()) diff --git a/x/ibc/app_test.go b/x/ibc/app_test.go index 3002f5ed61..4c559cb350 100644 --- a/x/ibc/app_test.go +++ b/x/ibc/app_test.go @@ -35,7 +35,7 @@ func TestIBCMsgs(t *testing.T) { destChain := "dest-chain" priv1 := crypto.GenPrivKeyEd25519() - addr1 := sdk.Address(priv1.PubKey().Address()) + addr1 := sdk.AccAddress(priv1.PubKey().Address()) coins := sdk.Coins{sdk.NewCoin("foocoin", 10)} var emptyCoins sdk.Coins diff --git a/x/ibc/client/cli/ibctx.go b/x/ibc/client/cli/ibctx.go index 21aa3a3089..f5505d9a47 100644 --- a/x/ibc/client/cli/ibctx.go +++ b/x/ibc/client/cli/ibctx.go @@ -56,7 +56,7 @@ func IBCTransferCmd(cdc *wire.Codec) *cobra.Command { return cmd } -func buildMsg(from sdk.Address) (sdk.Msg, error) { +func buildMsg(from sdk.AccAddress) (sdk.Msg, error) { amount := viper.GetString(flagAmount) coins, err := sdk.ParseCoins(amount) if err != nil { @@ -68,7 +68,7 @@ func buildMsg(from sdk.Address) (sdk.Msg, error) { if err != nil { return nil, err } - to := sdk.Address(bz) + to := sdk.AccAddress(bz) packet := ibc.NewIBCPacket(from, to, coins, viper.GetString(client.FlagChainID), viper.GetString(flagChain)) diff --git a/x/ibc/client/cli/relay.go b/x/ibc/client/cli/relay.go index d434ff35a4..7ca44a94d5 100644 --- a/x/ibc/client/cli/relay.go +++ b/x/ibc/client/cli/relay.go @@ -27,7 +27,7 @@ const ( type relayCommander struct { cdc *wire.Codec - address sdk.Address + address sdk.AccAddress decoder auth.AccountDecoder mainStore string ibcStore string diff --git a/x/ibc/client/rest/transfer.go b/x/ibc/client/rest/transfer.go index f9173a153d..139b79aee1 100644 --- a/x/ibc/client/rest/transfer.go +++ b/x/ibc/client/rest/transfer.go @@ -73,10 +73,10 @@ func TransferRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.Core w.Write([]byte(err.Error())) return } - to := sdk.Address(bz) + to := sdk.AccAddress(bz) // build message - packet := ibc.NewIBCPacket(sdk.Address(info.GetPubKey().Address()), to, m.Amount, m.SrcChainID, destChainID) + packet := ibc.NewIBCPacket(sdk.AccAddress(info.GetPubKey().Address()), to, m.Amount, m.SrcChainID, destChainID) msg := ibc.IBCTransferMsg{packet} // add gas to context diff --git a/x/ibc/ibc_test.go b/x/ibc/ibc_test.go index 1d87e7806b..8c91921bd3 100644 --- a/x/ibc/ibc_test.go +++ b/x/ibc/ibc_test.go @@ -28,11 +28,11 @@ func defaultContext(key sdk.StoreKey) sdk.Context { return ctx } -func newAddress() crypto.Address { - return crypto.GenPrivKeyEd25519().PubKey().Address() +func newAddress() sdk.AccAddress { + return sdk.AccAddress(crypto.GenPrivKeyEd25519().PubKey().Address()) } -func getCoins(ck bank.Keeper, ctx sdk.Context, addr crypto.Address) (sdk.Coins, sdk.Error) { +func getCoins(ck bank.Keeper, ctx sdk.Context, addr sdk.AccAddress) (sdk.Coins, sdk.Error) { zero := sdk.Coins(nil) coins, _, err := ck.AddCoins(ctx, addr, zero) return coins, err diff --git a/x/ibc/types.go b/x/ibc/types.go index 1356e4e36f..5f9ee611bb 100644 --- a/x/ibc/types.go +++ b/x/ibc/types.go @@ -22,14 +22,14 @@ func init() { // IBCPacket defines a piece of data that can be send between two separate // blockchains. type IBCPacket struct { - SrcAddr sdk.Address - DestAddr sdk.Address + SrcAddr sdk.AccAddress + DestAddr sdk.AccAddress Coins sdk.Coins SrcChain string DestChain string } -func NewIBCPacket(srcAddr sdk.Address, destAddr sdk.Address, coins sdk.Coins, +func NewIBCPacket(srcAddr sdk.AccAddress, destAddr sdk.AccAddress, coins sdk.Coins, srcChain string, destChain string) IBCPacket { return IBCPacket{ @@ -74,7 +74,7 @@ type IBCTransferMsg struct { func (msg IBCTransferMsg) Type() string { return "ibc" } // x/bank/tx.go MsgSend.GetSigners() -func (msg IBCTransferMsg) GetSigners() []sdk.Address { return []sdk.Address{msg.SrcAddr} } +func (msg IBCTransferMsg) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.SrcAddr} } // get the sign bytes for ibc transfer message func (msg IBCTransferMsg) GetSignBytes() []byte { @@ -94,7 +94,7 @@ func (msg IBCTransferMsg) ValidateBasic() sdk.Error { // to the destination chain. type IBCReceiveMsg struct { IBCPacket - Relayer sdk.Address + Relayer sdk.AccAddress Sequence int64 } @@ -103,13 +103,13 @@ func (msg IBCReceiveMsg) Type() string { return "ibc" } func (msg IBCReceiveMsg) ValidateBasic() sdk.Error { return msg.IBCPacket.ValidateBasic() } // x/bank/tx.go MsgSend.GetSigners() -func (msg IBCReceiveMsg) GetSigners() []sdk.Address { return []sdk.Address{msg.Relayer} } +func (msg IBCReceiveMsg) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Relayer} } // get the sign bytes for ibc receive message func (msg IBCReceiveMsg) GetSignBytes() []byte { b, err := msgCdc.MarshalJSON(struct { IBCPacket json.RawMessage - Relayer sdk.Address + Relayer sdk.AccAddress Sequence int64 }{ IBCPacket: json.RawMessage(msg.IBCPacket.GetSignBytes()), diff --git a/x/ibc/types_test.go b/x/ibc/types_test.go index 690179baa1..cfe73ed13f 100644 --- a/x/ibc/types_test.go +++ b/x/ibc/types_test.go @@ -67,7 +67,7 @@ func TestIBCTransferMsgValidation(t *testing.T) { func TestIBCReceiveMsg(t *testing.T) { packet := constructIBCPacket(true) - msg := IBCReceiveMsg{packet, sdk.Address([]byte("relayer")), 0} + msg := IBCReceiveMsg{packet, sdk.AccAddress([]byte("relayer")), 0} require.Equal(t, msg.Type(), "ibc") } @@ -80,8 +80,8 @@ func TestIBCReceiveMsgValidation(t *testing.T) { valid bool msg IBCReceiveMsg }{ - {true, IBCReceiveMsg{validPacket, sdk.Address([]byte("relayer")), 0}}, - {false, IBCReceiveMsg{invalidPacket, sdk.Address([]byte("relayer")), 0}}, + {true, IBCReceiveMsg{validPacket, sdk.AccAddress([]byte("relayer")), 0}}, + {false, IBCReceiveMsg{invalidPacket, sdk.AccAddress([]byte("relayer")), 0}}, } for i, tc := range cases { @@ -98,8 +98,8 @@ func TestIBCReceiveMsgValidation(t *testing.T) { // Helpers func constructIBCPacket(valid bool) IBCPacket { - srcAddr := sdk.Address([]byte("source")) - destAddr := sdk.Address([]byte("destination")) + srcAddr := sdk.AccAddress([]byte("source")) + destAddr := sdk.AccAddress([]byte("destination")) coins := sdk.Coins{sdk.NewCoin("atom", 10)} srcChain := "source-chain" destChain := "dest-chain" diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go index fa9548c484..3b88baa7fe 100644 --- a/x/slashing/app_test.go +++ b/x/slashing/app_test.go @@ -15,7 +15,7 @@ import ( var ( priv1 = crypto.GenPrivKeyEd25519() - addr1 = sdk.Address(priv1.PubKey().Address()) + addr1 = sdk.AccAddress(priv1.PubKey().Address()) coins = sdk.Coins{sdk.NewCoin("foocoin", 10)} ) @@ -61,7 +61,7 @@ func getInitChainer(mapp *mock.App, keeper stake.Keeper) sdk.InitChainer { } func checkValidator(t *testing.T, mapp *mock.App, keeper stake.Keeper, - addr sdk.Address, expFound bool) stake.Validator { + addr sdk.AccAddress, expFound bool) stake.Validator { ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{}) validator, found := keeper.GetValidator(ctxCheck, addr1) require.Equal(t, expFound, found) @@ -69,7 +69,7 @@ func checkValidator(t *testing.T, mapp *mock.App, keeper stake.Keeper, } func checkValidatorSigningInfo(t *testing.T, mapp *mock.App, keeper Keeper, - addr sdk.Address, expFound bool) ValidatorSigningInfo { + addr sdk.ValAddress, expFound bool) ValidatorSigningInfo { ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{}) signingInfo, found := keeper.getValidatorSigningInfo(ctxCheck, addr) require.Equal(t, expFound, found) @@ -100,9 +100,10 @@ func TestSlashingMsgs(t *testing.T) { require.Equal(t, addr1, validator.Owner) require.Equal(t, sdk.Bonded, validator.Status()) require.True(sdk.RatEq(t, sdk.NewRat(10), validator.PoolShares.Bonded())) - unrevokeMsg := MsgUnrevoke{ValidatorAddr: sdk.Address(validator.PubKey.Address())} + unrevokeMsg := MsgUnrevoke{ValidatorAddr: sdk.AccAddress(validator.PubKey.Address())} - checkValidatorSigningInfo(t, mapp, keeper, addr1, false) + // no signing info yet + checkValidatorSigningInfo(t, mapp, keeper, sdk.ValAddress(addr1), false) // unrevoke should fail with unknown validator res := mock.CheckGenTx(t, mapp.BaseApp, []sdk.Msg{unrevokeMsg}, []int64{0}, []int64{1}, false, priv1) diff --git a/x/slashing/client/cli/query.go b/x/slashing/client/cli/query.go index 5ff1c704c1..0360eb315a 100644 --- a/x/slashing/client/cli/query.go +++ b/x/slashing/client/cli/query.go @@ -25,7 +25,7 @@ func GetCmdQuerySigningInfo(storeName string, cdc *wire.Codec) *cobra.Command { if err != nil { return err } - key := slashing.GetValidatorSigningInfoKey(sdk.Address(pk.Address())) + key := slashing.GetValidatorSigningInfoKey(sdk.ValAddress(pk.Address())) ctx := context.NewCoreContextFromViper() res, err := ctx.QueryStore(key, storeName) if err != nil { diff --git a/x/slashing/handler.go b/x/slashing/handler.go index 6ba0be0473..3991bc2229 100644 --- a/x/slashing/handler.go +++ b/x/slashing/handler.go @@ -30,7 +30,7 @@ func handleMsgUnrevoke(ctx sdk.Context, msg MsgUnrevoke, k Keeper) sdk.Result { return ErrValidatorNotRevoked(k.codespace).Result() } - addr := sdk.Address(validator.GetPubKey().Address()) + addr := sdk.ValAddress(validator.GetPubKey().Address()) // Signing info must exist info, found := k.getValidatorSigningInfo(ctx, addr) diff --git a/x/slashing/keeper.go b/x/slashing/keeper.go index fb17739832..9f1ff205b5 100644 --- a/x/slashing/keeper.go +++ b/x/slashing/keeper.go @@ -34,7 +34,7 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, pubkey crypto.PubKey, infracti logger := ctx.Logger().With("module", "x/slashing") time := ctx.BlockHeader().Time age := time - timestamp - address := sdk.Address(pubkey.Address()) + address := sdk.ValAddress(pubkey.Address()) // Double sign too old if age > MaxEvidenceAge { @@ -64,7 +64,7 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, pubkey crypto.PubKey, infracti func (k Keeper) handleValidatorSignature(ctx sdk.Context, pubkey crypto.PubKey, power int64, signed bool) { logger := ctx.Logger().With("module", "x/slashing") height := ctx.BlockHeight() - address := sdk.Address(pubkey.Address()) + address := sdk.ValAddress(pubkey.Address()) // Local index, so counts blocks validator *should* have signed // Will use the 0-value default signing info if not present, except for start height diff --git a/x/slashing/keeper_test.go b/x/slashing/keeper_test.go index debeda6cca..6d0bf868c7 100644 --- a/x/slashing/keeper_test.go +++ b/x/slashing/keeper_test.go @@ -68,7 +68,7 @@ func TestHandleAbsentValidator(t *testing.T) { stake.EndBlocker(ctx, sk) require.Equal(t, ck.GetCoins(ctx, addr), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}}) require.True(t, sdk.NewRatFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower())) - info, found := keeper.getValidatorSigningInfo(ctx, val.Address()) + info, found := keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(val.Address())) require.False(t, found) require.Equal(t, int64(0), info.StartHeight) require.Equal(t, int64(0), info.IndexOffset) @@ -81,7 +81,7 @@ func TestHandleAbsentValidator(t *testing.T) { ctx = ctx.WithBlockHeight(height) keeper.handleValidatorSignature(ctx, val, amtInt, true) } - info, found = keeper.getValidatorSigningInfo(ctx, val.Address()) + info, found = keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(val.Address())) require.True(t, found) require.Equal(t, int64(0), info.StartHeight) require.Equal(t, SignedBlocksWindow, info.SignedBlocksCounter) @@ -91,7 +91,7 @@ func TestHandleAbsentValidator(t *testing.T) { ctx = ctx.WithBlockHeight(height) keeper.handleValidatorSignature(ctx, val, amtInt, false) } - info, found = keeper.getValidatorSigningInfo(ctx, val.Address()) + info, found = keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(val.Address())) require.True(t, found) require.Equal(t, int64(0), info.StartHeight) require.Equal(t, SignedBlocksWindow-MinSignedPerWindow, info.SignedBlocksCounter) @@ -105,7 +105,7 @@ func TestHandleAbsentValidator(t *testing.T) { // 501st block missed ctx = ctx.WithBlockHeight(height) keeper.handleValidatorSignature(ctx, val, amtInt, false) - info, found = keeper.getValidatorSigningInfo(ctx, val.Address()) + info, found = keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(val.Address())) require.True(t, found) require.Equal(t, int64(0), info.StartHeight) require.Equal(t, SignedBlocksWindow-MinSignedPerWindow-1, info.SignedBlocksCounter) @@ -132,7 +132,7 @@ func TestHandleAbsentValidator(t *testing.T) { require.Equal(t, int64(amtInt-1), pool.BondedTokens) // validator start height should have been changed - info, found = keeper.getValidatorSigningInfo(ctx, val.Address()) + info, found = keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(val.Address())) require.True(t, found) require.Equal(t, height, info.StartHeight) require.Equal(t, SignedBlocksWindow-MinSignedPerWindow-1, info.SignedBlocksCounter) @@ -183,7 +183,7 @@ func TestHandleNewValidator(t *testing.T) { ctx = ctx.WithBlockHeight(SignedBlocksWindow + 2) keeper.handleValidatorSignature(ctx, val, 100, false) - info, found := keeper.getValidatorSigningInfo(ctx, val.Address()) + info, found := keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(val.Address())) require.True(t, found) require.Equal(t, int64(SignedBlocksWindow+1), info.StartHeight) require.Equal(t, int64(2), info.IndexOffset) diff --git a/x/slashing/msg.go b/x/slashing/msg.go index 6060079a49..4b1483dce9 100644 --- a/x/slashing/msg.go +++ b/x/slashing/msg.go @@ -15,26 +15,22 @@ var _ sdk.Msg = &MsgUnrevoke{} // MsgUnrevoke - struct for unrevoking revoked validator type MsgUnrevoke struct { - ValidatorAddr sdk.Address `json:"address"` // address of the validator owner + ValidatorAddr sdk.AccAddress `json:"address"` // address of the validator owner } -func NewMsgUnrevoke(validatorAddr sdk.Address) MsgUnrevoke { +func NewMsgUnrevoke(validatorAddr sdk.AccAddress) MsgUnrevoke { return MsgUnrevoke{ ValidatorAddr: validatorAddr, } } //nolint -func (msg MsgUnrevoke) Type() string { return MsgType } -func (msg MsgUnrevoke) GetSigners() []sdk.Address { return []sdk.Address{msg.ValidatorAddr} } +func (msg MsgUnrevoke) Type() string { return MsgType } +func (msg MsgUnrevoke) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.ValidatorAddr} } // get the bytes for the message signer to sign on func (msg MsgUnrevoke) GetSignBytes() []byte { - b, err := cdc.MarshalJSON(struct { - ValidatorAddr string `json:"address"` - }{ - ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr), - }) + b, err := cdc.MarshalJSON(msg) if err != nil { panic(err) } diff --git a/x/slashing/msg_test.go b/x/slashing/msg_test.go index a668bc33fa..9c546da763 100644 --- a/x/slashing/msg_test.go +++ b/x/slashing/msg_test.go @@ -9,7 +9,7 @@ import ( ) func TestMsgUnrevokeGetSignBytes(t *testing.T) { - addr := sdk.Address("abcd") + addr := sdk.AccAddress("abcd") msg := NewMsgUnrevoke(addr) bytes := msg.GetSignBytes() require.Equal(t, string(bytes), `{"address":"cosmosvaladdr1v93xxeqamr0mv"}`) diff --git a/x/slashing/signing_info.go b/x/slashing/signing_info.go index acbe1738b6..3118793aac 100644 --- a/x/slashing/signing_info.go +++ b/x/slashing/signing_info.go @@ -8,7 +8,7 @@ import ( ) // Stored by *validator* address (not owner address) -func (k Keeper) getValidatorSigningInfo(ctx sdk.Context, address sdk.Address) (info ValidatorSigningInfo, found bool) { +func (k Keeper) getValidatorSigningInfo(ctx sdk.Context, address sdk.ValAddress) (info ValidatorSigningInfo, found bool) { store := ctx.KVStore(k.storeKey) bz := store.Get(GetValidatorSigningInfoKey(address)) if bz == nil { @@ -21,14 +21,14 @@ func (k Keeper) getValidatorSigningInfo(ctx sdk.Context, address sdk.Address) (i } // Stored by *validator* address (not owner address) -func (k Keeper) setValidatorSigningInfo(ctx sdk.Context, address sdk.Address, info ValidatorSigningInfo) { +func (k Keeper) setValidatorSigningInfo(ctx sdk.Context, address sdk.ValAddress, info ValidatorSigningInfo) { store := ctx.KVStore(k.storeKey) bz := k.cdc.MustMarshalBinary(info) store.Set(GetValidatorSigningInfoKey(address), bz) } // Stored by *validator* address (not owner address) -func (k Keeper) getValidatorSigningBitArray(ctx sdk.Context, address sdk.Address, index int64) (signed bool) { +func (k Keeper) getValidatorSigningBitArray(ctx sdk.Context, address sdk.ValAddress, index int64) (signed bool) { store := ctx.KVStore(k.storeKey) bz := store.Get(GetValidatorSigningBitArrayKey(address, index)) if bz == nil { @@ -41,7 +41,7 @@ func (k Keeper) getValidatorSigningBitArray(ctx sdk.Context, address sdk.Address } // Stored by *validator* address (not owner address) -func (k Keeper) setValidatorSigningBitArray(ctx sdk.Context, address sdk.Address, index int64, signed bool) { +func (k Keeper) setValidatorSigningBitArray(ctx sdk.Context, address sdk.ValAddress, index int64, signed bool) { store := ctx.KVStore(k.storeKey) bz := k.cdc.MustMarshalBinary(signed) store.Set(GetValidatorSigningBitArrayKey(address, index), bz) @@ -72,12 +72,12 @@ func (i ValidatorSigningInfo) HumanReadableString() string { } // Stored by *validator* address (not owner address) -func GetValidatorSigningInfoKey(v sdk.Address) []byte { +func GetValidatorSigningInfoKey(v sdk.ValAddress) []byte { return append([]byte{0x01}, v.Bytes()...) } // Stored by *validator* address (not owner address) -func GetValidatorSigningBitArrayKey(v sdk.Address, i int64) []byte { +func GetValidatorSigningBitArrayKey(v sdk.ValAddress, i int64) []byte { b := make([]byte, 8) binary.LittleEndian.PutUint64(b, uint64(i)) return append([]byte{0x02}, append(v.Bytes(), b...)...) diff --git a/x/slashing/signing_info_test.go b/x/slashing/signing_info_test.go index 26113e7153..742769013a 100644 --- a/x/slashing/signing_info_test.go +++ b/x/slashing/signing_info_test.go @@ -4,11 +4,13 @@ import ( "testing" "github.com/stretchr/testify/require" + + sdk "github.com/cosmos/cosmos-sdk/types" ) func TestGetSetValidatorSigningInfo(t *testing.T) { ctx, _, _, keeper := createTestInput(t) - info, found := keeper.getValidatorSigningInfo(ctx, addrs[0]) + info, found := keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(addrs[0])) require.False(t, found) newInfo := ValidatorSigningInfo{ StartHeight: int64(4), @@ -16,8 +18,8 @@ func TestGetSetValidatorSigningInfo(t *testing.T) { JailedUntil: int64(2), SignedBlocksCounter: int64(10), } - keeper.setValidatorSigningInfo(ctx, addrs[0], newInfo) - info, found = keeper.getValidatorSigningInfo(ctx, addrs[0]) + keeper.setValidatorSigningInfo(ctx, sdk.ValAddress(addrs[0]), newInfo) + info, found = keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(addrs[0])) require.True(t, found) require.Equal(t, info.StartHeight, int64(4)) require.Equal(t, info.IndexOffset, int64(3)) @@ -27,9 +29,9 @@ func TestGetSetValidatorSigningInfo(t *testing.T) { func TestGetSetValidatorSigningBitArray(t *testing.T) { ctx, _, _, keeper := createTestInput(t) - signed := keeper.getValidatorSigningBitArray(ctx, addrs[0], 0) + signed := keeper.getValidatorSigningBitArray(ctx, sdk.ValAddress(addrs[0]), 0) require.False(t, signed) // treat empty key as unsigned - keeper.setValidatorSigningBitArray(ctx, addrs[0], 0, true) - signed = keeper.getValidatorSigningBitArray(ctx, addrs[0], 0) + keeper.setValidatorSigningBitArray(ctx, sdk.ValAddress(addrs[0]), 0, true) + signed = keeper.getValidatorSigningBitArray(ctx, sdk.ValAddress(addrs[0]), 0) require.True(t, signed) // now should be signed } diff --git a/x/slashing/test_common.go b/x/slashing/test_common.go index 77b553317a..41a13e3886 100644 --- a/x/slashing/test_common.go +++ b/x/slashing/test_common.go @@ -28,7 +28,7 @@ var ( newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB51"), newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB52"), } - addrs = []sdk.Address{ + addrs = []sdk.AccAddress{ pks[0].Address(), pks[1].Address(), pks[2].Address(), @@ -85,12 +85,12 @@ func newPubKey(pk string) (res crypto.PubKey) { return pkEd } -func testAddr(addr string) sdk.Address { +func testAddr(addr string) sdk.AccAddress { res := []byte(addr) return res } -func newTestMsgCreateValidator(address sdk.Address, pubKey crypto.PubKey, amt sdk.Int) stake.MsgCreateValidator { +func newTestMsgCreateValidator(address sdk.AccAddress, pubKey crypto.PubKey, amt sdk.Int) stake.MsgCreateValidator { return stake.MsgCreateValidator{ Description: stake.Description{}, ValidatorAddr: address, diff --git a/x/slashing/tick_test.go b/x/slashing/tick_test.go index 42a476a4ce..247fe0972a 100644 --- a/x/slashing/tick_test.go +++ b/x/slashing/tick_test.go @@ -37,7 +37,7 @@ func TestBeginBlocker(t *testing.T) { } BeginBlocker(ctx, req, keeper) - info, found := keeper.getValidatorSigningInfo(ctx, pk.Address()) + info, found := keeper.getValidatorSigningInfo(ctx, sdk.ValAddress(pk.Address())) require.True(t, found) require.Equal(t, ctx.BlockHeight(), info.StartHeight) require.Equal(t, int64(1), info.IndexOffset) diff --git a/x/stake/app_test.go b/x/stake/app_test.go index be4dc90cc0..aa25138c95 100644 --- a/x/stake/app_test.go +++ b/x/stake/app_test.go @@ -14,23 +14,17 @@ import ( var ( priv1 = crypto.GenPrivKeyEd25519() - addr1 = sdk.Address(priv1.PubKey().Address()) + addr1 = sdk.AccAddress(priv1.PubKey().Address()) priv2 = crypto.GenPrivKeyEd25519() - addr2 = sdk.Address(priv2.PubKey().Address()) - addr3 = sdk.Address(crypto.GenPrivKeyEd25519().PubKey().Address()) + addr2 = sdk.AccAddress(priv2.PubKey().Address()) + addr3 = sdk.AccAddress(crypto.GenPrivKeyEd25519().PubKey().Address()) priv4 = crypto.GenPrivKeyEd25519() -<<<<<<< HEAD - addr4 = priv4.PubKey().Address() - coins = sdk.NewCoin("foocoin", 10) - fee = auth.StdFee{sdk.Coins{sdk.NewCoin("foocoin", 0)}, 100000} -======= - addr4 = sdk.Address(priv4.PubKey().Address()) + addr4 = sdk.AccAddress(priv4.PubKey().Address()) coins = sdk.Coins{{"foocoin", sdk.NewInt(10)}} fee = auth.StdFee{ sdk.Coins{{"foocoin", sdk.NewInt(0)}}, 100000, } ->>>>>>> asdf ) // getMockApp returns an initialized mock application for this module. @@ -77,10 +71,11 @@ func getInitChainer(mapp *mock.App, keeper Keeper) sdk.InitChainer { } } -func checkValidator( - t *testing.T, mapp *mock.App, keeper Keeper, - addr sdk.Address, expFound bool, -) Validator { +//__________________________________________________________________________________________ + +func checkValidator(t *testing.T, mapp *mock.App, keeper Keeper, + addr sdk.AccAddress, expFound bool) Validator { + ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{}) validator, found := keeper.GetValidator(ctxCheck, addr1) @@ -88,10 +83,12 @@ func checkValidator( return validator } + func checkDelegation( t *testing.T, mapp *mock.App, keeper Keeper, delegatorAddr, - validatorAddr sdk.Address, expFound bool, expShares sdk.Rat, + validatorAddr sdk.AccAddress, expFound bool, expShares sdk.Rat, ) { + ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{}) delegation, found := keeper.GetDelegation(ctxCheck, delegatorAddr, validatorAddr) if expFound { diff --git a/x/stake/client/cli/query.go b/x/stake/client/cli/query.go index 30f833c020..e703e8a54c 100644 --- a/x/stake/client/cli/query.go +++ b/x/stake/client/cli/query.go @@ -209,7 +209,7 @@ func GetCmdQueryUnbondingDelegation(storeName string, cdc *wire.Codec) *cobra.Co return err } - delAddr, err := sdk.GetValAddressHex(viper.GetString(FlagAddressDelegator)) + delAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } @@ -302,7 +302,7 @@ func GetCmdQueryRedelegation(storeName string, cdc *wire.Codec) *cobra.Command { if err != nil { return err } - delAddr, err := sdk.GetValAddressHex(viper.GetString(FlagAddressDelegator)) + delAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } diff --git a/x/stake/client/cli/tx.go b/x/stake/client/cli/tx.go index 9b8acb8cc8..7b4d11db5e 100644 --- a/x/stake/client/cli/tx.go +++ b/x/stake/client/cli/tx.go @@ -209,7 +209,7 @@ func GetCmdBeginRedelegate(storeName string, cdc *wire.Codec) *cobra.Command { } func getShares(storeName string, cdc *wire.Codec, sharesAmountStr, sharesPercentStr string, - delegatorAddr, validatorAddr sdk.Address) (sharesAmount sdk.Rat, err error) { + delegatorAddr, validatorAddr sdk.AccAddress) (sharesAmount sdk.Rat, err error) { switch { case sharesAmountStr != "" && sharesPercentStr != "": diff --git a/x/stake/client/rest/query.go b/x/stake/client/rest/query.go index 090445f0a8..be6a21f785 100644 --- a/x/stake/client/rest/query.go +++ b/x/stake/client/rest/query.go @@ -55,7 +55,7 @@ func delegationHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.HandlerF return } - validatorAddr, err := sdk.GetValAddressBech32(bech32validator) + validatorAddr, err := sdk.GetAccAddressBech32(bech32validator) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) @@ -111,7 +111,7 @@ func ubdHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.HandlerFunc { return } - validatorAddr, err := sdk.GetValAddressBech32(bech32validator) + validatorAddr, err := sdk.GetAccAddressBech32(bech32validator) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) @@ -168,14 +168,14 @@ func redHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.HandlerFunc { return } - validatorSrcAddr, err := sdk.GetValAddressBech32(bech32validatorSrc) + validatorSrcAddr, err := sdk.GetAccAddressBech32(bech32validatorSrc) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) return } - validatorDstAddr, err := sdk.GetValAddressBech32(bech32validatorDst) + validatorDstAddr, err := sdk.GetAccAddressBech32(bech32validatorDst) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) @@ -217,9 +217,9 @@ func redHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.HandlerFunc { // TODO move exist next to validator struct for maintainability type StakeValidatorOutput struct { - Owner string `json:"owner"` // in bech32 - PubKey string `json:"pub_key"` // in bech32 - Revoked bool `json:"revoked"` // has the validator been revoked from bonded status? + Owner sdk.AccAddress `json:"owner"` // in bech32 + PubKey string `json:"pub_key"` // in bech32 + Revoked bool `json:"revoked"` // has the validator been revoked from bonded status? PoolShares stake.PoolShares `json:"pool_shares"` // total shares for tokens held in the pool DelegatorShares sdk.Rat `json:"delegator_shares"` // total shares issued to a validator's delegators @@ -231,7 +231,7 @@ type StakeValidatorOutput struct { Commission sdk.Rat `json:"commission"` // XXX the commission rate of fees charged to any delegators CommissionMax sdk.Rat `json:"commission_max"` // XXX maximum commission rate which this validator can ever charge - CommissionChangeRate sdk.Rat `json:"commission_change_rate"` // XXX maximum daily increase of the validator commission + CommissionChangeRate sdk.Rat `json:"commisrsion_change_rate"` // XXX maximum daily increase of the validator commission CommissionChangeToday sdk.Rat `json:"commission_change_today"` // XXX commission rate change today, reset each day (UTC time) // fee related @@ -239,17 +239,13 @@ type StakeValidatorOutput struct { } func bech32StakeValidatorOutput(validator stake.Validator) (StakeValidatorOutput, error) { - bechOwner, err := sdk.Bech32ifyVal(validator.Owner) - if err != nil { - return StakeValidatorOutput{}, err - } bechValPubkey, err := sdk.Bech32ifyValPub(validator.PubKey) if err != nil { return StakeValidatorOutput{}, err } return StakeValidatorOutput{ - Owner: bechOwner, + Owner: validator.Owner, PubKey: bechValPubkey, Revoked: validator.Revoked, diff --git a/x/stake/client/rest/tx.go b/x/stake/client/rest/tx.go index 51a854528d..415a8af8b3 100644 --- a/x/stake/client/rest/tx.go +++ b/x/stake/client/rest/tx.go @@ -103,7 +103,7 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))) return } - validatorAddr, err := sdk.GetValAddressBech32(msg.ValidatorAddr) + validatorAddr, err := sdk.GetAccAddressBech32(msg.ValidatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) @@ -134,13 +134,13 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte w.Write([]byte("Must use own delegator address")) return } - validatorSrcAddr, err := sdk.GetValAddressBech32(msg.ValidatorSrcAddr) + validatorSrcAddr, err := sdk.GetAccAddressBech32(msg.ValidatorSrcAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) return } - validatorDstAddr, err := sdk.GetValAddressBech32(msg.ValidatorDstAddr) + validatorDstAddr, err := sdk.GetAccAddressBech32(msg.ValidatorDstAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) @@ -168,13 +168,13 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))) return } - validatorSrcAddr, err := sdk.GetValAddressBech32(msg.ValidatorSrcAddr) + validatorSrcAddr, err := sdk.GetAccAddressBech32(msg.ValidatorSrcAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) return } - validatorDstAddr, err := sdk.GetValAddressBech32(msg.ValidatorDstAddr) + validatorDstAddr, err := sdk.GetAccAddressBech32(msg.ValidatorDstAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) @@ -205,7 +205,7 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte w.Write([]byte("Must use own delegator address")) return } - validatorAddr, err := sdk.GetValAddressBech32(msg.ValidatorAddr) + validatorAddr, err := sdk.GetAccAddressBech32(msg.ValidatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) @@ -232,7 +232,7 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))) return } - validatorAddr, err := sdk.GetValAddressBech32(msg.ValidatorAddr) + validatorAddr, err := sdk.GetAccAddressBech32(msg.ValidatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) diff --git a/x/stake/handler_test.go b/x/stake/handler_test.go index 21cf617209..fffd248b3b 100644 --- a/x/stake/handler_test.go +++ b/x/stake/handler_test.go @@ -14,7 +14,7 @@ import ( //______________________________________________________________________ -func newTestMsgCreateValidator(address sdk.Address, pubKey crypto.PubKey, amt int64) MsgCreateValidator { +func newTestMsgCreateValidator(address sdk.AccAddress, pubKey crypto.PubKey, amt int64) MsgCreateValidator { return MsgCreateValidator{ Description: Description{}, ValidatorAddr: address, @@ -23,7 +23,7 @@ func newTestMsgCreateValidator(address sdk.Address, pubKey crypto.PubKey, amt in } } -func newTestMsgDelegate(delegatorAddr, validatorAddr sdk.Address, amt int64) MsgDelegate { +func newTestMsgDelegate(delegatorAddr, validatorAddr sdk.AccAddress, amt int64) MsgDelegate { return MsgDelegate{ DelegatorAddr: delegatorAddr, ValidatorAddr: validatorAddr, @@ -307,7 +307,7 @@ func TestMultipleMsgCreateValidator(t *testing.T) { ctx, accMapper, keeper := keep.CreateTestInput(t, false, initBond) params := setInstantUnbondPeriod(keeper, ctx) - validatorAddrs := []sdk.Address{keep.Addrs[0], keep.Addrs[1], keep.Addrs[2]} + validatorAddrs := []sdk.AccAddress{keep.Addrs[0], keep.Addrs[1], keep.Addrs[2]} // bond them all for i, validatorAddr := range validatorAddrs { diff --git a/x/stake/keeper/delegation.go b/x/stake/keeper/delegation.go index 353154ce22..c4b393f271 100644 --- a/x/stake/keeper/delegation.go +++ b/x/stake/keeper/delegation.go @@ -9,7 +9,7 @@ import ( // load a delegation func (k Keeper) GetDelegation(ctx sdk.Context, - delegatorAddr, validatorAddr sdk.Address) (delegation types.Delegation, found bool) { + delegatorAddr, validatorAddr sdk.AccAddress) (delegation types.Delegation, found bool) { store := ctx.KVStore(k.storeKey) key := GetDelegationKey(delegatorAddr, validatorAddr) @@ -41,7 +41,7 @@ func (k Keeper) GetAllDelegations(ctx sdk.Context) (delegations []types.Delegati } // load all delegations for a delegator -func (k Keeper) GetDelegations(ctx sdk.Context, delegator sdk.Address, +func (k Keeper) GetDelegations(ctx sdk.Context, delegator sdk.AccAddress, maxRetrieve int16) (delegations []types.Delegation) { store := ctx.KVStore(k.storeKey) @@ -79,7 +79,7 @@ func (k Keeper) RemoveDelegation(ctx sdk.Context, delegation types.Delegation) { // load a unbonding delegation func (k Keeper) GetUnbondingDelegation(ctx sdk.Context, - DelegatorAddr, ValidatorAddr sdk.Address) (ubd types.UnbondingDelegation, found bool) { + DelegatorAddr, ValidatorAddr sdk.AccAddress) (ubd types.UnbondingDelegation, found bool) { store := ctx.KVStore(k.storeKey) key := GetUBDKey(DelegatorAddr, ValidatorAddr) @@ -93,7 +93,11 @@ func (k Keeper) GetUnbondingDelegation(ctx sdk.Context, } // load all unbonding delegations from a particular validator +<<<<<<< HEAD func (k Keeper) GetUnbondingDelegationsFromValidator(ctx sdk.Context, valAddr sdk.Address) (ubds []types.UnbondingDelegation) { +======= +func (k Keeper) GetUnbondingDelegationsFromValidator(ctx sdk.Context, valAddr sdk.AccAddress) (unbondingDelegations []types.UnbondingDelegation) { +>>>>>>> asdf store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, GetUBDsByValIndexKey(valAddr)) for { @@ -131,7 +135,7 @@ func (k Keeper) RemoveUnbondingDelegation(ctx sdk.Context, ubd types.UnbondingDe // load a redelegation func (k Keeper) GetRedelegation(ctx sdk.Context, - DelegatorAddr, ValidatorSrcAddr, ValidatorDstAddr sdk.Address) (red types.Redelegation, found bool) { + DelegatorAddr, ValidatorSrcAddr, ValidatorDstAddr sdk.AccAddress) (red types.Redelegation, found bool) { store := ctx.KVStore(k.storeKey) key := GetREDKey(DelegatorAddr, ValidatorSrcAddr, ValidatorDstAddr) @@ -145,7 +149,11 @@ func (k Keeper) GetRedelegation(ctx sdk.Context, } // load all redelegations from a particular validator +<<<<<<< HEAD func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.Address) (reds []types.Redelegation) { +======= +func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.AccAddress) (redelegations []types.Redelegation) { +>>>>>>> asdf store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, GetREDsFromValSrcIndexKey(valAddr)) for { @@ -164,7 +172,7 @@ func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.Addre // has a redelegation func (k Keeper) HasReceivingRedelegation(ctx sdk.Context, - DelegatorAddr, ValidatorDstAddr sdk.Address) bool { + DelegatorAddr, ValidatorDstAddr sdk.AccAddress) bool { store := ctx.KVStore(k.storeKey) prefix := GetREDsByDelToValDstIndexKey(DelegatorAddr, ValidatorDstAddr) @@ -201,7 +209,7 @@ func (k Keeper) RemoveRedelegation(ctx sdk.Context, red types.Redelegation) { //_____________________________________________________________________________________ // Perform a delegation, set/update everything necessary within the store -func (k Keeper) Delegate(ctx sdk.Context, delegatorAddr sdk.Address, bondAmt sdk.Coin, +func (k Keeper) Delegate(ctx sdk.Context, delegatorAddr sdk.AccAddress, bondAmt sdk.Coin, validator types.Validator) (newShares sdk.Rat, err sdk.Error) { // Get or create the delegator delegation @@ -234,7 +242,7 @@ func (k Keeper) Delegate(ctx sdk.Context, delegatorAddr sdk.Address, bondAmt sdk } // unbond the the delegation return -func (k Keeper) unbond(ctx sdk.Context, delegatorAddr, validatorAddr sdk.Address, +func (k Keeper) unbond(ctx sdk.Context, delegatorAddr, validatorAddr sdk.AccAddress, shares sdk.Rat) (amount int64, err sdk.Error) { // check if delegation has any shares in it unbond @@ -293,7 +301,7 @@ func (k Keeper) unbond(ctx sdk.Context, delegatorAddr, validatorAddr sdk.Address //______________________________________________________________________________________________________ // complete unbonding an unbonding record -func (k Keeper) BeginUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk.Address, sharesAmount sdk.Rat) sdk.Error { +func (k Keeper) BeginUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk.AccAddress, sharesAmount sdk.Rat) sdk.Error { returnAmount, err := k.unbond(ctx, delegatorAddr, validatorAddr, sharesAmount) if err != nil { @@ -317,7 +325,7 @@ func (k Keeper) BeginUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk } // complete unbonding an unbonding record -func (k Keeper) CompleteUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk.Address) sdk.Error { +func (k Keeper) CompleteUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr sdk.AccAddress) sdk.Error { ubd, found := k.GetUnbondingDelegation(ctx, delegatorAddr, validatorAddr) if !found { @@ -340,7 +348,7 @@ func (k Keeper) CompleteUnbonding(ctx sdk.Context, delegatorAddr, validatorAddr // complete unbonding an unbonding record func (k Keeper) BeginRedelegation(ctx sdk.Context, delegatorAddr, validatorSrcAddr, - validatorDstAddr sdk.Address, sharesAmount sdk.Rat) sdk.Error { + validatorDstAddr sdk.AccAddress, sharesAmount sdk.Rat) sdk.Error { // check if this is a transitive redelegation if k.HasReceivingRedelegation(ctx, delegatorAddr, validatorSrcAddr) { @@ -381,7 +389,7 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delegatorAddr, validatorSrcAd } // complete unbonding an ongoing redelegation -func (k Keeper) CompleteRedelegation(ctx sdk.Context, delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.Address) sdk.Error { +func (k Keeper) CompleteRedelegation(ctx sdk.Context, delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) sdk.Error { red, found := k.GetRedelegation(ctx, delegatorAddr, validatorSrcAddr, validatorDstAddr) if !found { diff --git a/x/stake/keeper/key.go b/x/stake/keeper/key.go index 824c45ca87..31f1c608fe 100644 --- a/x/stake/keeper/key.go +++ b/x/stake/keeper/key.go @@ -36,7 +36,7 @@ const maxDigitsForAccount = 12 // ~220,000,000 atoms created at launch // get the key for the validator with address. // VALUE: stake/types.Validator -func GetValidatorKey(ownerAddr sdk.Address) []byte { +func GetValidatorKey(ownerAddr sdk.AccAddress) []byte { return append(ValidatorsKey, ownerAddr.Bytes()...) } @@ -48,7 +48,7 @@ func GetValidatorByPubKeyIndexKey(pubkey crypto.PubKey) []byte { // get the key for the current validator group // VALUE: none (key rearrangement with GetValKeyFromValBondedIndexKey) -func GetValidatorsBondedIndexKey(ownerAddr sdk.Address) []byte { +func GetValidatorsBondedIndexKey(ownerAddr sdk.AccAddress) []byte { return append(ValidatorsBondedIndexKey, ownerAddr.Bytes()...) } @@ -96,7 +96,7 @@ func getValidatorPowerRank(validator types.Validator, pool types.Pool) []byte { // get the key for the accumulated update validators. // VALUE: abci.Validator // note records using these keys should never persist between blocks -func GetTendermintUpdatesKey(ownerAddr sdk.Address) []byte { +func GetTendermintUpdatesKey(ownerAddr sdk.AccAddress) []byte { return append(TendermintUpdatesKey, ownerAddr.Bytes()...) } @@ -104,12 +104,12 @@ func GetTendermintUpdatesKey(ownerAddr sdk.Address) []byte { // get the key for delegator bond with validator. // VALUE: stake/types.Delegation -func GetDelegationKey(delegatorAddr, validatorAddr sdk.Address) []byte { +func GetDelegationKey(delegatorAddr, validatorAddr sdk.AccAddress) []byte { return append(GetDelegationsKey(delegatorAddr), validatorAddr.Bytes()...) } // get the prefix for a delegator for all validators -func GetDelegationsKey(delegatorAddr sdk.Address) []byte { +func GetDelegationsKey(delegatorAddr sdk.AccAddress) []byte { return append(DelegationKey, delegatorAddr.Bytes()...) } @@ -117,7 +117,7 @@ func GetDelegationsKey(delegatorAddr sdk.Address) []byte { // get the key for an unbonding delegation by delegator and validator addr. // VALUE: stake/types.UnbondingDelegation -func GetUBDKey(delegatorAddr, validatorAddr sdk.Address) []byte { +func GetUBDKey(delegatorAddr, validatorAddr sdk.AccAddress) []byte { return append( GetUBDsKey(delegatorAddr.Bytes()), validatorAddr.Bytes()...) @@ -125,7 +125,7 @@ func GetUBDKey(delegatorAddr, validatorAddr sdk.Address) []byte { // get the index-key for an unbonding delegation, stored by validator-index // VALUE: none (key rearrangement used) -func GetUBDByValIndexKey(delegatorAddr, validatorAddr sdk.Address) []byte { +func GetUBDByValIndexKey(delegatorAddr, validatorAddr sdk.AccAddress) []byte { return append(GetUBDsByValIndexKey(validatorAddr), delegatorAddr.Bytes()...) } @@ -143,12 +143,12 @@ func GetUBDKeyFromValIndexKey(IndexKey []byte) []byte { //______________ // get the prefix for all unbonding delegations from a delegator -func GetUBDsKey(delegatorAddr sdk.Address) []byte { +func GetUBDsKey(delegatorAddr sdk.AccAddress) []byte { return append(UnbondingDelegationKey, delegatorAddr.Bytes()...) } // get the prefix keyspace for the indexes of unbonding delegations for a validator -func GetUBDsByValIndexKey(validatorAddr sdk.Address) []byte { +func GetUBDsByValIndexKey(validatorAddr sdk.AccAddress) []byte { return append(UnbondingDelegationByValIndexKey, validatorAddr.Bytes()...) } @@ -156,9 +156,7 @@ func GetUBDsByValIndexKey(validatorAddr sdk.Address) []byte { // get the key for a redelegation // VALUE: stake/types.RedelegationKey -func GetREDKey(delegatorAddr, validatorSrcAddr, - validatorDstAddr sdk.Address) []byte { - +func GetREDKey(delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) []byte { return append(append( GetREDsKey(delegatorAddr.Bytes()), validatorSrcAddr.Bytes()...), @@ -167,9 +165,7 @@ func GetREDKey(delegatorAddr, validatorSrcAddr, // get the index-key for a redelegation, stored by source-validator-index // VALUE: none (key rearrangement used) -func GetREDByValSrcIndexKey(delegatorAddr, validatorSrcAddr, - validatorDstAddr sdk.Address) []byte { - +func GetREDByValSrcIndexKey(delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) []byte { return append(append( GetREDsFromValSrcIndexKey(validatorSrcAddr), delegatorAddr.Bytes()...), @@ -178,9 +174,7 @@ func GetREDByValSrcIndexKey(delegatorAddr, validatorSrcAddr, // get the index-key for a redelegation, stored by destination-validator-index // VALUE: none (key rearrangement used) -func GetREDByValDstIndexKey(delegatorAddr, validatorSrcAddr, - validatorDstAddr sdk.Address) []byte { - +func GetREDByValDstIndexKey(delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) []byte { return append(append( GetREDsToValDstIndexKey(validatorDstAddr), delegatorAddr.Bytes()...), @@ -215,25 +209,23 @@ func GetREDKeyFromValDstIndexKey(IndexKey []byte) []byte { //______________ // get the prefix keyspace for redelegations from a delegator -func GetREDsKey(delegatorAddr sdk.Address) []byte { +func GetREDsKey(delegatorAddr sdk.AccAddress) []byte { return append(RedelegationKey, delegatorAddr.Bytes()...) } // get the prefix keyspace for all redelegations redelegating away from a source validator -func GetREDsFromValSrcIndexKey(validatorSrcAddr sdk.Address) []byte { +func GetREDsFromValSrcIndexKey(validatorSrcAddr sdk.AccAddress) []byte { return append(RedelegationByValSrcIndexKey, validatorSrcAddr.Bytes()...) } // get the prefix keyspace for all redelegations redelegating towards a destination validator -func GetREDsToValDstIndexKey(validatorDstAddr sdk.Address) []byte { +func GetREDsToValDstIndexKey(validatorDstAddr sdk.AccAddress) []byte { return append(RedelegationByValDstIndexKey, validatorDstAddr.Bytes()...) } // get the prefix keyspace for all redelegations redelegating towards a destination validator // from a particular delegator -func GetREDsByDelToValDstIndexKey(delegatorAddr sdk.Address, - validatorDstAddr sdk.Address) []byte { - +func GetREDsByDelToValDstIndexKey(delegatorAddr sdk.Address, validatorDstAddr sdk.AccAddress) []byte { return append( GetREDsToValDstIndexKey(validatorDstAddr), delegatorAddr.Bytes()...) diff --git a/x/stake/keeper/sdk_types.go b/x/stake/keeper/sdk_types.go index b8be3e34f8..989e951663 100644 --- a/x/stake/keeper/sdk_types.go +++ b/x/stake/keeper/sdk_types.go @@ -49,7 +49,7 @@ func (k Keeper) IterateValidatorsBonded(ctx sdk.Context, fn func(index int64, va } // get the sdk.validator for a particular address -func (k Keeper) Validator(ctx sdk.Context, address sdk.Address) sdk.Validator { +func (k Keeper) Validator(ctx sdk.Context, address sdk.AccAddress) sdk.Validator { val, found := k.GetValidator(ctx, address) if !found { return nil @@ -75,7 +75,7 @@ func (k Keeper) GetValidatorSet() sdk.ValidatorSet { } // get the delegation for a particular set of delegator and validator addresses -func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.Address, addrVal sdk.Address) sdk.Delegation { +func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.AccAddress, addrVal sdk.AccAddress) sdk.Delegation { bond, ok := k.GetDelegation(ctx, addrDel, addrVal) if !ok { return nil @@ -84,7 +84,7 @@ func (k Keeper) Delegation(ctx sdk.Context, addrDel sdk.Address, addrVal sdk.Add } // iterate through the active validator set and perform the provided function -func (k Keeper) IterateDelegations(ctx sdk.Context, delAddr sdk.Address, fn func(index int64, delegation sdk.Delegation) (stop bool)) { +func (k Keeper) IterateDelegations(ctx sdk.Context, delAddr sdk.AccAddress, fn func(index int64, delegation sdk.Delegation) (stop bool)) { store := ctx.KVStore(k.storeKey) key := GetDelegationsKey(delAddr) iterator := sdk.KVStorePrefixIterator(store, key) diff --git a/x/stake/keeper/test_common.go b/x/stake/keeper/test_common.go index 211b37ec16..b367e56929 100644 --- a/x/stake/keeper/test_common.go +++ b/x/stake/keeper/test_common.go @@ -25,14 +25,14 @@ import ( var ( Addrs = createTestAddrs(100) PKs = createTestPubKeys(100) - emptyAddr sdk.Address + emptyAddr sdk.AccAddress emptyPubkey crypto.PubKey - addrDels = []sdk.Address{ + addrDels = []sdk.AccAddress{ Addrs[0], Addrs[1], } - addrVals = []sdk.Address{ + addrVals = []sdk.AccAddress{ Addrs[2], Addrs[3], Addrs[4], @@ -137,7 +137,7 @@ func NewPubKey(pk string) (res crypto.PubKey) { } // for incode address generation -func TestAddr(addr string, bech string) sdk.Address { +func TestAddr(addr string, bech string) sdk.AccAddress { res, err := sdk.GetAccAddressHex(addr) if err != nil { @@ -160,8 +160,8 @@ func TestAddr(addr string, bech string) sdk.Address { } // nolint: unparam -func createTestAddrs(numAddrs int) []sdk.Address { - var addresses []sdk.Address +func createTestAddrs(numAddrs int) []sdk.AccAddress { + var addresses []sdk.AccAddress var buffer bytes.Buffer // start at 100 so we can make up to 999 test addresses with valid test addresses diff --git a/x/stake/keeper/validator.go b/x/stake/keeper/validator.go index 233c7b6e87..3c49aa340e 100644 --- a/x/stake/keeper/validator.go +++ b/x/stake/keeper/validator.go @@ -12,7 +12,7 @@ import ( ) // get a single validator -func (k Keeper) GetValidator(ctx sdk.Context, addr sdk.Address) (validator types.Validator, found bool) { +func (k Keeper) GetValidator(ctx sdk.Context, addr sdk.AccAddress) (validator types.Validator, found bool) { store := ctx.KVStore(k.storeKey) value := store.Get(GetValidatorKey(addr)) if value == nil { @@ -487,7 +487,7 @@ func (k Keeper) bondValidator(ctx sdk.Context, validator types.Validator) types. } // remove the validator record and associated indexes -func (k Keeper) RemoveValidator(ctx sdk.Context, address sdk.Address) { +func (k Keeper) RemoveValidator(ctx sdk.Context, address sdk.AccAddress) { // first retrieve the old validator record validator, found := k.GetValidator(ctx, address) diff --git a/x/stake/types/delegation.go b/x/stake/types/delegation.go index 8439e3da3d..6f923aaea3 100644 --- a/x/stake/types/delegation.go +++ b/x/stake/types/delegation.go @@ -13,10 +13,10 @@ import ( // owned by one delegator, and is associated with the voting power of one // pubKey. type Delegation struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorAddr sdk.Address `json:"validator_addr"` - Shares sdk.Rat `json:"shares"` - Height int64 `json:"height"` // Last height bond updated + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorAddr sdk.AccAddress `json:"validator_addr"` + Shares sdk.Rat `json:"shares"` + Height int64 `json:"height"` // Last height bond updated } type delegationValue struct { @@ -78,9 +78,9 @@ func (d Delegation) Equal(d2 Delegation) bool { var _ sdk.Delegation = Delegation{} // nolint - for sdk.Delegation -func (d Delegation) GetDelegator() sdk.Address { return d.DelegatorAddr } -func (d Delegation) GetValidator() sdk.Address { return d.ValidatorAddr } -func (d Delegation) GetBondShares() sdk.Rat { return d.Shares } +func (d Delegation) GetDelegator() sdk.AccAddress { return d.DelegatorAddr } +func (d Delegation) GetValidator() sdk.AccAddress { return d.ValidatorAddr } +func (d Delegation) GetBondShares() sdk.Rat { return d.Shares } // HumanReadableString returns a human readable string representation of a // Delegation. An error is returned if the Delegation's delegator or validator @@ -97,12 +97,12 @@ func (d Delegation) HumanReadableString() (string, error) { // UnbondingDelegation reflects a delegation's passive unbonding queue. type UnbondingDelegation struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` // delegator - ValidatorAddr sdk.Address `json:"validator_addr"` // validator unbonding from owner addr - CreationHeight int64 `json:"creation_height"` // height which the unbonding took place - MinTime int64 `json:"min_time"` // unix time for unbonding completion - InitialBalance sdk.Coin `json:"initial_balance"` // atoms initially scheduled to receive at completion - Balance sdk.Coin `json:"balance"` // atoms to receive at completion + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` // delegator + ValidatorAddr sdk.AccAddress `json:"validator_addr"` // validator unbonding from owner addr + CreationHeight int64 `json:"creation_height"` // height which the unbonding took place + MinTime int64 `json:"min_time"` // unix time for unbonding completion + InitialBalance sdk.Coin `json:"initial_balance"` // atoms initially scheduled to receive at completion + Balance sdk.Coin `json:"balance"` // atoms to receive at completion } type ubdValue struct { @@ -169,19 +169,6 @@ func (d UnbondingDelegation) Equal(d2 UnbondingDelegation) bool { // UnbondingDelegation. An error is returned if the UnbondingDelegation's // delegator or validator addresses cannot be Bech32 encoded. func (d UnbondingDelegation) HumanReadableString() (string, error) { -<<<<<<< HEAD - bechAcc, err := sdk.Bech32ifyAcc(d.DelegatorAddr) - if err != nil { - return "", err - } - - bechVal, err := sdk.Bech32ifyAcc(d.ValidatorAddr) - if err != nil { - return "", err - } - -======= ->>>>>>> asdf resp := "Unbonding Delegation \n" resp += fmt.Sprintf("Delegator: %s\n", d.DelegatorAddr) resp += fmt.Sprintf("Validator: %s\n", d.ValidatorAddr) @@ -195,15 +182,15 @@ func (d UnbondingDelegation) HumanReadableString() (string, error) { // Redelegation reflects a delegation's passive re-delegation queue. type Redelegation struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` // delegator - ValidatorSrcAddr sdk.Address `json:"validator_src_addr"` // validator redelegation source owner addr - ValidatorDstAddr sdk.Address `json:"validator_dst_addr"` // validator redelegation destination owner addr - CreationHeight int64 `json:"creation_height"` // height which the redelegation took place - MinTime int64 `json:"min_time"` // unix time for redelegation completion - InitialBalance sdk.Coin `json:"initial_balance"` // initial balance when redelegation started - Balance sdk.Coin `json:"balance"` // current balance - SharesSrc sdk.Rat `json:"shares_src"` // amount of source shares redelegating - SharesDst sdk.Rat `json:"shares_dst"` // amount of destination shares redelegating + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` // delegator + ValidatorSrcAddr sdk.AccAddress `json:"validator_src_addr"` // validator redelegation source owner addr + ValidatorDstAddr sdk.AccAddress `json:"validator_dst_addr"` // validator redelegation destination owner addr + CreationHeight int64 `json:"creation_height"` // height which the redelegation took place + MinTime int64 `json:"min_time"` // unix time for redelegation completion + InitialBalance sdk.Coin `json:"initial_balance"` // initial balance when redelegation started + Balance sdk.Coin `json:"balance"` // current balance + SharesSrc sdk.Rat `json:"shares_src"` // amount of source shares redelegating + SharesDst sdk.Rat `json:"shares_dst"` // amount of destination shares redelegating } type redValue struct { @@ -278,24 +265,6 @@ func (d Redelegation) Equal(d2 Redelegation) bool { // Redelegation. An error is returned if the UnbondingDelegation's delegator or // validator addresses cannot be Bech32 encoded. func (d Redelegation) HumanReadableString() (string, error) { -<<<<<<< HEAD - bechAcc, err := sdk.Bech32ifyAcc(d.DelegatorAddr) - if err != nil { - return "", err - } - - bechValSrc, err := sdk.Bech32ifyAcc(d.ValidatorSrcAddr) - if err != nil { - return "", err - } - - bechValDst, err := sdk.Bech32ifyAcc(d.ValidatorDstAddr) - if err != nil { - return "", err - } - -======= ->>>>>>> asdf resp := "Redelegation \n" resp += fmt.Sprintf("Delegator: %s\n", d.DelegatorAddr) resp += fmt.Sprintf("Source Validator: %s\n", d.ValidatorSrcAddr) diff --git a/x/stake/types/msg.go b/x/stake/types/msg.go index 1fc6a84bab..b179894577 100644 --- a/x/stake/types/msg.go +++ b/x/stake/types/msg.go @@ -27,12 +27,12 @@ var maximumBondingRationalDenominator sdk.Int = sdk.NewInt(int64(math.Pow10(MaxB // MsgCreateValidator - struct for unbonding transactions type MsgCreateValidator struct { Description - ValidatorAddr sdk.Address `json:"address"` - PubKey crypto.PubKey `json:"pubkey"` - SelfDelegation sdk.Coin `json:"self_delegation"` + ValidatorAddr sdk.AccAddress `json:"address"` + PubKey crypto.PubKey `json:"pubkey"` + SelfDelegation sdk.Coin `json:"self_delegation"` } -func NewMsgCreateValidator(validatorAddr sdk.Address, pubkey crypto.PubKey, +func NewMsgCreateValidator(validatorAddr sdk.AccAddress, pubkey crypto.PubKey, selfDelegation sdk.Coin, description Description) MsgCreateValidator { return MsgCreateValidator{ Description: description, @@ -44,20 +44,20 @@ func NewMsgCreateValidator(validatorAddr sdk.Address, pubkey crypto.PubKey, //nolint func (msg MsgCreateValidator) Type() string { return MsgType } -func (msg MsgCreateValidator) GetSigners() []sdk.Address { - return []sdk.Address{msg.ValidatorAddr} +func (msg MsgCreateValidator) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.ValidatorAddr} } // get the bytes for the message signer to sign on func (msg MsgCreateValidator) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { Description - ValidatorAddr string `json:"address"` - PubKey string `json:"pubkey"` - Bond sdk.Coin `json:"bond"` + ValidatorAddr sdk.AccAddress `json:"address"` + PubKey string `json:"pubkey"` + Bond sdk.Coin `json:"bond"` }{ Description: msg.Description, - ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr), + ValidatorAddr: msg.ValidatorAddr, PubKey: sdk.MustBech32ifyValPub(msg.PubKey), }) if err != nil { @@ -86,10 +86,10 @@ func (msg MsgCreateValidator) ValidateBasic() sdk.Error { // MsgEditValidator - struct for editing a validator type MsgEditValidator struct { Description - ValidatorAddr sdk.Address `json:"address"` + ValidatorAddr sdk.AccAddress `json:"address"` } -func NewMsgEditValidator(validatorAddr sdk.Address, description Description) MsgEditValidator { +func NewMsgEditValidator(validatorAddr sdk.AccAddress, description Description) MsgEditValidator { return MsgEditValidator{ Description: description, ValidatorAddr: validatorAddr, @@ -98,18 +98,18 @@ func NewMsgEditValidator(validatorAddr sdk.Address, description Description) Msg //nolint func (msg MsgEditValidator) Type() string { return MsgType } -func (msg MsgEditValidator) GetSigners() []sdk.Address { - return []sdk.Address{msg.ValidatorAddr} +func (msg MsgEditValidator) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.ValidatorAddr} } // get the bytes for the message signer to sign on func (msg MsgEditValidator) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { Description - ValidatorAddr string `json:"address"` + ValidatorAddr sdk.AccAddress `json:"address"` }{ Description: msg.Description, - ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr), + ValidatorAddr: msg.ValidatorAddr, }) if err != nil { panic(err) @@ -133,12 +133,12 @@ func (msg MsgEditValidator) ValidateBasic() sdk.Error { // MsgDelegate - struct for bonding transactions type MsgDelegate struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorAddr sdk.Address `json:"validator_addr"` - Bond sdk.Coin `json:"bond"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorAddr sdk.AccAddress `json:"validator_addr"` + Bond sdk.Coin `json:"bond"` } -func NewMsgDelegate(delegatorAddr, validatorAddr sdk.Address, bond sdk.Coin) MsgDelegate { +func NewMsgDelegate(delegatorAddr, validatorAddr sdk.AccAddress, bond sdk.Coin) MsgDelegate { return MsgDelegate{ DelegatorAddr: delegatorAddr, ValidatorAddr: validatorAddr, @@ -148,19 +148,19 @@ func NewMsgDelegate(delegatorAddr, validatorAddr sdk.Address, bond sdk.Coin) Msg //nolint func (msg MsgDelegate) Type() string { return MsgType } -func (msg MsgDelegate) GetSigners() []sdk.Address { - return []sdk.Address{msg.DelegatorAddr} +func (msg MsgDelegate) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.DelegatorAddr} } // get the bytes for the message signer to sign on func (msg MsgDelegate) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorAddr string `json:"validator_addr"` - Bond sdk.Coin `json:"bond"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorAddr sdk.AccAddress `json:"validator_addr"` + Bond sdk.Coin `json:"bond"` }{ DelegatorAddr: msg.DelegatorAddr, - ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr), + ValidatorAddr: msg.ValidatorAddr, Bond: msg.Bond, }) if err != nil { @@ -187,14 +187,14 @@ func (msg MsgDelegate) ValidateBasic() sdk.Error { // MsgDelegate - struct for bonding transactions type MsgBeginRedelegate struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorSrcAddr sdk.Address `json:"validator_src_addr"` - ValidatorDstAddr sdk.Address `json:"validator_dst_addr"` - SharesAmount sdk.Rat `json:"shares_amount"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorSrcAddr sdk.AccAddress `json:"validator_src_addr"` + ValidatorDstAddr sdk.AccAddress `json:"validator_dst_addr"` + SharesAmount sdk.Rat `json:"shares_amount"` } func NewMsgBeginRedelegate(delegatorAddr, validatorSrcAddr, - validatorDstAddr sdk.Address, sharesAmount sdk.Rat) MsgBeginRedelegate { + validatorDstAddr sdk.AccAddress, sharesAmount sdk.Rat) MsgBeginRedelegate { return MsgBeginRedelegate{ DelegatorAddr: delegatorAddr, @@ -206,21 +206,21 @@ func NewMsgBeginRedelegate(delegatorAddr, validatorSrcAddr, //nolint func (msg MsgBeginRedelegate) Type() string { return MsgType } -func (msg MsgBeginRedelegate) GetSigners() []sdk.Address { - return []sdk.Address{msg.DelegatorAddr} +func (msg MsgBeginRedelegate) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.DelegatorAddr} } // get the bytes for the message signer to sign on func (msg MsgBeginRedelegate) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorSrcAddr string `json:"validator_src_addr"` - ValidatorDstAddr string `json:"validator_dst_addr"` - SharesAmount string `json:"shares"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorSrcAddr sdk.AccAddress `json:"validator_src_addr"` + ValidatorDstAddr sdk.AccAddress `json:"validator_dst_addr"` + SharesAmount string `json:"shares"` }{ DelegatorAddr: msg.DelegatorAddr, - ValidatorSrcAddr: sdk.MustBech32ifyVal(msg.ValidatorSrcAddr.Bytes()), - ValidatorDstAddr: sdk.MustBech32ifyVal(msg.ValidatorDstAddr.Bytes()), + ValidatorSrcAddr: msg.ValidatorSrcAddr.Bytes(), + ValidatorDstAddr: msg.ValidatorDstAddr.Bytes(), SharesAmount: msg.SharesAmount.String(), }) if err != nil { @@ -251,13 +251,13 @@ func (msg MsgBeginRedelegate) ValidateBasic() sdk.Error { // MsgDelegate - struct for bonding transactions type MsgCompleteRedelegate struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorSrcAddr sdk.Address `json:"validator_source_addr"` - ValidatorDstAddr sdk.Address `json:"validator_destination_addr"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorSrcAddr sdk.AccAddress `json:"validator_source_addr"` + ValidatorDstAddr sdk.AccAddress `json:"validator_destination_addr"` } func NewMsgCompleteRedelegate(delegatorAddr, validatorSrcAddr, - validatorDstAddr sdk.Address) MsgCompleteRedelegate { + validatorDstAddr sdk.AccAddress) MsgCompleteRedelegate { return MsgCompleteRedelegate{ DelegatorAddr: delegatorAddr, @@ -268,20 +268,20 @@ func NewMsgCompleteRedelegate(delegatorAddr, validatorSrcAddr, //nolint func (msg MsgCompleteRedelegate) Type() string { return MsgType } -func (msg MsgCompleteRedelegate) GetSigners() []sdk.Address { - return []sdk.Address{msg.DelegatorAddr} +func (msg MsgCompleteRedelegate) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.DelegatorAddr} } // get the bytes for the message signer to sign on func (msg MsgCompleteRedelegate) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorSrcAddr string `json:"validator_src_addr"` - ValidatorDstAddr string `json:"validator_dst_addr"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorSrcAddr sdk.AccAddress `json:"validator_src_addr"` + ValidatorDstAddr sdk.AccAddress `json:"validator_dst_addr"` }{ DelegatorAddr: msg.DelegatorAddr, - ValidatorSrcAddr: sdk.MustBech32ifyVal(msg.ValidatorSrcAddr), - ValidatorDstAddr: sdk.MustBech32ifyVal(msg.ValidatorDstAddr), + ValidatorSrcAddr: msg.ValidatorSrcAddr, + ValidatorDstAddr: msg.ValidatorDstAddr, }) if err != nil { panic(err) @@ -307,12 +307,12 @@ func (msg MsgCompleteRedelegate) ValidateBasic() sdk.Error { // MsgBeginUnbonding - struct for unbonding transactions type MsgBeginUnbonding struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorAddr sdk.Address `json:"validator_addr"` - SharesAmount sdk.Rat `json:"shares_amount"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorAddr sdk.AccAddress `json:"validator_addr"` + SharesAmount sdk.Rat `json:"shares_amount"` } -func NewMsgBeginUnbonding(delegatorAddr, validatorAddr sdk.Address, sharesAmount sdk.Rat) MsgBeginUnbonding { +func NewMsgBeginUnbonding(delegatorAddr, validatorAddr sdk.AccAddress, sharesAmount sdk.Rat) MsgBeginUnbonding { return MsgBeginUnbonding{ DelegatorAddr: delegatorAddr, ValidatorAddr: validatorAddr, @@ -321,18 +321,18 @@ func NewMsgBeginUnbonding(delegatorAddr, validatorAddr sdk.Address, sharesAmount } //nolint -func (msg MsgBeginUnbonding) Type() string { return MsgType } -func (msg MsgBeginUnbonding) GetSigners() []sdk.Address { return []sdk.Address{msg.DelegatorAddr} } +func (msg MsgBeginUnbonding) Type() string { return MsgType } +func (msg MsgBeginUnbonding) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.DelegatorAddr} } // get the bytes for the message signer to sign on func (msg MsgBeginUnbonding) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorAddr string `json:"validator_addr"` - SharesAmount string `json:"shares_amount"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorAddr sdk.AccAddress `json:"validator_addr"` + SharesAmount string `json:"shares_amount"` }{ DelegatorAddr: msg.DelegatorAddr, - ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr), + ValidatorAddr: msg.ValidatorAddr, SharesAmount: msg.SharesAmount.String(), }) if err != nil { @@ -360,11 +360,11 @@ func (msg MsgBeginUnbonding) ValidateBasic() sdk.Error { // MsgCompleteUnbonding - struct for unbonding transactions type MsgCompleteUnbonding struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorAddr sdk.Address `json:"validator_addr"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorAddr sdk.AccAddress `json:"validator_addr"` } -func NewMsgCompleteUnbonding(delegatorAddr, validatorAddr sdk.Address) MsgCompleteUnbonding { +func NewMsgCompleteUnbonding(delegatorAddr, validatorAddr sdk.AccAddress) MsgCompleteUnbonding { return MsgCompleteUnbonding{ DelegatorAddr: delegatorAddr, ValidatorAddr: validatorAddr, @@ -372,17 +372,19 @@ func NewMsgCompleteUnbonding(delegatorAddr, validatorAddr sdk.Address) MsgComple } //nolint -func (msg MsgCompleteUnbonding) Type() string { return MsgType } -func (msg MsgCompleteUnbonding) GetSigners() []sdk.Address { return []sdk.Address{msg.DelegatorAddr} } +func (msg MsgCompleteUnbonding) Type() string { return MsgType } +func (msg MsgCompleteUnbonding) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.DelegatorAddr} +} // get the bytes for the message signer to sign on func (msg MsgCompleteUnbonding) GetSignBytes() []byte { b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr sdk.Address `json:"delegator_addr"` - ValidatorAddr string `json:"validator_src_addr"` + DelegatorAddr sdk.AccAddress `json:"delegator_addr"` + ValidatorAddr sdk.AccAddress `json:"validator_src_addr"` }{ DelegatorAddr: msg.DelegatorAddr, - ValidatorAddr: sdk.MustBech32ifyVal(msg.ValidatorAddr.Bytes()), + ValidatorAddr: msg.ValidatorAddr.Bytes(), }) if err != nil { panic(err) diff --git a/x/stake/types/msg_test.go b/x/stake/types/msg_test.go index 1a854a4926..d4a971bab9 100644 --- a/x/stake/types/msg_test.go +++ b/x/stake/types/msg_test.go @@ -19,7 +19,7 @@ var ( func TestMsgCreateValidator(t *testing.T) { tests := []struct { name, moniker, identity, website, details string - validatorAddr sdk.Address + validatorAddr sdk.AccAddress pubkey crypto.PubKey bond sdk.Coin expectPass bool @@ -49,7 +49,7 @@ func TestMsgCreateValidator(t *testing.T) { func TestMsgEditValidator(t *testing.T) { tests := []struct { name, moniker, identity, website, details string - validatorAddr sdk.Address + validatorAddr sdk.AccAddress expectPass bool }{ {"basic good", "a", "b", "c", "d", addr1, true}, @@ -73,8 +73,8 @@ func TestMsgEditValidator(t *testing.T) { func TestMsgDelegate(t *testing.T) { tests := []struct { name string - delegatorAddr sdk.Address - validatorAddr sdk.Address + delegatorAddr sdk.AccAddress + validatorAddr sdk.AccAddress bond sdk.Coin expectPass bool }{ @@ -100,9 +100,9 @@ func TestMsgDelegate(t *testing.T) { func TestMsgBeginRedelegate(t *testing.T) { tests := []struct { name string - delegatorAddr sdk.Address - validatorSrcAddr sdk.Address - validatorDstAddr sdk.Address + delegatorAddr sdk.AccAddress + validatorSrcAddr sdk.AccAddress + validatorDstAddr sdk.AccAddress sharesAmount sdk.Rat expectPass bool }{ @@ -128,9 +128,9 @@ func TestMsgBeginRedelegate(t *testing.T) { func TestMsgCompleteRedelegate(t *testing.T) { tests := []struct { name string - delegatorAddr sdk.Address - validatorSrcAddr sdk.Address - validatorDstAddr sdk.Address + delegatorAddr sdk.AccAddress + validatorSrcAddr sdk.AccAddress + validatorDstAddr sdk.AccAddress expectPass bool }{ {"regular", addr1, addr2, addr3, true}, @@ -153,8 +153,8 @@ func TestMsgCompleteRedelegate(t *testing.T) { func TestMsgBeginUnbonding(t *testing.T) { tests := []struct { name string - delegatorAddr sdk.Address - validatorAddr sdk.Address + delegatorAddr sdk.AccAddress + validatorAddr sdk.AccAddress sharesAmount sdk.Rat expectPass bool }{ @@ -179,8 +179,8 @@ func TestMsgBeginUnbonding(t *testing.T) { func TestMsgCompleteUnbonding(t *testing.T) { tests := []struct { name string - delegatorAddr sdk.Address - validatorAddr sdk.Address + delegatorAddr sdk.AccAddress + validatorAddr sdk.AccAddress expectPass bool }{ {"regular", addr1, addr2, true}, diff --git a/x/stake/types/test_utils.go b/x/stake/types/test_utils.go index 02123ef8e4..d0622d46a8 100644 --- a/x/stake/types/test_utils.go +++ b/x/stake/types/test_utils.go @@ -14,11 +14,11 @@ var ( pk1 = crypto.GenPrivKeyEd25519().PubKey() pk2 = crypto.GenPrivKeyEd25519().PubKey() pk3 = crypto.GenPrivKeyEd25519().PubKey() - addr1 = sdk.Address(pk1.Address()) - addr2 = sdk.Address(pk2.Address()) - addr3 = sdk.Address(pk3.Address()) + addr1 = sdk.AccAddress(pk1.Address()) + addr2 = sdk.AccAddress(pk2.Address()) + addr3 = sdk.AccAddress(pk3.Address()) - emptyAddr sdk.Address + emptyAddr sdk.AccAddress emptyPubkey crypto.PubKey ) diff --git a/x/stake/types/validator.go b/x/stake/types/validator.go index 01ddd64f27..7b143364ad 100644 --- a/x/stake/types/validator.go +++ b/x/stake/types/validator.go @@ -23,9 +23,9 @@ const doNotModifyDescVal = "[do-not-modify]" // exchange rate. Voting power can be calculated as total bonds multiplied by // exchange rate. type Validator struct { - Owner sdk.Address `json:"owner"` // sender of BondTx - UnbondTx returns here - PubKey crypto.PubKey `json:"pub_key"` // pubkey of validator - Revoked bool `json:"revoked"` // has the validator been revoked from bonded status? + Owner sdk.AccAddress `json:"owner"` // sender of BondTx - UnbondTx returns here + PubKey crypto.PubKey `json:"pub_key"` // pubkey of validator + Revoked bool `json:"revoked"` // has the validator been revoked from bonded status? PoolShares PoolShares `json:"pool_shares"` // total shares for tokens held in the pool DelegatorShares sdk.Rat `json:"delegator_shares"` // total shares issued to a validator's delegators @@ -45,7 +45,7 @@ type Validator struct { } // NewValidator - initialize a new validator -func NewValidator(owner sdk.Address, pubKey crypto.PubKey, description Description) Validator { +func NewValidator(owner sdk.AccAddress, pubKey crypto.PubKey, description Description) Validator { return Validator{ Owner: owner, PubKey: pubKey, @@ -384,7 +384,7 @@ var _ sdk.Validator = Validator{} func (v Validator) GetRevoked() bool { return v.Revoked } func (v Validator) GetMoniker() string { return v.Description.Moniker } func (v Validator) GetStatus() sdk.BondStatus { return v.Status() } -func (v Validator) GetOwner() sdk.Address { return v.Owner } +func (v Validator) GetOwner() sdk.AccAddress { return v.Owner } func (v Validator) GetPubKey() crypto.PubKey { return v.PubKey } func (v Validator) GetPower() sdk.Rat { return v.PoolShares.Bonded() } func (v Validator) GetDelegatorShares() sdk.Rat { return v.DelegatorShares } From 96bc71404e438ddf7f96415d5af93e01a5216ea6 Mon Sep 17 00:00:00 2001 From: sunnya97 <sunnya97@protonmail.ch> Date: Sun, 8 Jul 2018 00:25:22 -0700 Subject: [PATCH 05/38] asdf --- client/lcd/lcd_test.go | 8 ++++---- examples/democoin/x/pow/types.go | 2 +- examples/democoin/x/pow/types_test.go | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go index e09e274023..ad32fa6a27 100644 --- a/client/lcd/lcd_test.go +++ b/client/lcd/lcd_test.go @@ -74,9 +74,9 @@ func TestKeys(t *testing.T) { addrBech32 := addr.String() require.Equal(t, name, m[0].Name, "Did not serve keys name correctly") - require.Equal(t, addrBech32, m[0].Address, "Did not serve keys Address correctly") + require.Equal(t, addrBech32, m[0].Address.String(), "Did not serve keys Address correctly") require.Equal(t, newName, m[1].Name, "Did not serve keys name correctly") - require.Equal(t, addr2Bech32, m[1].Address, "Did not serve keys Address correctly") + require.Equal(t, addr2Bech32, m[1].Address.String(), "Did not serve keys Address correctly") // select key keyEndpoint := fmt.Sprintf("/keys/%s", newName) @@ -87,7 +87,7 @@ func TestKeys(t *testing.T) { require.Nil(t, err) require.Equal(t, newName, m2.Name, "Did not serve keys name correctly") - require.Equal(t, addr2Bech32, m2.Address, "Did not serve keys Address correctly") + require.Equal(t, addr2Bech32, m2.Address.String(), "Did not serve keys Address correctly") // update key jsonStr = []byte(fmt.Sprintf(`{ @@ -197,7 +197,7 @@ func TestValidators(t *testing.T) { require.NotEqual(t, rpc.ResultValidatorsOutput{}, resultVals) - require.Contains(t, resultVals.Validators[0].Address, "cosmosvaladdr") + require.Contains(t, resultVals.Validators[0].Address.String(), "cosmosvaladdr") require.Contains(t, resultVals.Validators[0].PubKey, "cosmosvalpub") // -- diff --git a/examples/democoin/x/pow/types.go b/examples/democoin/x/pow/types.go index 52098d7875..2247a1e88c 100644 --- a/examples/democoin/x/pow/types.go +++ b/examples/democoin/x/pow/types.go @@ -34,7 +34,7 @@ func NewMsgMine(sender sdk.AccAddress, difficulty uint64, count uint64, nonce ui func (msg MsgMine) Type() string { return "pow" } func (msg MsgMine) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.Sender} } func (msg MsgMine) String() string { - return fmt.Sprintf("MsgMine{Sender: %v, Difficulty: %d, Count: %d, Nonce: %d, Proof: %s}", msg.Sender, msg.Difficulty, msg.Count, msg.Nonce, msg.Proof) + return fmt.Sprintf("MsgMine{Sender: %s, Difficulty: %d, Count: %d, Nonce: %d, Proof: %s}", msg.Sender, msg.Difficulty, msg.Count, msg.Nonce, msg.Proof) } // validate the mine message diff --git a/examples/democoin/x/pow/types_test.go b/examples/democoin/x/pow/types_test.go index 8c0f16b15b..be848d9408 100644 --- a/examples/democoin/x/pow/types_test.go +++ b/examples/democoin/x/pow/types_test.go @@ -55,14 +55,14 @@ func TestMsgMineString(t *testing.T) { addr := sdk.AccAddress([]byte("sender")) msg := MsgMine{addr, 0, 0, 0, []byte("abc")} res := msg.String() - require.Equal(t, res, "MsgMine{Sender: 73656E646572, Difficulty: 0, Count: 0, Nonce: 0, Proof: abc}") + require.Equal(t, res, "MsgMine{Sender: cosmosaccaddr1wdjkuer9wg4wml9c, Difficulty: 0, Count: 0, Nonce: 0, Proof: abc}") } func TestMsgMineGetSignBytes(t *testing.T) { addr := sdk.AccAddress([]byte("sender")) msg := MsgMine{addr, 1, 1, 1, []byte("abc")} res := msg.GetSignBytes() - require.Equal(t, string(res), `{"count":1,"difficulty":1,"nonce":1,"proof":"YWJj","sender":"73656E646572"}`) + require.Equal(t, string(res), `{"count":1,"difficulty":1,"nonce":1,"proof":"YWJj","sender":"cosmosaccaddr1wdjkuer9wg4wml9c"}`) } func TestMsgMineGetSigners(t *testing.T) { From d87c9ebc74318f664c3fbb5f94df01633869a5b6 Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Mon, 9 Jul 2018 00:29:09 -0700 Subject: [PATCH 06/38] fixed lcd errors --- x/bank/client/rest/sendtx.go | 9 +-------- x/ibc/client/rest/transfer.go | 11 +---------- x/slashing/msg_test.go | 2 +- 3 files changed, 3 insertions(+), 19 deletions(-) diff --git a/x/bank/client/rest/sendtx.go b/x/bank/client/rest/sendtx.go index bba491b52a..4029a42f4a 100644 --- a/x/bank/client/rest/sendtx.go +++ b/x/bank/client/rest/sendtx.go @@ -44,7 +44,7 @@ func SendRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.CoreCont vars := mux.Vars(r) bech32addr := vars["address"] - address, err := sdk.GetAccAddressBech32(bech32addr) + to, err := sdk.GetAccAddressBech32(bech32addr) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) @@ -72,13 +72,6 @@ func SendRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.CoreCont return } - to, err := sdk.GetAccAddressHex(address.String()) - if err != nil { - w.WriteHeader(http.StatusBadRequest) - w.Write([]byte(err.Error())) - return - } - // build message msg := client.BuildMsg(sdk.AccAddress(info.GetPubKey().Address()), to, m.Amount) if err != nil { // XXX rechecking same error ? diff --git a/x/ibc/client/rest/transfer.go b/x/ibc/client/rest/transfer.go index 139b79aee1..2540d14017 100644 --- a/x/ibc/client/rest/transfer.go +++ b/x/ibc/client/rest/transfer.go @@ -1,7 +1,6 @@ package rest import ( - "encoding/hex" "io/ioutil" "net/http" @@ -39,7 +38,7 @@ func TransferRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.Core destChainID := vars["destchain"] bech32addr := vars["address"] - address, err := sdk.GetAccAddressBech32(bech32addr) + to, err := sdk.GetAccAddressBech32(bech32addr) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) @@ -67,14 +66,6 @@ func TransferRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.Core return } - bz, err := hex.DecodeString(address.String()) - if err != nil { - w.WriteHeader(http.StatusBadRequest) - w.Write([]byte(err.Error())) - return - } - to := sdk.AccAddress(bz) - // build message packet := ibc.NewIBCPacket(sdk.AccAddress(info.GetPubKey().Address()), to, m.Amount, m.SrcChainID, destChainID) msg := ibc.IBCTransferMsg{packet} diff --git a/x/slashing/msg_test.go b/x/slashing/msg_test.go index 9c546da763..287eb6c5c5 100644 --- a/x/slashing/msg_test.go +++ b/x/slashing/msg_test.go @@ -12,5 +12,5 @@ func TestMsgUnrevokeGetSignBytes(t *testing.T) { addr := sdk.AccAddress("abcd") msg := NewMsgUnrevoke(addr) bytes := msg.GetSignBytes() - require.Equal(t, string(bytes), `{"address":"cosmosvaladdr1v93xxeqamr0mv"}`) + require.Equal(t, string(bytes), `{"address":"cosmosaccaddr1v93xxeqhyqz5v"}`) } From 25d976feb498d88d7b0b89f7fca847cde5b93fd3 Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Mon, 9 Jul 2018 01:47:38 -0700 Subject: [PATCH 07/38] works? --- baseapp/baseapp_test.go | 10 +++++----- client/keys/add.go | 24 ++++++++++++------------ cmd/gaia/app/genesis.go | 12 ++++++------ server/init.go | 8 ++++---- x/auth/stdtx_test.go | 2 +- x/bank/client/cli/sendtx.go | 9 +++------ x/bank/test_helpers.go | 4 ++-- x/mock/app.go | 12 ++++++------ x/mock/app_test.go | 10 +++++----- x/mock/test_utils.go | 2 +- x/slashing/test_common.go | 6 +++--- x/stake/keeper/delegation.go | 12 ++---------- x/stake/keeper/key.go | 2 +- x/stake/types/delegation.go | 14 +++++++------- 14 files changed, 58 insertions(+), 69 deletions(-) diff --git a/baseapp/baseapp_test.go b/baseapp/baseapp_test.go index 66695bbf39..4448d0e339 100644 --- a/baseapp/baseapp_test.go +++ b/baseapp/baseapp_test.go @@ -285,9 +285,9 @@ type msgCounter struct { } // Implements Msg -func (msg msgCounter) Type() string { return typeMsgCounter } -func (msg msgCounter) GetSignBytes() []byte { return nil } -func (msg msgCounter) GetSigners() []sdk.Address { return nil } +func (msg msgCounter) Type() string { return typeMsgCounter } +func (msg msgCounter) GetSignBytes() []byte { return nil } +func (msg msgCounter) GetSigners() []sdk.AccAddress { return nil } func (msg msgCounter) ValidateBasic() sdk.Error { if msg.Counter >= 0 { return nil @@ -323,8 +323,8 @@ type msgCounter2 struct { } // Implements Msg -func (msg msgCounter2) Type() string { return typeMsgCounter2 } -func (msg msgCounter2) GetSignBytes() []byte { return nil } +func (msg msgCounter2) Type() string { return typeMsgCounter2 } +func (msg msgCounter2) GetSignBytes() []byte { return nil } func (msg msgCounter2) GetSigners() []sdk.AccAddress { return nil } func (msg msgCounter2) ValidateBasic() sdk.Error { if msg.Counter >= 0 { diff --git a/client/keys/add.go b/client/keys/add.go index d21f106380..82e6a120ee 100644 --- a/client/keys/add.go +++ b/client/keys/add.go @@ -161,12 +161,6 @@ type NewKeyBody struct { Password string `json:"password"` } -// new key response REST body -type NewKeyResponse struct { - Address sdk.AccAddress `json:"address"` - Mnemonic string `json:"mnemonic"` -} - // add new key REST handler func AddNewKeyRequestHandler(w http.ResponseWriter, r *http.Request) { var kb keys.Keybase @@ -215,18 +209,24 @@ func AddNewKeyRequestHandler(w http.ResponseWriter, r *http.Request) { w.Write([]byte(err.Error())) return } - address := sdk.AccAddress(info.GetPubKey().Address().Bytes()) - bz, err := json.Marshal(NewKeyResponse{ - Address: address, - Mnemonic: mnemonic, - }) + + keyOutput, err := Bech32KeyOutput(info) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(err.Error())) return } - w.Write(output) + keyOutput.Seed = mnemonic + + bz, err := json.Marshal(keyOutput) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + w.Write([]byte(err.Error())) + return + } + + w.Write(bz) } // function to just a new seed to display in the UI before actually persisting it in the keybase diff --git a/cmd/gaia/app/genesis.go b/cmd/gaia/app/genesis.go index baa363a448..0472c46ada 100644 --- a/cmd/gaia/app/genesis.go +++ b/cmd/gaia/app/genesis.go @@ -36,14 +36,14 @@ type GenesisAccount struct { func NewGenesisAccount(acc *auth.BaseAccount) GenesisAccount { return GenesisAccount{ - Address: sdk.MustBech32ifyAcc(acc.Address), + Address: acc.Address, Coins: acc.Coins, } } func NewGenesisAccountI(acc auth.Account) GenesisAccount { return GenesisAccount{ - Address: sdk.MustBech32ifyAcc(acc.GetAddress()), + Address: acc.GetAddress(), Coins: acc.GetCoins(), } } @@ -51,7 +51,7 @@ func NewGenesisAccountI(acc auth.Account) GenesisAccount { // convert GenesisAccount to auth.BaseAccount func (ga *GenesisAccount) ToAccount() (acc *auth.BaseAccount) { return &auth.BaseAccount{ - Address: sdk.MustGetAccAddressBech32(ga.Address), + Address: ga.Address, Coins: ga.Coins.Sort(), } } @@ -78,7 +78,7 @@ func GaiaAppInit() server.AppInit { type GaiaGenTx struct { Name string `json:"name"` Address sdk.AccAddress `json:"address"` - PubKey string `json:"pub_key"` + PubKey string `json:"pub_key"` } // Generate a gaia genesis transaction with flags @@ -153,7 +153,7 @@ func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState } // create the genesis account, give'm few steaks and a buncha token with there name - accAuth := auth.NewBaseAccountWithAddress(sdk.MustGetAccAddressBech32(genTx.Address)) + accAuth := auth.NewBaseAccountWithAddress(genTx.Address) accAuth.Coins = sdk.Coins{ {genTx.Name + "Token", sdk.NewInt(1000)}, {"steak", sdk.NewInt(freeFermionsAcc)}, @@ -165,7 +165,7 @@ func GaiaAppGenState(cdc *wire.Codec, appGenTxs []json.RawMessage) (genesisState // add the validator if len(genTx.Name) > 0 { desc := stake.NewDescription(genTx.Name, "", "", "") - validator := stake.NewValidator(sdk.MustGetAccAddressBech32(genTx.Address), + validator := stake.NewValidator(genTx.Address, sdk.MustGetAccPubKeyBech32(genTx.PubKey), desc) stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens + freeFermionVal // increase the supply diff --git a/server/init.go b/server/init.go index ff8565c8a4..ef78081868 100644 --- a/server/init.go +++ b/server/init.go @@ -454,7 +454,7 @@ func GenerateCoinKey() (sdk.AccAddress, string, error) { // generate a private key, with recovery phrase info, secret, err := keybase.CreateMnemonic("name", keys.English, "pass", keys.Secp256k1) if err != nil { - return "", "", err + return sdk.AccAddress([]byte{}), "", err } addr := info.GetPubKey().Address() return sdk.AccAddress(addr), secret, nil @@ -467,21 +467,21 @@ func GenerateSaveCoinKey(clientRoot, keyName, keyPass string, overwrite bool) (s // get the keystore from the client keybase, err := clkeys.GetKeyBaseFromDir(clientRoot) if err != nil { - return "", "", err + return sdk.AccAddress([]byte{}), "", err } // ensure no overwrite if !overwrite { _, err := keybase.Get(keyName) if err == nil { - return "", "", errors.New("key already exists, overwrite is disabled") + return sdk.AccAddress([]byte{}), "", errors.New("key already exists, overwrite is disabled") } } // generate a private key, with recovery phrase info, secret, err := keybase.CreateMnemonic(keyName, keys.English, keyPass, keys.Secp256k1) if err != nil { - return "", "", err + return sdk.AccAddress([]byte{}), "", err } addr := info.GetPubKey().Address() return sdk.AccAddress(addr), secret, nil diff --git a/x/auth/stdtx_test.go b/x/auth/stdtx_test.go index 841470431d..bc94396637 100644 --- a/x/auth/stdtx_test.go +++ b/x/auth/stdtx_test.go @@ -28,7 +28,7 @@ func TestStdTx(t *testing.T) { func TestStdSignBytes(t *testing.T) { priv := crypto.GenPrivKeyEd25519() - addr := priv.PubKey().Address() + addr := sdk.AccAddress(priv.PubKey().Address()) msgs := []sdk.Msg{sdk.NewTestMsg(addr)} fee := newStdFee() signMsg := StdSignMsg{ diff --git a/x/bank/client/cli/sendtx.go b/x/bank/client/cli/sendtx.go index 8731de40e9..81a1f1fe2f 100644 --- a/x/bank/client/cli/sendtx.go +++ b/x/bank/client/cli/sendtx.go @@ -1,7 +1,7 @@ package cli import ( - "errors" + "github.com/pkg/errors" "github.com/cosmos/cosmos-sdk/client/context" sdk "github.com/cosmos/cosmos-sdk/types" @@ -37,11 +37,9 @@ func SendTxCmd(cdc *wire.Codec) *cobra.Command { return err } - bech32From := sdk.MustBech32ifyAcc(from) // Check if account was found if fromAcc == nil { - return errors.New("No account with address " + bech32From + - " was found in the state.\nAre you sure there has been a transaction involving it?") + return errors.Errorf("No account with address %s was found in the state.\nAre you sure there has been a transaction involving it?", from) } toStr := viper.GetString(flagTo) @@ -63,8 +61,7 @@ func SendTxCmd(cdc *wire.Codec) *cobra.Command { return err } if !account.GetCoins().IsGTE(coins) { - return errors.New("Address " + bech32From + - " doesn't have enough coins to pay for this transaction.") + return errors.Errorf("Address %s doesn't have enough coins to pay for this transaction.", from) } // build and sign the transaction, then broadcast to Tendermint diff --git a/x/bank/test_helpers.go b/x/bank/test_helpers.go index ecaae62817..1dad0ba267 100644 --- a/x/bank/test_helpers.go +++ b/x/bank/test_helpers.go @@ -58,7 +58,7 @@ func TotalCoinsInvariant(t *testing.T, app *mock.App, log string) { // accounts already exist. func TestAndRunSingleInputMsgSend(t *testing.T, r *rand.Rand, app *mock.App, ctx sdk.Context, keys []crypto.PrivKey, log string) (action string, err sdk.Error) { fromKey := keys[r.Intn(len(keys))] - fromAddr := fromKey.PubKey().Address() + fromAddr := sdk.AccAddress(fromKey.PubKey().Address()) toKey := keys[r.Intn(len(keys))] // Disallow sending money to yourself for { @@ -67,7 +67,7 @@ func TestAndRunSingleInputMsgSend(t *testing.T, r *rand.Rand, app *mock.App, ctx } toKey = keys[r.Intn(len(keys))] } - toAddr := toKey.PubKey().Address() + toAddr := sdk.AccAddress(toKey.PubKey().Address()) initFromCoins := app.AccountMapper.GetAccount(ctx, fromAddr).GetCoins() denomIndex := r.Intn(len(initFromCoins)) diff --git a/x/mock/app.go b/x/mock/app.go index dd8edb102f..83d17ba681 100644 --- a/x/mock/app.go +++ b/x/mock/app.go @@ -95,11 +95,11 @@ func (app *App) InitChainer(ctx sdk.Context, _ abci.RequestInitChain) abci.Respo // CreateGenAccounts generates genesis accounts loaded with coins, and returns // their addresses, pubkeys, and privkeys. -func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (genAccs []auth.Account, addrs []sdk.Address, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) { +func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (genAccs []auth.Account, addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) { for i := 0; i < numAccs; i++ { privKey := crypto.GenPrivKeyEd25519() pubKey := privKey.PubKey() - addr := pubKey.Address() + addr := sdk.AccAddress(pubKey.Address()) genAcc := &auth.BaseAccount{ Address: addr, @@ -166,19 +166,19 @@ func GeneratePrivKeys(n int) (keys []crypto.PrivKey) { // GeneratePrivKeyAddressPairs generates a total of n private key, address // pairs. -func GeneratePrivKeyAddressPairs(n int) (keys []crypto.PrivKey, addrs []sdk.Address) { +func GeneratePrivKeyAddressPairs(n int) (keys []crypto.PrivKey, addrs []sdk.AccAddress) { keys = make([]crypto.PrivKey, n, n) - addrs = make([]sdk.Address, n, n) + addrs = make([]sdk.AccAddress, n, n) for i := 0; i < n; i++ { keys[i] = crypto.GenPrivKeyEd25519() - addrs[i] = keys[i].PubKey().Address() + addrs[i] = sdk.AccAddress(keys[i].PubKey().Address()) } return } // RandomSetGenesis set genesis accounts with random coin values using the // provided addresses and coin denominations. -func RandomSetGenesis(r *rand.Rand, app *App, addrs []sdk.Address, denoms []string) { +func RandomSetGenesis(r *rand.Rand, app *App, addrs []sdk.AccAddress, denoms []string) { accts := make([]auth.Account, len(addrs), len(addrs)) randCoinIntervals := []BigInterval{ {sdk.NewIntWithDecimal(1, 0), sdk.NewIntWithDecimal(1, 1)}, diff --git a/x/mock/app_test.go b/x/mock/app_test.go index 7ee82474ce..0890b53ecc 100644 --- a/x/mock/app_test.go +++ b/x/mock/app_test.go @@ -19,7 +19,7 @@ var ( // testMsg is a mock transaction that has a validation which can fail. type testMsg struct { - signers []sdk.Address + signers []sdk.AccAddress positiveNum int64 } @@ -27,7 +27,7 @@ func (tx testMsg) Type() string { return msgType } func (tx testMsg) GetMsg() sdk.Msg { return tx } func (tx testMsg) GetMemo() string { return "" } func (tx testMsg) GetSignBytes() []byte { return nil } -func (tx testMsg) GetSigners() []sdk.Address { return tx.signers } +func (tx testMsg) GetSigners() []sdk.AccAddress { return tx.signers } func (tx testMsg) GetSignatures() []auth.StdSignature { return nil } func (tx testMsg) ValidateBasic() sdk.Error { if tx.positiveNum >= 0 { @@ -53,7 +53,7 @@ func TestCheckAndDeliverGenTx(t *testing.T) { SetGenesis(mApp, accs) ctxCheck := mApp.BaseApp.NewContext(true, abci.Header{}) - msg := testMsg{signers: []sdk.Address{addrs[0]}, positiveNum: 1} + msg := testMsg{signers: []sdk.AccAddress{addrs[0]}, positiveNum: 1} acct := mApp.AccountMapper.GetAccount(ctxCheck, addrs[0]) require.Equal(t, accs[0], acct.(*auth.BaseAccount)) @@ -86,14 +86,14 @@ func TestCheckGenTx(t *testing.T) { SetGenesis(mApp, accs) - msg1 := testMsg{signers: []sdk.Address{addrs[0]}, positiveNum: 1} + msg1 := testMsg{signers: []sdk.AccAddress{addrs[0]}, positiveNum: 1} CheckGenTx( t, mApp.BaseApp, []sdk.Msg{msg1}, []int64{accs[0].GetAccountNumber()}, []int64{accs[0].GetSequence()}, true, privKeys[0], ) - msg2 := testMsg{signers: []sdk.Address{addrs[0]}, positiveNum: -1} + msg2 := testMsg{signers: []sdk.AccAddress{addrs[0]}, positiveNum: -1} CheckGenTx( t, mApp.BaseApp, []sdk.Msg{msg2}, []int64{accs[0].GetAccountNumber()}, []int64{accs[0].GetSequence()}, diff --git a/x/mock/test_utils.go b/x/mock/test_utils.go index f9620c1403..f9e1e8f5e9 100644 --- a/x/mock/test_utils.go +++ b/x/mock/test_utils.go @@ -11,7 +11,7 @@ import ( ) // CheckBalance checks the balance of an account. -func CheckBalance(t *testing.T, app *App, addr sdk.Address, exp sdk.Coins) { +func CheckBalance(t *testing.T, app *App, addr sdk.AccAddress, exp sdk.Coins) { ctxCheck := app.BaseApp.NewContext(true, abci.Header{}) res := app.AccountMapper.GetAccount(ctxCheck, addr) diff --git a/x/slashing/test_common.go b/x/slashing/test_common.go index 41a13e3886..c5320cb24f 100644 --- a/x/slashing/test_common.go +++ b/x/slashing/test_common.go @@ -29,9 +29,9 @@ var ( newPubKey("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AFB52"), } addrs = []sdk.AccAddress{ - pks[0].Address(), - pks[1].Address(), - pks[2].Address(), + sdk.AccAddress(pks[0].Address()), + sdk.AccAddress(pks[1].Address()), + sdk.AccAddress(pks[2].Address()), } initCoins sdk.Int = sdk.NewInt(200) ) diff --git a/x/stake/keeper/delegation.go b/x/stake/keeper/delegation.go index c4b393f271..e2f96f3d9f 100644 --- a/x/stake/keeper/delegation.go +++ b/x/stake/keeper/delegation.go @@ -93,11 +93,7 @@ func (k Keeper) GetUnbondingDelegation(ctx sdk.Context, } // load all unbonding delegations from a particular validator -<<<<<<< HEAD -func (k Keeper) GetUnbondingDelegationsFromValidator(ctx sdk.Context, valAddr sdk.Address) (ubds []types.UnbondingDelegation) { -======= -func (k Keeper) GetUnbondingDelegationsFromValidator(ctx sdk.Context, valAddr sdk.AccAddress) (unbondingDelegations []types.UnbondingDelegation) { ->>>>>>> asdf +func (k Keeper) GetUnbondingDelegationsFromValidator(ctx sdk.Context, valAddr sdk.AccAddress) (ubds []types.UnbondingDelegation) { store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, GetUBDsByValIndexKey(valAddr)) for { @@ -149,11 +145,7 @@ func (k Keeper) GetRedelegation(ctx sdk.Context, } // load all redelegations from a particular validator -<<<<<<< HEAD -func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.Address) (reds []types.Redelegation) { -======= -func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.AccAddress) (redelegations []types.Redelegation) { ->>>>>>> asdf +func (k Keeper) GetRedelegationsFromValidator(ctx sdk.Context, valAddr sdk.AccAddress) (reds []types.Redelegation) { store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, GetREDsFromValSrcIndexKey(valAddr)) for { diff --git a/x/stake/keeper/key.go b/x/stake/keeper/key.go index 31f1c608fe..132add34a6 100644 --- a/x/stake/keeper/key.go +++ b/x/stake/keeper/key.go @@ -225,7 +225,7 @@ func GetREDsToValDstIndexKey(validatorDstAddr sdk.AccAddress) []byte { // get the prefix keyspace for all redelegations redelegating towards a destination validator // from a particular delegator -func GetREDsByDelToValDstIndexKey(delegatorAddr sdk.Address, validatorDstAddr sdk.AccAddress) []byte { +func GetREDsByDelToValDstIndexKey(delegatorAddr, validatorDstAddr sdk.AccAddress) []byte { return append( GetREDsToValDstIndexKey(validatorDstAddr), delegatorAddr.Bytes()...) diff --git a/x/stake/types/delegation.go b/x/stake/types/delegation.go index 6f923aaea3..2ceedd5f31 100644 --- a/x/stake/types/delegation.go +++ b/x/stake/types/delegation.go @@ -55,8 +55,8 @@ func UnmarshalDelegation(cdc *wire.Codec, key, value []byte) (delegation Delegat err = errors.New("unexpected key length") return } - delAddr := sdk.Address(addrs[:sdk.AddrLen]) - valAddr := sdk.Address(addrs[sdk.AddrLen:]) + delAddr := sdk.AccAddress(addrs[:sdk.AddrLen]) + valAddr := sdk.AccAddress(addrs[sdk.AddrLen:]) return Delegation{ DelegatorAddr: delAddr, @@ -145,8 +145,8 @@ func UnmarshalUBD(cdc *wire.Codec, key, value []byte) (ubd UnbondingDelegation, err = errors.New("unexpected key length") return } - delAddr := sdk.Address(addrs[:sdk.AddrLen]) - valAddr := sdk.Address(addrs[sdk.AddrLen:]) + delAddr := sdk.AccAddress(addrs[:sdk.AddrLen]) + valAddr := sdk.AccAddress(addrs[sdk.AddrLen:]) return UnbondingDelegation{ DelegatorAddr: delAddr, @@ -237,9 +237,9 @@ func UnmarshalRED(cdc *wire.Codec, key, value []byte) (red Redelegation, err err err = errors.New("unexpected key length") return } - delAddr := sdk.Address(addrs[:sdk.AddrLen]) - valSrcAddr := sdk.Address(addrs[sdk.AddrLen : 2*sdk.AddrLen]) - valDstAddr := sdk.Address(addrs[2*sdk.AddrLen:]) + delAddr := sdk.AccAddress(addrs[:sdk.AddrLen]) + valSrcAddr := sdk.AccAddress(addrs[sdk.AddrLen : 2*sdk.AddrLen]) + valDstAddr := sdk.AccAddress(addrs[2*sdk.AddrLen:]) return Redelegation{ DelegatorAddr: delAddr, From d7158b70a540fee331cc4f47113610fa3a03c1e6 Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Mon, 9 Jul 2018 02:05:19 -0700 Subject: [PATCH 08/38] fixed cli test --- cmd/gaia/cli_test/cli_test.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/cmd/gaia/cli_test/cli_test.go b/cmd/gaia/cli_test/cli_test.go index 0f82b38ee2..38a347b241 100644 --- a/cmd/gaia/cli_test/cli_test.go +++ b/cmd/gaia/cli_test/cli_test.go @@ -53,7 +53,7 @@ func TestGaiaCLISend(t *testing.T) { fooAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show foo --output=json --home=%s", gaiacliHome)) barAddr, _ := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome)) - + fooAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", fooAddr, flags)) require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf("steak").Int64()) @@ -107,7 +107,7 @@ func TestGaiaCLICreateValidator(t *testing.T) { barAddr, barPubKey := executeGetAddrPK(t, fmt.Sprintf("gaiacli keys show bar --output=json --home=%s", gaiacliHome)) barCeshPubKey := sdk.MustBech32ifyValPub(barPubKey) - executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%v --from=foo", flags, barAddr), pass) + executeWrite(t, fmt.Sprintf("gaiacli send %v --amount=10steak --to=%s --from=foo", flags, barAddr), pass) tests.WaitForNextHeightTM(port) barAcc := executeGetAccount(t, fmt.Sprintf("gaiacli account %s %v", barAddr, flags)) @@ -117,9 +117,9 @@ func TestGaiaCLICreateValidator(t *testing.T) { // create validator cvStr := fmt.Sprintf("gaiacli stake create-validator %v", flags) - cvStr += fmt.Sprintf(" --from=%v", "bar") - cvStr += fmt.Sprintf(" --address-validator=%v", barAddr) - cvStr += fmt.Sprintf(" --pubkey=%v", barCeshPubKey) + cvStr += fmt.Sprintf(" --from=%s", "bar") + cvStr += fmt.Sprintf(" --address-validator=%s", barAddr) + cvStr += fmt.Sprintf(" --pubkey=%s", barCeshPubKey) cvStr += fmt.Sprintf(" --amount=%v", "2steak") cvStr += fmt.Sprintf(" --moniker=%v", "bar-vally") @@ -135,7 +135,7 @@ func TestGaiaCLICreateValidator(t *testing.T) { // unbond a single share unbondStr := fmt.Sprintf("gaiacli stake unbond begin %v", flags) - unbondStr += fmt.Sprintf(" --from=%v", "bar") + unbondStr += fmt.Sprintf(" --from=%s", "bar") unbondStr += fmt.Sprintf(" --address-validator=%s", barAddr) unbondStr += fmt.Sprintf(" --address-delegator=%s", barAddr) unbondStr += fmt.Sprintf(" --shares-amount=%v", "1") From 9f2f47a0a5fa3ca949316f76d0c338645e08999d Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Mon, 9 Jul 2018 02:15:36 -0700 Subject: [PATCH 09/38] changelong --- CHANGELOG.md | 2 ++ docs/core/app1.md | 14 +++++++------- docs/core/app2.md | 8 ++++---- docs/core/app3.md | 16 ++++++++-------- 4 files changed, 21 insertions(+), 19 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 58cf20c879..1c0abab412 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -45,6 +45,8 @@ BREAKING CHANGES * [lcd] Switch key creation output to return bech32 * [x/stake] store-value for delegation, validator, ubd, and red do not hold duplicate information contained store-key * [gaiad] genesis transactions now use bech32 addresses / pubkeys +* [types] Renamed `sdk.Address` to `sdk.AccAddress`/`sdk.ValAddress` +* [types] `sdk.AccAddress`/`sdk.ValAddress` natively marshals to Bech32 in String, Sprintf (when used with `%s`), and MarshalJSON DEPRECATED * [cli] Deprecate `--name` flag in commands that send txs, in favor of `--from` diff --git a/docs/core/app1.md b/docs/core/app1.md index ba7f02a8d8..6977d2ddc3 100644 --- a/docs/core/app1.md +++ b/docs/core/app1.md @@ -30,7 +30,7 @@ type Msg interface { // Signers returns the addrs of signers that must sign. // CONTRACT: All signatures must be present to be valid. // CONTRACT: Returns addrs in some deterministic order. - GetSigners() []Address + GetSigners() []AccAddress } ``` @@ -43,8 +43,8 @@ For instance, take the simple token sending message type from app1.go: ```go // MsgSend to send coins from Input to Output type MsgSend struct { - From sdk.Address `json:"from"` - To sdk.Address `json:"to"` + From sdk.AccAddress `json:"from"` + To sdk.AccAddress `json:"to"` Amount sdk.Coins `json:"amount"` } @@ -65,8 +65,8 @@ func (msg MsgSend) GetSignBytes() []byte { } // Implements Msg. Return the signer. -func (msg MsgSend) GetSigners() []sdk.Address { - return []sdk.Address{msg.From} +func (msg MsgSend) GetSigners() []sdk.AccAddress { + return []sdk.AccAddress{msg.From} } ``` @@ -277,7 +277,7 @@ Coins](https://godoc.org/github.com/cosmos/cosmos-sdk/types#Coins). Now we're ready to handle the two parts of the MsgSend: ```go -func handleFrom(store sdk.KVStore, from sdk.Address, amt sdk.Coins) sdk.Result { +func handleFrom(store sdk.KVStore, from sdk.AccAddress, amt sdk.Coins) sdk.Result { // Get sender account from the store. accBytes := store.Get(from) if accBytes == nil { @@ -315,7 +315,7 @@ func handleFrom(store sdk.KVStore, from sdk.Address, amt sdk.Coins) sdk.Result { return sdk.Result{} } -func handleTo(store sdk.KVStore, to sdk.Address, amt sdk.Coins) sdk.Result { +func handleTo(store sdk.KVStore, to sdk.AccAddress, amt sdk.Coins) sdk.Result { // Add msg amount to receiver account accBytes := store.Get(to) var acc appAccount diff --git a/docs/core/app2.md b/docs/core/app2.md index f87ff557fc..0158976cd6 100644 --- a/docs/core/app2.md +++ b/docs/core/app2.md @@ -22,8 +22,8 @@ Let's introduce a new message type for issuing coins: // MsgIssue to allow a registered issuer // to issue new coins. type MsgIssue struct { - Issuer sdk.Address - Receiver sdk.Address + Issuer sdk.AccAddress + Receiver sdk.AccAddress Coin sdk.Coin } @@ -71,7 +71,7 @@ func handleMsgIssue(keyIssue *sdk.KVStoreKey, keyAcc *sdk.KVStoreKey) sdk.Handle } } -func handleIssuer(store sdk.KVStore, issuer sdk.Address, coin sdk.Coin) sdk.Result { +func handleIssuer(store sdk.KVStore, issuer sdk.AccAddress, coin sdk.Coin) sdk.Result { // the issuer address is stored directly under the coin denomination denom := []byte(coin.Denom) infoBytes := store.Get(denom) @@ -95,7 +95,7 @@ func handleIssuer(store sdk.KVStore, issuer sdk.Address, coin sdk.Coin) sdk.Resu // coinInfo stores meta data about a coin type coinInfo struct { - Issuer sdk.Address `json:"issuer"` + Issuer sdk.AccAddress `json:"issuer"` } ``` diff --git a/docs/core/app3.md b/docs/core/app3.md index eeaddda9e6..450b1a59e0 100644 --- a/docs/core/app3.md +++ b/docs/core/app3.md @@ -46,8 +46,8 @@ The `Account` interface captures this account model with getters and setters: // Account is a standard account using a sequence number for replay protection // and a pubkey for authentication. type Account interface { - GetAddress() sdk.Address - SetAddress(sdk.Address) error // errors if already set. + GetAddress() sdk.AccAddress + SetAddress(sdk.AccAddress) error // errors if already set. GetPubKey() crypto.PubKey // can return nil. SetPubKey(crypto.PubKey) error @@ -76,11 +76,11 @@ The default implementation of `Account` is the `BaseAccount`: // Extend this by embedding this in your AppAccount. // See the examples/basecoin/types/account.go for an example. type BaseAccount struct { - Address sdk.Address `json:"address"` - Coins sdk.Coins `json:"coins"` - PubKey crypto.PubKey `json:"public_key"` - AccountNumber int64 `json:"account_number"` - Sequence int64 `json:"sequence"` + Address sdk.AccAddress `json:"address"` + Coins sdk.Coins `json:"coins"` + PubKey crypto.PubKey `json:"public_key"` + AccountNumber int64 `json:"account_number"` + Sequence int64 `json:"sequence"` } ``` @@ -260,7 +260,7 @@ The PubKey is required for signature verification, but it is only required in the StdSignature once. From that point on, it will be stored in the account. The fee is paid by the first address returned by `msg.GetSigners()` for the first `Msg`, -as provided by the `FeePayer(tx Tx) sdk.Address` function. +as provided by the `FeePayer(tx Tx) sdk.AccAddress` function. ## CoinKeeper From 023b6c14832426b8c0a8b6ab569bd07b5a3157b3 Mon Sep 17 00:00:00 2001 From: Federico Kunze <fekunze@berkeley.edu> Date: Mon, 9 Jul 2018 10:43:53 -0400 Subject: [PATCH 10/38] Addressed comments from Gautier and Dev --- cmd/gaia/testnets/README.md | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/cmd/gaia/testnets/README.md b/cmd/gaia/testnets/README.md index 7d72d2de2f..33cf98f956 100644 --- a/cmd/gaia/testnets/README.md +++ b/cmd/gaia/testnets/README.md @@ -355,13 +355,28 @@ gaiacli stake delegation \ ## Governance -Governace is the process from which users in Cosmos can come to consensus on software updates, parameters of the mainnet or on custom proposals for independent sovereign zones/hubs. +Governance is the process from which users in the Cosmos Hub can come to consensus on software upgrades, parameters of the mainnet or on custom text proposals. -Governance is done through voting on proposals, which will be submitted by `Atom` holders on the mainnet. For more information about the governance process and how it works, please check out the Governance module [specification](https://github.com/cosmos/cosmos-sdk/tree/develop/docs/spec/governance). +Governance is done through voting on proposals, which will be submitted by `Atom` holders on the mainnet. + +Some considerations about + +- Voting is done by bonded Atom holders on a 1 bonded `Atom` 1 vote basis +- Delegators inherit the vote of their validator if they don't vote +- **Validators MUST vote on every proposal**. If a validator does not vote on a proposal, they will be **partially slashed**. +- Votes are tallied at the end of the voting period (2 weeks on mainnet). Each address can vote multiple times (paying the transaction fee each time), only the last casted vote will count. +- Voters can choose between options `Yes`, `No`, `NoWithVeto` and `Abstain` +At the end of the voting period, a proposal is accepted if `(YesVotes/(YesVotes+NoVotes+NoWithVetoVotes))>1/2` and `(NoWithVetoVotes/(YesVotes+NoVotes+NoWithVetoVotes))<1/3`. It is rejected otherwise. + +For more information about the governance process and how it works, please check out the Governance module [specification](https://github.com/cosmos/cosmos-sdk/tree/develop/docs/spec/governance). ### Create a Governance proposal -In order to create a governance proposal, you must submit an initial deposit along with the proposal details (_i.e_ `title`, `description` and `type`, which must be of value _Text_, _ParameterChange_ or _SoftwareUpgrade_): +In order to create a governance proposal, you must submit an initial deposit along with the proposal details: + +- `title`: Title of the proposal +- `description`: Description of the proposal +- `type`: Type of proposal. Must be of value _Text_ (types _SoftwareUpgrade_ and _ParameterChange_ not supported yet). ```bash gaiacli gov submit-proposal \ @@ -375,7 +390,7 @@ gaiacli gov submit-proposal \ ``` -### Rise deposit +### Increase deposit In order for a proposal to be broadcasted to the network, the amount deposited must be above a `minDeposit` value (default: `10 steak`). If the proposal you previously created didn't meet this requirement, you can still rise the total amount deposited to make it valid. Once the minimum deposit is reached, proposal enters voting period: @@ -388,7 +403,7 @@ gaiacli gov deposit \ --chain-id=gaia-7000 ``` -_NOTE_: Proposals that don't meet this requirement will be deleted. +_NOTE_: Proposals that don't meet this requirement will be deleted after `MaxDepositPeriod` is reached. #### Query proposal @@ -402,6 +417,8 @@ gaiacli gov query-proposal \ ### Vote on a proposal +After a proposal's deposit reaches the `MinDeposit` value, the voting period opens. Bonded Atom holders can then cast vote on it: + ```bash gaiacli gov vote \ --proposalID=<proposal_id> \ From ab2d5a73e3bc443b4922cce80d79c2fb618ad02b Mon Sep 17 00:00:00 2001 From: Federico Kunze <fekunze@berkeley.edu> Date: Mon, 9 Jul 2018 11:03:42 -0400 Subject: [PATCH 11/38] Typos and format --- cmd/gaia/testnets/README.md | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/cmd/gaia/testnets/README.md b/cmd/gaia/testnets/README.md index 33cf98f956..b266d7dcb4 100644 --- a/cmd/gaia/testnets/README.md +++ b/cmd/gaia/testnets/README.md @@ -310,11 +310,11 @@ WantedBy=multi-user.target ## Delegating to a Validator -On the upcoming mainnet, you can delegate `atom` to a validator. These [delegators](https://cosmos.network/resources/delegators) can receive part of the validator's fee revenue. Read more about the [Cosmos Token Model](https://github.com/cosmos/cosmos/raw/master/Cosmos_Token_Model.pdf). +On the upcoming mainnet, you can delegate `Atom` to a validator. These [delegators](https://cosmos.network/resources/delegators) can receive part of the validator's fee revenue. Read more about the [Cosmos Token Model](https://github.com/cosmos/cosmos/raw/master/Cosmos_Token_Model.pdf). ### Bond Tokens -On the testnet, we delegate `steak` instead of `atom`. Here's how you can bond tokens to a testnet validator: +On the testnet, we delegate `steak` instead of `Atom`. Here's how you can bond tokens to a testnet validator: ```bash gaiacli stake delegate \ @@ -355,18 +355,16 @@ gaiacli stake delegation \ ## Governance -Governance is the process from which users in the Cosmos Hub can come to consensus on software upgrades, parameters of the mainnet or on custom text proposals. +Governance is the process from which users in the Cosmos Hub can come to consensus on software upgrades, parameters of the mainnet or on custom text proposals. This is done through voting on proposals, which will be submitted by `Atom` holders on the mainnet. -Governance is done through voting on proposals, which will be submitted by `Atom` holders on the mainnet. +Some considerations about the voting process: -Some considerations about - -- Voting is done by bonded Atom holders on a 1 bonded `Atom` 1 vote basis +- Voting is done by bonded `Atom` holders on a 1 bonded `Atom` 1 vote basis - Delegators inherit the vote of their validator if they don't vote -- **Validators MUST vote on every proposal**. If a validator does not vote on a proposal, they will be **partially slashed**. -- Votes are tallied at the end of the voting period (2 weeks on mainnet). Each address can vote multiple times (paying the transaction fee each time), only the last casted vote will count. +- **Validators MUST vote on every proposal**. If a validator does not vote on a proposal, they will be **partially slashed** +- Votes are tallied at the end of the voting period (2 weeks on mainnet). Each address can vote multiple times (paying the transaction fee each time), only the last casted vote will count - Voters can choose between options `Yes`, `No`, `NoWithVeto` and `Abstain` -At the end of the voting period, a proposal is accepted if `(YesVotes/(YesVotes+NoVotes+NoWithVetoVotes))>1/2` and `(NoWithVetoVotes/(YesVotes+NoVotes+NoWithVetoVotes))<1/3`. It is rejected otherwise. +At the end of the voting period, a proposal is accepted if `(YesVotes/(YesVotes+NoVotes+NoWithVetoVotes))>1/2` and `(NoWithVetoVotes/(YesVotes+NoVotes+NoWithVetoVotes))<1/3`. It is rejected otherwise For more information about the governance process and how it works, please check out the Governance module [specification](https://github.com/cosmos/cosmos-sdk/tree/develop/docs/spec/governance). @@ -392,7 +390,7 @@ gaiacli gov submit-proposal \ ### Increase deposit -In order for a proposal to be broadcasted to the network, the amount deposited must be above a `minDeposit` value (default: `10 steak`). If the proposal you previously created didn't meet this requirement, you can still rise the total amount deposited to make it valid. Once the minimum deposit is reached, proposal enters voting period: +In order for a proposal to be broadcasted to the network, the amount deposited must be above a `minDeposit` value (default: `10 steak`). If the proposal you previously created didn't meet this requirement, you can still increase the total amount deposited to activate it. Once the minimum deposit is reached, the proposal enters voting period: ```bash gaiacli gov deposit \ @@ -403,7 +401,7 @@ gaiacli gov deposit \ --chain-id=gaia-7000 ``` -_NOTE_: Proposals that don't meet this requirement will be deleted after `MaxDepositPeriod` is reached. +> _NOTE_: Proposals that don't meet this requirement will be deleted after `MaxDepositPeriod` is reached. #### Query proposal @@ -417,7 +415,7 @@ gaiacli gov query-proposal \ ### Vote on a proposal -After a proposal's deposit reaches the `MinDeposit` value, the voting period opens. Bonded Atom holders can then cast vote on it: +After a proposal's deposit reaches the `MinDeposit` value, the voting period opens. Bonded `Atom` holders can then cast vote on it: ```bash gaiacli gov vote \ @@ -451,7 +449,7 @@ gaiacli send \ --to=<destination_cosmosaccaddr> ``` -> _*Note:*_ The `--amount` flag accepts the format `--amount=<value|coin_name>`. +> _*NOTE:*_ The `--amount` flag accepts the format `--amount=<value|coin_name>`. Now, view the updated balances of the origin and destination accounts: From 47948707539990ab5dae04de23d7371e38aaf7f8 Mon Sep 17 00:00:00 2001 From: Federico Kunze <fekunze@berkeley.edu> Date: Mon, 9 Jul 2018 11:10:56 -0400 Subject: [PATCH 12/38] Update CHANGELOG.md --- CHANGELOG.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 58cf20c879..a1170035af 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ BREAKING CHANGES * go-crypto, abci, tmlibs have been merged into Tendermint * Various other fixes * [auth] Signers of a transaction now only sign over their own account and sequence number -* [auth] Removed MsgChangePubKey +* [auth] Removed MsgChangePubKey * [auth] Removed SetPubKey from account mapper * [auth] AltBytes renamed to Memo, now a string, max 100 characters, costs a bit of gas * [types] `GetMsg()` -> `GetMsgs()` as txs wrap many messages @@ -78,7 +78,7 @@ FEATURES * [gaiacli] Ledger support added - You can now use a Ledger with `gaiacli --ledger` for all key-related commands - Ledger keys can be named and tracked locally in the key DB -* [testing] created a randomized testing framework. +* [testing] created a randomized testing framework. - Currently bank has limited functionality in the framework - Auth has its invariants checked within the framework * [gaiacli] added the following flags for commands that post transactions to the chain: @@ -98,6 +98,7 @@ IMPROVEMENTS * [keys] improve error message when deleting non-existent key * [gaiacli] improve error messages on `send` and `account` commands * added contributing guidelines +* [docs] Added commands for governance CLI on testnet README BUG FIXES * [x/slashing] \#1510 Unrevoked validators cannot un-revoke themselves From 841c322ddd2a0d91b2735139482236887d6bb579 Mon Sep 17 00:00:00 2001 From: Federico Kunze <fekunze@berkeley.edu> Date: Mon, 9 Jul 2018 11:30:32 -0400 Subject: [PATCH 13/38] Update Gov process considerations --- cmd/gaia/testnets/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/gaia/testnets/README.md b/cmd/gaia/testnets/README.md index b266d7dcb4..86dc62e74f 100644 --- a/cmd/gaia/testnets/README.md +++ b/cmd/gaia/testnets/README.md @@ -362,7 +362,7 @@ Some considerations about the voting process: - Voting is done by bonded `Atom` holders on a 1 bonded `Atom` 1 vote basis - Delegators inherit the vote of their validator if they don't vote - **Validators MUST vote on every proposal**. If a validator does not vote on a proposal, they will be **partially slashed** -- Votes are tallied at the end of the voting period (2 weeks on mainnet). Each address can vote multiple times (paying the transaction fee each time), only the last casted vote will count +- Votes are tallied at the end of the voting period (2 weeks on mainnet). Each address can vote multiple times to update its `Option` value (paying the transaction fee each time), only the last casted vote will count as valid - Voters can choose between options `Yes`, `No`, `NoWithVeto` and `Abstain` At the end of the voting period, a proposal is accepted if `(YesVotes/(YesVotes+NoVotes+NoWithVetoVotes))>1/2` and `(NoWithVetoVotes/(YesVotes+NoVotes+NoWithVetoVotes))<1/3`. It is rejected otherwise From a768543d92a1a555338056f354a51af92dee321b Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Sat, 7 Jul 2018 18:59:06 -0700 Subject: [PATCH 14/38] tools: Add code complexity linter, gocyclo Gocyclo is a code complexity linter. It uses cyclomatic complexity. Cyclomatic complexity essentially measures the number of different paths code could go through. (The conditional in a for loop counts as adding one path) It looks at this on a per-function level. The idea that this would be enforcing is that if there are too many different paths code can go through in a function, it needs to be better split up. (A function with too many code paths is hard to reason about) The complexity which we want the linter to start failing on is configurable. The default is 10. Change the "Cyclo" parameter in `tools/gometalinter.json` to try other values. --- CHANGELOG.md | 1 + tools/Makefile | 15 +++++++++++++++ tools/gometalinter.json | 5 +++-- 3 files changed, 19 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e63d01c4b4..48ddab70f8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -70,6 +70,7 @@ FEATURES * ineffassign * errcheck * unparam + * gocyclo * [tools] Add `make format` command to automate fixing misspell and gofmt errors. * [server] Default config now creates a profiler at port 6060, and increase p2p send/recv rates * [tests] Add WaitForNextNBlocksTM helper method diff --git a/tools/Makefile b/tools/Makefile index 195e67aa52..d58f52d1b1 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -12,6 +12,7 @@ INEFFASSIGN = github.com/gordonklaus/ineffassign MISSPELL = github.com/client9/misspell/cmd/misspell ERRCHECK = github.com/kisielk/errcheck UNPARAM = mvdan.cc/unparam +GOCYCLO = github.com/alecthomas/gocyclo DEP_CHECK := $(shell command -v dep 2> /dev/null) GOLINT_CHECK := $(shell command -v golint 2> /dev/null) @@ -21,6 +22,7 @@ INEFFASSIGN_CHECK := $(shell command -v ineffassign 2> /dev/null) MISSPELL_CHECK := $(shell command -v misspell 2> /dev/null) ERRCHECK_CHECK := $(shell command -v errcheck 2> /dev/null) UNPARAM_CHECK := $(shell command -v unparam 2> /dev/null) +GOCYCLO_CHECK := $(shell command -v gocyclo 2> /dev/null) check_tools: ifndef DEP_CHECK @@ -63,6 +65,11 @@ ifndef UNPARAM_CHECK else @echo "Found unparam in path." endif +ifndef GOCYCLO_CHECK + @echo "No gocyclo in path. Install with 'make get_tools'." +else + @echo "Found gocyclo in path." +endif get_tools: ifdef DEP_CHECK @@ -113,6 +120,12 @@ else @echo "Installing unparam" go get -v $(UNPARAM) endif +ifdef GOYCLO_CHECK + @echo "goyclo is already installed. Run 'make update_tools' to update." +else + @echo "Installing goyclo" + go get -v $(GOCYCLO) +endif update_tools: @echo "Updating dep" @@ -131,6 +144,8 @@ update_tools: go get -u -v $(ERRCHECK) @echo "Updating unparam" go get -u -v $(UNPARAM) + @echo "Updating goyclo" + go get -u -v $(GOCYCLO) # To avoid unintended conflicts with file names, always add to .PHONY # unless there is a reason not to. diff --git a/tools/gometalinter.json b/tools/gometalinter.json index a6c74eebbb..32ae434c49 100644 --- a/tools/gometalinter.json +++ b/tools/gometalinter.json @@ -2,7 +2,8 @@ "Linters": { "vet": "go tool vet -composites=false :PATH:LINE:MESSAGE" }, - "Enable": ["golint", "vet", "ineffassign", "unparam", "unconvert", "misspell"], + "Enable": ["golint", "vet", "ineffassign", "unparam", "unconvert", "misspell", "gocyclo"], "Deadline": "500s", - "Vendor": true + "Vendor": true, + "Cyclo": 10 } \ No newline at end of file From 2b5ccdbf879009d96a02389e7b863c9126d6cccf Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Sat, 7 Jul 2018 19:34:46 -0700 Subject: [PATCH 15/38] Reduce code complexity in AnteHandler, and GetExternalIP --- server/util.go | 36 +++++++++++++++-------- x/auth/ante.go | 79 ++++++++++++++++++++++++++------------------------ 2 files changed, 65 insertions(+), 50 deletions(-) diff --git a/server/util.go b/server/util.go index 0f1816b166..1e6ed06c98 100644 --- a/server/util.go +++ b/server/util.go @@ -149,24 +149,15 @@ func externalIP() (string, error) { return "", err } for _, iface := range ifaces { - if iface.Flags&net.FlagUp == 0 { - continue // interface down - } - if iface.Flags&net.FlagLoopback != 0 { - continue // loopback interface + if skipInterface(iface) { + continue } addrs, err := iface.Addrs() if err != nil { return "", err } for _, addr := range addrs { - var ip net.IP - switch v := addr.(type) { - case *net.IPNet: - ip = v.IP - case *net.IPAddr: - ip = v.IP - } + ip := addrToIP(addr) if ip == nil || ip.IsLoopback() { continue } @@ -179,3 +170,24 @@ func externalIP() (string, error) { } return "", errors.New("are you connected to the network?") } + +func skipInterface(iface net.Interface) bool { + if iface.Flags&net.FlagUp == 0 { + return true // interface down + } + if iface.Flags&net.FlagLoopback != 0 { + return true // loopback interface + } + return false +} + +func addrToIP(addr net.Addr) net.IP { + var ip net.IP + switch v := addr.(type) { + case *net.IPNet: + ip = v.IP + case *net.IPAddr: + ip = v.IP + } + return ip +} diff --git a/x/auth/ante.go b/x/auth/ante.go index ff3145d456..c71b174743 100644 --- a/x/auth/ante.go +++ b/x/auth/ante.go @@ -29,45 +29,26 @@ func NewAnteHandler(am AccountMapper, fck FeeCollectionKeeper) sdk.AnteHandler { return ctx, sdk.ErrInternal("tx must be StdTx").Result(), true } - // Assert that there are signatures. - var sigs = stdTx.GetSignatures() - if len(sigs) == 0 { - return ctx, - sdk.ErrUnauthorized("no signers").Result(), - true + err := validateBasic(stdTx) + if err != nil { + return ctx, err.Result(), true } - memo := stdTx.GetMemo() - - if len(memo) > maxMemoCharacters { - return ctx, - sdk.ErrMemoTooLarge(fmt.Sprintf("maximum number of characters is %d but received %d characters", maxMemoCharacters, len(memo))).Result(), - true - } + sigs := stdTx.GetSignatures() + signerAddrs := stdTx.GetSigners() + msgs := tx.GetMsgs() // set the gas meter ctx = ctx.WithGasMeter(sdk.NewGasMeter(stdTx.Fee.Gas)) // charge gas for the memo - ctx.GasMeter().ConsumeGas(memoCostPerByte*sdk.Gas(len(memo)), "memo") - - msgs := tx.GetMsgs() - - // Assert that number of signatures is correct. - var signerAddrs = stdTx.GetSigners() - if len(sigs) != len(signerAddrs) { - return ctx, - sdk.ErrUnauthorized("wrong number of signers").Result(), - true - } + ctx.GasMeter().ConsumeGas(memoCostPerByte*sdk.Gas(len(stdTx.GetMemo())), "memo") // Get the sign bytes (requires all account & sequence numbers and the fee) - sequences := make([]int64, len(signerAddrs)) - for i := 0; i < len(signerAddrs); i++ { + sequences := make([]int64, len(sigs)) + accNums := make([]int64, len(sigs)) + for i := 0; i < len(sigs); i++ { sequences[i] = sigs[i].Sequence - } - accNums := make([]int64, len(signerAddrs)) - for i := 0; i < len(signerAddrs); i++ { accNums[i] = sigs[i].AccountNumber } fee := stdTx.Fee @@ -88,16 +69,15 @@ func NewAnteHandler(am AccountMapper, fck FeeCollectionKeeper) sdk.AnteHandler { } // first sig pays the fees - if i == 0 { - // TODO: min fee - if !fee.Amount.IsZero() { - ctx.GasMeter().ConsumeGas(deductFeesCost, "deductFees") - signerAcc, res = deductFees(signerAcc, fee) - if !res.IsOK() { - return ctx, res, true - } - fck.addCollectedFees(ctx, fee.Amount) + // TODO: Add min fees + // Can this function be moved outside of the loop? + if i == 0 && !fee.Amount.IsZero() { + ctx.GasMeter().ConsumeGas(deductFeesCost, "deductFees") + signerAcc, res = deductFees(signerAcc, fee) + if !res.IsOK() { + return ctx, res, true } + fck.addCollectedFees(ctx, fee.Amount) } // Save the account. @@ -114,6 +94,29 @@ func NewAnteHandler(am AccountMapper, fck FeeCollectionKeeper) sdk.AnteHandler { } } +// Validate the transaction based on things that don't depend on the context +func validateBasic(tx StdTx) (err sdk.Error) { + // Assert that there are signatures. + sigs := tx.GetSignatures() + if len(sigs) == 0 { + return sdk.ErrUnauthorized("no signers") + } + + // Assert that number of signatures is correct. + var signerAddrs = tx.GetSigners() + if len(sigs) != len(signerAddrs) { + return sdk.ErrUnauthorized("wrong number of signers") + } + + memo := tx.GetMemo() + if len(memo) > maxMemoCharacters { + return sdk.ErrMemoTooLarge( + fmt.Sprintf("maximum number of characters is %d but received %d characters", + maxMemoCharacters, len(memo))) + } + return nil +} + // verify the signature and increment the sequence. // if the account doesn't have a pubkey, set it. func processSig( From 0c5358c2676b0a2be66540d22411a29f72e28ed6 Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 13:54:28 -0700 Subject: [PATCH 16/38] Continue reducing code complexity: * Adds a Min function to Int, and uses that in the slash function * Adds a getHeight helper function to iavlstore * Adds a splitPath function to baseapp * Changes cyclo param from 10 to 11 --- baseapp/baseapp.go | 13 +++++++++---- store/iavlstore.go | 33 ++++++++++++++++++++------------- tools/gometalinter.json | 2 +- types/int.go | 17 +++++++++++++++++ x/stake/keeper/slash.go | 10 ++-------- 5 files changed, 49 insertions(+), 26 deletions(-) diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index 9c7ce727fa..f4f213279c 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -324,14 +324,19 @@ func (app *BaseApp) FilterPeerByPubKey(info string) abci.ResponseQuery { return abci.ResponseQuery{} } -// Implements ABCI. -// Delegates to CommitMultiStore if it implements Queryable -func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { - path := strings.Split(req.Path, "/") +func splitPath(requestPath string) (path []string) { + path = strings.Split(requestPath, "/") // first element is empty string if len(path) > 0 && path[0] == "" { path = path[1:] } + return path +} + +// Implements ABCI. +// Delegates to CommitMultiStore if it implements Queryable +func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { + path := splitPath(req.Path) // "/app" prefix for special application queries if len(path) >= 2 && path[0] == "app" { var result sdk.Result diff --git a/store/iavlstore.go b/store/iavlstore.go index e5d5095728..d05c867c2e 100644 --- a/store/iavlstore.go +++ b/store/iavlstore.go @@ -153,6 +153,20 @@ func (st *iavlStore) ReverseIterator(start, end []byte) Iterator { return newIAVLIterator(st.tree.Tree(), start, end, false) } +// Handle gatest the latest height, if height is 0 +func getHeight(tree *iavl.VersionedTree, req abci.RequestQuery) int64 { + height := req.Height + if height == 0 { + latest := tree.Version64() + if tree.VersionExists(latest - 1) { + height = latest - 1 + } else { + height = latest + } + } + return height +} + // Query implements ABCI interface, allows queries // // by default we will return from (latest height -1), @@ -167,24 +181,17 @@ func (st *iavlStore) Query(req abci.RequestQuery) (res abci.ResponseQuery) { } tree := st.tree - height := req.Height - if height == 0 { - latest := tree.Version64() - if tree.VersionExists(latest - 1) { - height = latest - 1 - } else { - height = latest - } - } - // store the height we chose in the response - res.Height = height + + // store the height we chose in the response, with 0 being changed to the + // latest height + res.Height = getHeight(tree, req) switch req.Path { case "/store", "/key": // Get by key key := req.Data // Data holds the key bytes res.Key = key if req.Prove { - value, proof, err := tree.GetVersionedWithProof(key, height) + value, proof, err := tree.GetVersionedWithProof(key, res.Height) if err != nil { res.Log = err.Error() break @@ -198,7 +205,7 @@ func (st *iavlStore) Query(req abci.RequestQuery) (res abci.ResponseQuery) { } res.Proof = p } else { - _, res.Value = tree.GetVersioned(key, height) + _, res.Value = tree.GetVersioned(key, res.Height) } case "/subspace": subspace := req.Data diff --git a/tools/gometalinter.json b/tools/gometalinter.json index 32ae434c49..124e28c147 100644 --- a/tools/gometalinter.json +++ b/tools/gometalinter.json @@ -5,5 +5,5 @@ "Enable": ["golint", "vet", "ineffassign", "unparam", "unconvert", "misspell", "gocyclo"], "Deadline": "500s", "Vendor": true, - "Cyclo": 10 + "Cyclo": 11 } \ No newline at end of file diff --git a/types/int.go b/types/int.go index d04c6a80cd..0227203cdc 100644 --- a/types/int.go +++ b/types/int.go @@ -37,6 +37,13 @@ func mod(i *big.Int, i2 *big.Int) *big.Int { return new(big.Int).Mod(i, i2) } func neg(i *big.Int) *big.Int { return new(big.Int).Neg(i) } +func min(i *big.Int, i2 *big.Int) *big.Int { + if i.Cmp(i2) == 1 { + return new(big.Int).Set(i2) + } + return new(big.Int).Set(i) +} + // MarshalAmino for custom encoding scheme func marshalAmino(i *big.Int) (string, error) { bz, err := i.MarshalText() @@ -227,6 +234,11 @@ func (i Int) Neg() (res Int) { return Int{neg(i.i)} } +// Return the minimum of the ints +func MinInt(i1, i2 Int) Int { + return Int{min(i1.BigInt(), i2.BigInt())} +} + func (i Int) String() string { return i.i.String() } @@ -419,6 +431,11 @@ func (i Uint) DivRaw(i2 uint64) Uint { return i.Div(NewUint(i2)) } +// Return the minimum of the Uints +func MinUint(i1, i2 Uint) Uint { + return Uint{min(i1.BigInt(), i2.BigInt())} +} + // MarshalAmino defines custom encoding scheme func (i Uint) MarshalAmino() (string, error) { if i.i == nil { // Necessary since default Uint initialization has i.i as nil diff --git a/x/stake/keeper/slash.go b/x/stake/keeper/slash.go index f194d656cb..a2080eab93 100644 --- a/x/stake/keeper/slash.go +++ b/x/stake/keeper/slash.go @@ -81,10 +81,7 @@ func (k Keeper) Slash(ctx sdk.Context, pubkey crypto.PubKey, infractionHeight in } // Cannot decrease balance below zero - sharesToRemove := remainingSlashAmount - if sharesToRemove.GT(validator.PoolShares.Amount.RoundInt()) { - sharesToRemove = validator.PoolShares.Amount.RoundInt() - } + sharesToRemove := sdk.MinInt(remainingSlashAmount, validator.PoolShares.Amount.RoundInt()) // Get the current pool pool := k.GetPool(ctx) @@ -163,10 +160,7 @@ func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty // Possible since the unbonding delegation may already // have been slashed, and slash amounts are calculated // according to stake held at time of infraction - unbondingSlashAmount := slashAmount - if unbondingSlashAmount.GT(unbondingDelegation.Balance.Amount) { - unbondingSlashAmount = unbondingDelegation.Balance.Amount - } + unbondingSlashAmount := sdk.MinInt(slashAmount, unbondingDelegation.Balance.Amount) // Update unbonding delegation if necessary if !unbondingSlashAmount.IsZero() { From 1433b61a92531756fb420382306647d1d0ea5d30 Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 14:11:51 -0700 Subject: [PATCH 17/38] Missed a min in slashing --- x/stake/keeper/slash.go | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/x/stake/keeper/slash.go b/x/stake/keeper/slash.go index a2080eab93..44bc2aade6 100644 --- a/x/stake/keeper/slash.go +++ b/x/stake/keeper/slash.go @@ -202,10 +202,7 @@ func (k Keeper) slashRedelegation(ctx sdk.Context, validator types.Validator, re // Possible since the redelegation may already // have been slashed, and slash amounts are calculated // according to stake held at time of infraction - redelegationSlashAmount := slashAmount - if redelegationSlashAmount.GT(redelegation.Balance.Amount) { - redelegationSlashAmount = redelegation.Balance.Amount - } + redelegationSlashAmount := sdk.MinInt(slashAmount, redelegation.Balance.Amount) // Update redelegation if necessary if !redelegationSlashAmount.IsZero() { From 2a419a3192e4b44cca4ed244d80d9f32d84f6705 Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 14:21:29 -0700 Subject: [PATCH 18/38] add helper to UpdateBondedValidatorsFull --- x/stake/keeper/inflation_test.go | 1 + x/stake/keeper/validator.go | 6 +++++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/x/stake/keeper/inflation_test.go b/x/stake/keeper/inflation_test.go index 2fee8154a0..28efc0c59b 100644 --- a/x/stake/keeper/inflation_test.go +++ b/x/stake/keeper/inflation_test.go @@ -342,6 +342,7 @@ func checkValidatorSetup(t *testing.T, pool types.Pool, initialTotalTokens, init } // Checks that The inflation will correctly increase or decrease after an update to the pool +// nolint: gocyclo func checkInflation(t *testing.T, pool types.Pool, previousInflation, updatedInflation sdk.Rat, msg string) { inflationChange := updatedInflation.Sub(previousInflation) diff --git a/x/stake/keeper/validator.go b/x/stake/keeper/validator.go index 233c7b6e87..e8713c04d5 100644 --- a/x/stake/keeper/validator.go +++ b/x/stake/keeper/validator.go @@ -422,6 +422,11 @@ func (k Keeper) UpdateBondedValidatorsFull(ctx sdk.Context) { iterator.Close() // perform the actual kicks + kickOutValidators(k, ctx, toKickOut) + return +} + +func kickOutValidators(k Keeper, ctx sdk.Context, toKickOut map[string]byte) { for key := range toKickOut { ownerAddr := []byte(key) validator, found := k.GetValidator(ctx, ownerAddr) @@ -430,7 +435,6 @@ func (k Keeper) UpdateBondedValidatorsFull(ctx sdk.Context) { } k.unbondValidator(ctx, validator) } - return } // perform all the store operations for when a validator status becomes unbonded From e906272ca075c35937aff99b47274a6808a3215f Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 14:44:01 -0700 Subject: [PATCH 19/38] Reduce complexity of baseapp query --- baseapp/baseapp.go | 50 ++++++++++++++++++++++++++++++--------- x/ibc/client/cli/relay.go | 2 ++ 2 files changed, 41 insertions(+), 11 deletions(-) diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index f4f213279c..0316663d35 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -337,8 +337,26 @@ func splitPath(requestPath string) (path []string) { // Delegates to CommitMultiStore if it implements Queryable func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { path := splitPath(req.Path) + if len(path) == 0 { + msg := "no query path provided" + return sdk.ErrUnknownRequest(msg).QueryResult() + } + switch path[0] { // "/app" prefix for special application queries - if len(path) >= 2 && path[0] == "app" { + case "app": + return handleQueryApp(app, path, req) + case "store": + return handleQueryStore(app, path, req) + case "p2p": + return handleQueryP2P(app, path, req) + } + + msg := "unknown query path" + return sdk.ErrUnknownRequest(msg).QueryResult() +} + +func handleQueryApp(app *BaseApp, path []string, req abci.RequestQuery) (res abci.ResponseQuery) { + if len(path) >= 2 { var result sdk.Result switch path[1] { case "simulate": @@ -363,18 +381,24 @@ func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { Value: value, } } + msg := "Expected second parameter to be either simulate or version, neither was present" + return sdk.ErrUnknownRequest(msg).QueryResult() +} + +func handleQueryStore(app *BaseApp, path []string, req abci.RequestQuery) (res abci.ResponseQuery) { // "/store" prefix for store queries - if len(path) >= 1 && path[0] == "store" { - queryable, ok := app.cms.(sdk.Queryable) - if !ok { - msg := "multistore doesn't support queries" - return sdk.ErrUnknownRequest(msg).QueryResult() - } - req.Path = "/" + strings.Join(path[1:], "/") - return queryable.Query(req) + queryable, ok := app.cms.(sdk.Queryable) + if !ok { + msg := "multistore doesn't support queries" + return sdk.ErrUnknownRequest(msg).QueryResult() } + req.Path = "/" + strings.Join(path[1:], "/") + return queryable.Query(req) +} + +func handleQueryP2P(app *BaseApp, path []string, req abci.RequestQuery) (res abci.ResponseQuery) { // "/p2p" prefix for p2p queries - if len(path) >= 4 && path[0] == "p2p" { + if len(path) >= 4 { if path[1] == "filter" { if path[2] == "addr" { return app.FilterPeerByAddrPort(path[3]) @@ -384,9 +408,13 @@ func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { // NOTE: this changed in tendermint and we didn't notice... return app.FilterPeerByPubKey(path[3]) } + } else { + msg := "Expected second parameter to be filter" + return sdk.ErrUnknownRequest(msg).QueryResult() } } - msg := "unknown query path" + + msg := "Expected path is p2p filter <addr|pubkey> <parameter>" return sdk.ErrUnknownRequest(msg).QueryResult() } diff --git a/x/ibc/client/cli/relay.go b/x/ibc/client/cli/relay.go index d434ff35a4..1c5a61a18f 100644 --- a/x/ibc/client/cli/relay.go +++ b/x/ibc/client/cli/relay.go @@ -86,6 +86,8 @@ func (c relayCommander) runIBCRelay(cmd *cobra.Command, args []string) { c.loop(fromChainID, fromChainNode, toChainID, toChainNode) } +// This is nolinted as someone is in the process of refactoring this to remove the goto +// nolint: gocyclo func (c relayCommander) loop(fromChainID, fromChainNode, toChainID, toChainNode string) { From 592419c83a1b804eb925c31c628c16d306f5df2d Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 15:00:55 -0700 Subject: [PATCH 20/38] Reduce code complexity of testnet command --- server/testnet.go | 69 ++++++++++++++++++++++++++--------------------- 1 file changed, 39 insertions(+), 30 deletions(-) diff --git a/server/testnet.go b/server/testnet.go index d102b87ccb..d7e4ec9ac7 100644 --- a/server/testnet.go +++ b/server/testnet.go @@ -60,10 +60,11 @@ Example: } func testnetWithConfig(config *cfg.Config, cdc *wire.Codec, appInit AppInit) error { - outDir := viper.GetString(outputDir) + numValidators := viper.GetInt(nValidators) + // Generate private key, node ID, initial transaction - for i := 0; i < viper.GetInt(nValidators); i++ { + for i := 0; i < numValidators; i++ { nodeDirName := fmt.Sprintf("%s%d", viper.GetString(nodeDirPrefix), i) nodeDir := filepath.Join(outDir, nodeDirName, "gaiad") clientDir := filepath.Join(outDir, nodeDirName, "gaiacli") @@ -83,18 +84,9 @@ func testnetWithConfig(config *cfg.Config, cdc *wire.Codec, appInit AppInit) err } config.Moniker = nodeDirName - - ip := viper.GetString(startingIPAddress) - if len(ip) == 0 { - ip, err = externalIP() - if err != nil { - return err - } - } else { - ip, err = calculateIP(ip, i) - if err != nil { - return err - } + ip, err := getIP(i) + if err != nil { + return err } genTxConfig := gc.GenTx{ @@ -112,35 +104,22 @@ func testnetWithConfig(config *cfg.Config, cdc *wire.Codec, appInit AppInit) err // Save private key seed words name := fmt.Sprintf("%v.json", "key_seed") - writePath := filepath.Join(clientDir) - file := filepath.Join(writePath, name) - err = cmn.EnsureDir(writePath, 0700) - if err != nil { - return err - } - err = cmn.WriteFile(file, cliPrint, 0600) + err = writeFile(name, clientDir, cliPrint) if err != nil { return err } // Gather gentxs folder name = fmt.Sprintf("%v.json", nodeDirName) - writePath = filepath.Join(gentxsDir) - file = filepath.Join(writePath, name) - err = cmn.EnsureDir(writePath, 0700) + err = writeFile(name, gentxsDir, genTxFile) if err != nil { return err } - err = cmn.WriteFile(file, genTxFile, 0644) - if err != nil { - return err - } - } // Generate genesis.json and config.toml chainID := "chain-" + cmn.RandStr(6) - for i := 0; i < viper.GetInt(nValidators); i++ { + for i := 0; i < numValidators; i++ { nodeDirName := fmt.Sprintf("%s%d", viper.GetString(nodeDirPrefix), i) nodeDir := filepath.Join(outDir, nodeDirName, "gaiad") @@ -165,6 +144,36 @@ func testnetWithConfig(config *cfg.Config, cdc *wire.Codec, appInit AppInit) err return nil } +func getIP(i int) (ip string, err error) { + ip = viper.GetString(startingIPAddress) + if len(ip) == 0 { + ip, err = externalIP() + if err != nil { + return "", err + } + } else { + ip, err = calculateIP(ip, i) + if err != nil { + return "", err + } + } + return ip, nil +} + +func writeFile(name string, dir string, contents []byte) error { + writePath := filepath.Join(dir) + file := filepath.Join(writePath, name) + err := cmn.EnsureDir(writePath, 0700) + if err != nil { + return err + } + err = cmn.WriteFile(file, contents, 0600) + if err != nil { + return err + } + return nil +} + func calculateIP(ip string, i int) (string, error) { ipv4 := net.ParseIP(ip).To4() if ipv4 == nil { From 896cd333f08ff24246d69c1feb0c66e57aaf6010 Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Mon, 9 Jul 2018 16:06:05 -0700 Subject: [PATCH 21/38] address comments --- client/lcd/lcd_test.go | 2 +- cmd/gaia/cmd/gaiadebug/main.go | 4 +-- types/account.go | 51 ++++++++++++++++----------------- x/auth/client/cli/account.go | 2 +- x/auth/client/rest/query.go | 2 +- x/bank/client/cli/sendtx.go | 2 +- x/bank/client/rest/sendtx.go | 2 +- x/gov/client/cli/tx.go | 8 +++--- x/gov/client/rest/rest.go | 14 ++++----- x/ibc/client/rest/transfer.go | 2 +- x/slashing/client/cli/tx.go | 2 +- x/slashing/client/rest/query.go | 2 +- x/slashing/client/rest/tx.go | 2 +- x/stake/client/cli/query.go | 22 +++++++------- x/stake/client/cli/tx.go | 28 +++++++++--------- x/stake/client/rest/query.go | 14 ++++----- x/stake/client/rest/tx.go | 24 ++++++++-------- x/stake/keeper/test_common.go | 6 ++-- 18 files changed, 93 insertions(+), 96 deletions(-) diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go index ad32fa6a27..b5800ca292 100644 --- a/client/lcd/lcd_test.go +++ b/client/lcd/lcd_test.go @@ -61,7 +61,7 @@ func TestKeys(t *testing.T) { require.Nil(t, err, body) addr2Bech32 := resp.Address.String() - _, err = sdk.GetAccAddressBech32(addr2Bech32) + _, err = sdk.AccAddressFromBech32(addr2Bech32) require.NoError(t, err, "Failed to return a correct bech32 address") // existing keys diff --git a/cmd/gaia/cmd/gaiadebug/main.go b/cmd/gaia/cmd/gaiadebug/main.go index f56a757a8a..bff79870b1 100644 --- a/cmd/gaia/cmd/gaiadebug/main.go +++ b/cmd/gaia/cmd/gaiadebug/main.go @@ -158,10 +158,10 @@ func runAddrCmd(cmd *cobra.Command, args []string) error { addr, err = hex.DecodeString(addrString) if err != nil { var err2 error - addr, err2 = sdk.GetAccAddressBech32(addrString) + addr, err2 = sdk.AccAddressFromBech32(addrString) if err2 != nil { var err3 error - addr, err3 = sdk.GetValAddressBech32(addrString) + addr, err3 = sdk.ValAddressFromBech32(addrString) if err3 != nil { return fmt.Errorf(`Expected hex or bech32. Got errors: diff --git a/types/account.go b/types/account.go index 4cfc7e9d43..daa3b614e8 100644 --- a/types/account.go +++ b/types/account.go @@ -2,6 +2,7 @@ package types import ( "encoding/hex" + "encoding/json" "errors" "fmt" @@ -23,11 +24,12 @@ const ( //__________________________________________________________ -// AccAddress is a go crypto-style Address +// AccAddress a wrapper around bytes meant to represent an account address +// When marshaled to a string or json, it uses bech32 type AccAddress []byte -// create an Address from a hex string -func GetAccAddressHex(address string) (addr AccAddress, err error) { +// create an AccAddress from a hex string +func AccAddressFromHex(address string) (addr AccAddress, err error) { if len(address) == 0 { return addr, errors.New("decoding bech32 address failed: must provide an address") } @@ -38,8 +40,8 @@ func GetAccAddressHex(address string) (addr AccAddress, err error) { return AccAddress(bz), nil } -// create an Address from a bech32 string -func GetAccAddressBech32(address string) (addr AccAddress, err error) { +// create an AccAddress from a bech32 string +func AccAddressFromBech32(address string) (addr AccAddress, err error) { bz, err := GetFromBech32(address, Bech32PrefixAccAddr) if err != nil { return nil, err @@ -60,21 +62,18 @@ func (bz *AccAddress) Unmarshal(data []byte) error { // Marshals to JSON using Bech32 func (bz AccAddress) MarshalJSON() ([]byte, error) { - s := bz.String() - jbz := make([]byte, len(s)+2) - jbz[0] = '"' - copy(jbz[1:], []byte(s)) - jbz[len(jbz)-1] = '"' - return jbz, nil + return json.Marshal(bz.String()) } // Unmarshals from JSON assuming Bech32 encoding func (bz *AccAddress) UnmarshalJSON(data []byte) error { - if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' { - return fmt.Errorf("Invalid bech32 string: %s", data) + var s string + err := json.Unmarshal(data, &s) + if err != nil { + return nil } - bz2, err := GetAccAddressBech32(string(data[1 : len(data)-1])) + bz2, err := AccAddressFromBech32(s) if err != nil { return err } @@ -109,11 +108,12 @@ func (bz AccAddress) Format(s fmt.State, verb rune) { //__________________________________________________________ -// Address is a go crypto-style Address +// AccAddress a wrapper around bytes meant to represent a validator address +// (from over ABCI). When marshaled to a string or json, it uses bech32 type ValAddress []byte // create a ValAddress from a hex string -func GetValAddressHex(address string) (addr ValAddress, err error) { +func ValAddressFromHex(address string) (addr ValAddress, err error) { if len(address) == 0 { return addr, errors.New("decoding bech32 address failed: must provide an address") } @@ -125,7 +125,7 @@ func GetValAddressHex(address string) (addr ValAddress, err error) { } // create a ValAddress from a bech32 string -func GetValAddressBech32(address string) (addr ValAddress, err error) { +func ValAddressFromBech32(address string) (addr ValAddress, err error) { bz, err := GetFromBech32(address, Bech32PrefixValAddr) if err != nil { return nil, err @@ -146,21 +146,18 @@ func (bz *ValAddress) Unmarshal(data []byte) error { // Marshals to JSON using Bech32 func (bz ValAddress) MarshalJSON() ([]byte, error) { - s := bz.String() - jbz := make([]byte, len(s)+2) - jbz[0] = '"' - copy(jbz[1:], []byte(s)) - jbz[len(jbz)-1] = '"' - return jbz, nil + return json.Marshal(bz.String()) } // Unmarshals from JSON assuming Bech32 encoding func (bz *ValAddress) UnmarshalJSON(data []byte) error { - if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' { - return fmt.Errorf("Invalid bech32 string: %s", data) + var s string + err := json.Unmarshal(data, &s) + if err != nil { + return nil } - bz2, err := GetValAddressBech32(string(data[1 : len(data)-1])) + bz2, err := ValAddressFromBech32(s) if err != nil { return err } @@ -212,7 +209,7 @@ func Bech32ifyValPub(pub crypto.PubKey) (string, error) { return bech32.ConvertAndEncode(Bech32PrefixValPub, pub.Bytes()) } -// MustBech32ifyValPub pancis on bech32-encoding failure +// MustBech32ifyValPub panics on bech32-encoding failure func MustBech32ifyValPub(pub crypto.PubKey) string { enc, err := Bech32ifyValPub(pub) if err != nil { diff --git a/x/auth/client/cli/account.go b/x/auth/client/cli/account.go index 47980a64ca..5fc8545b95 100644 --- a/x/auth/client/cli/account.go +++ b/x/auth/client/cli/account.go @@ -41,7 +41,7 @@ func GetAccountCmd(storeName string, cdc *wire.Codec, decoder auth.AccountDecode // find the key to look up the account addr := args[0] - key, err := sdk.GetAccAddressBech32(addr) + key, err := sdk.AccAddressFromBech32(addr) if err != nil { return err } diff --git a/x/auth/client/rest/query.go b/x/auth/client/rest/query.go index a5d6f328c6..5cdc2ee257 100644 --- a/x/auth/client/rest/query.go +++ b/x/auth/client/rest/query.go @@ -27,7 +27,7 @@ func QueryAccountRequestHandlerFn(storeName string, cdc *wire.Codec, decoder aut vars := mux.Vars(r) bech32addr := vars["address"] - addr, err := sdk.GetAccAddressBech32(bech32addr) + addr, err := sdk.AccAddressFromBech32(bech32addr) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) diff --git a/x/bank/client/cli/sendtx.go b/x/bank/client/cli/sendtx.go index 81a1f1fe2f..b294e8cc74 100644 --- a/x/bank/client/cli/sendtx.go +++ b/x/bank/client/cli/sendtx.go @@ -44,7 +44,7 @@ func SendTxCmd(cdc *wire.Codec) *cobra.Command { toStr := viper.GetString(flagTo) - to, err := sdk.GetAccAddressBech32(toStr) + to, err := sdk.AccAddressFromBech32(toStr) if err != nil { return err } diff --git a/x/bank/client/rest/sendtx.go b/x/bank/client/rest/sendtx.go index 4029a42f4a..872b3cfe36 100644 --- a/x/bank/client/rest/sendtx.go +++ b/x/bank/client/rest/sendtx.go @@ -44,7 +44,7 @@ func SendRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.CoreCont vars := mux.Vars(r) bech32addr := vars["address"] - to, err := sdk.GetAccAddressBech32(bech32addr) + to, err := sdk.AccAddressFromBech32(bech32addr) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) diff --git a/x/gov/client/cli/tx.go b/x/gov/client/cli/tx.go index 89b5c2eb17..1c5c11b71e 100644 --- a/x/gov/client/cli/tx.go +++ b/x/gov/client/cli/tx.go @@ -38,7 +38,7 @@ func GetCmdSubmitProposal(cdc *wire.Codec) *cobra.Command { initialDeposit := viper.GetString(flagDeposit) // get the from address from the name flag - from, err := sdk.GetAccAddressBech32(viper.GetString(flagProposer)) + from, err := sdk.AccAddressFromBech32(viper.GetString(flagProposer)) if err != nil { return err } @@ -90,7 +90,7 @@ func GetCmdDeposit(cdc *wire.Codec) *cobra.Command { Short: "deposit tokens for activing proposal", RunE: func(cmd *cobra.Command, args []string) error { // get the from address from the name flag - depositer, err := sdk.GetAccAddressBech32(viper.GetString(flagDepositer)) + depositer, err := sdk.AccAddressFromBech32(viper.GetString(flagDepositer)) if err != nil { return err } @@ -136,7 +136,7 @@ func GetCmdVote(cdc *wire.Codec) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { bechVoter := viper.GetString(flagVoter) - voter, err := sdk.GetAccAddressBech32(bechVoter) + voter, err := sdk.AccAddressFromBech32(bechVoter) if err != nil { return err } @@ -218,7 +218,7 @@ func GetCmdQueryVote(storeName string, cdc *wire.Codec) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { proposalID := viper.GetInt64(flagProposalID) - voterAddr, err := sdk.GetAccAddressBech32(viper.GetString(flagVoter)) + voterAddr, err := sdk.AccAddressFromBech32(viper.GetString(flagVoter)) if err != nil { return err } diff --git a/x/gov/client/rest/rest.go b/x/gov/client/rest/rest.go index 6ffed71f39..d8a0acd8c7 100644 --- a/x/gov/client/rest/rest.go +++ b/x/gov/client/rest/rest.go @@ -68,7 +68,7 @@ func postProposalHandlerFn(cdc *wire.Codec, ctx context.CoreContext) http.Handle return } - proposer, err := sdk.GetAccAddressBech32(req.Proposer) + proposer, err := sdk.AccAddressFromBech32(req.Proposer) if err != nil { writeErr(&w, http.StatusBadRequest, err.Error()) return @@ -122,7 +122,7 @@ func depositHandlerFn(cdc *wire.Codec, ctx context.CoreContext) http.HandlerFunc return } - depositer, err := sdk.GetAccAddressBech32(req.Depositer) + depositer, err := sdk.AccAddressFromBech32(req.Depositer) if err != nil { writeErr(&w, http.StatusBadRequest, err.Error()) return @@ -170,7 +170,7 @@ func voteHandlerFn(cdc *wire.Codec, ctx context.CoreContext) http.HandlerFunc { return } - voter, err := sdk.GetAccAddressBech32(req.Voter) + voter, err := sdk.AccAddressFromBech32(req.Voter) if err != nil { writeErr(&w, http.StatusBadRequest, err.Error()) return @@ -264,7 +264,7 @@ func queryDepositHandlerFn(cdc *wire.Codec) http.HandlerFunc { return } - depositerAddr, err := sdk.GetAccAddressBech32(bechDepositerAddr) + depositerAddr, err := sdk.AccAddressFromBech32(bechDepositerAddr) if err != nil { w.WriteHeader(http.StatusBadRequest) err := errors.Errorf("'%s' needs to be bech32 encoded", RestDepositer) @@ -330,7 +330,7 @@ func queryVoteHandlerFn(cdc *wire.Codec) http.HandlerFunc { return } - voterAddr, err := sdk.GetAccAddressBech32(bechVoterAddr) + voterAddr, err := sdk.AccAddressFromBech32(bechVoterAddr) if err != nil { w.WriteHeader(http.StatusBadRequest) err := errors.Errorf("'%s' needs to be bech32 encoded", RestVoter) @@ -379,7 +379,7 @@ func queryProposalsWithParameterFn(cdc *wire.Codec) http.HandlerFunc { var depositerAddr sdk.AccAddress if len(bechVoterAddr) != 0 { - voterAddr, err = sdk.GetAccAddressBech32(bechVoterAddr) + voterAddr, err = sdk.AccAddressFromBech32(bechVoterAddr) if err != nil { w.WriteHeader(http.StatusBadRequest) err := errors.Errorf("'%s' needs to be bech32 encoded", RestVoter) @@ -389,7 +389,7 @@ func queryProposalsWithParameterFn(cdc *wire.Codec) http.HandlerFunc { } if len(bechDepositerAddr) != 0 { - depositerAddr, err = sdk.GetAccAddressBech32(bechDepositerAddr) + depositerAddr, err = sdk.AccAddressFromBech32(bechDepositerAddr) if err != nil { w.WriteHeader(http.StatusBadRequest) err := errors.Errorf("'%s' needs to be bech32 encoded", RestDepositer) diff --git a/x/ibc/client/rest/transfer.go b/x/ibc/client/rest/transfer.go index 2540d14017..bee9f955f4 100644 --- a/x/ibc/client/rest/transfer.go +++ b/x/ibc/client/rest/transfer.go @@ -38,7 +38,7 @@ func TransferRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.Core destChainID := vars["destchain"] bech32addr := vars["address"] - to, err := sdk.GetAccAddressBech32(bech32addr) + to, err := sdk.AccAddressFromBech32(bech32addr) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) diff --git a/x/slashing/client/cli/tx.go b/x/slashing/client/cli/tx.go index c73b2e162f..15458ad1a8 100644 --- a/x/slashing/client/cli/tx.go +++ b/x/slashing/client/cli/tx.go @@ -19,7 +19,7 @@ func GetCmdUnrevoke(cdc *wire.Codec) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { ctx := context.NewCoreContextFromViper().WithDecoder(authcmd.GetAccountDecoder(cdc)) - validatorAddr, err := sdk.GetAccAddressBech32(args[0]) + validatorAddr, err := sdk.AccAddressFromBech32(args[0]) if err != nil { return err } diff --git a/x/slashing/client/rest/query.go b/x/slashing/client/rest/query.go index 9842ada732..123e235ce0 100644 --- a/x/slashing/client/rest/query.go +++ b/x/slashing/client/rest/query.go @@ -27,7 +27,7 @@ func signingInfoHandlerFn(ctx context.CoreContext, storeName string, cdc *wire.C vars := mux.Vars(r) bech32validator := vars["validator"] - validatorAddr, err := sdk.GetValAddressBech32(bech32validator) + validatorAddr, err := sdk.ValAddressFromBech32(bech32validator) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) diff --git a/x/slashing/client/rest/tx.go b/x/slashing/client/rest/tx.go index 212487ddf1..f358075447 100644 --- a/x/slashing/client/rest/tx.go +++ b/x/slashing/client/rest/tx.go @@ -57,7 +57,7 @@ func unrevokeRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.Core return } - validatorAddr, err := sdk.GetAccAddressBech32(m.ValidatorAddr) + validatorAddr, err := sdk.AccAddressFromBech32(m.ValidatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) diff --git a/x/stake/client/cli/query.go b/x/stake/client/cli/query.go index e703e8a54c..c2d85d4b1a 100644 --- a/x/stake/client/cli/query.go +++ b/x/stake/client/cli/query.go @@ -22,7 +22,7 @@ func GetCmdQueryValidator(storeName string, cdc *wire.Codec) *cobra.Command { Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { - addr, err := sdk.GetAccAddressBech32(args[0]) + addr, err := sdk.AccAddressFromBech32(args[0]) if err != nil { return err } @@ -114,12 +114,12 @@ func GetCmdQueryDelegation(storeName string, cdc *wire.Codec) *cobra.Command { Short: "Query a delegation based on address and validator address", RunE: func(cmd *cobra.Command, args []string) error { - valAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidator)) + valAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator)) if err != nil { return err } - delAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) + delAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } @@ -166,7 +166,7 @@ func GetCmdQueryDelegations(storeName string, cdc *wire.Codec) *cobra.Command { Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { - delegatorAddr, err := sdk.GetAccAddressBech32(args[0]) + delegatorAddr, err := sdk.AccAddressFromBech32(args[0]) if err != nil { return err } @@ -204,12 +204,12 @@ func GetCmdQueryUnbondingDelegation(storeName string, cdc *wire.Codec) *cobra.Co Short: "Query an unbonding-delegation record based on delegator and validator address", RunE: func(cmd *cobra.Command, args []string) error { - valAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidator)) + valAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator)) if err != nil { return err } - delAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) + delAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } @@ -256,7 +256,7 @@ func GetCmdQueryUnbondingDelegations(storeName string, cdc *wire.Codec) *cobra.C Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { - delegatorAddr, err := sdk.GetAccAddressBech32(args[0]) + delegatorAddr, err := sdk.AccAddressFromBech32(args[0]) if err != nil { return err } @@ -294,15 +294,15 @@ func GetCmdQueryRedelegation(storeName string, cdc *wire.Codec) *cobra.Command { Short: "Query an unbonding-delegation record based on delegator and validator address", RunE: func(cmd *cobra.Command, args []string) error { - valSrcAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidatorSrc)) + valSrcAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorSrc)) if err != nil { return err } - valDstAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidatorDst)) + valDstAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorDst)) if err != nil { return err } - delAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) + delAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } @@ -349,7 +349,7 @@ func GetCmdQueryRedelegations(storeName string, cdc *wire.Codec) *cobra.Command Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { - delegatorAddr, err := sdk.GetAccAddressBech32(args[0]) + delegatorAddr, err := sdk.AccAddressFromBech32(args[0]) if err != nil { return err } diff --git a/x/stake/client/cli/tx.go b/x/stake/client/cli/tx.go index 7b4d11db5e..801710fc34 100644 --- a/x/stake/client/cli/tx.go +++ b/x/stake/client/cli/tx.go @@ -28,7 +28,7 @@ func GetCmdCreateValidator(cdc *wire.Codec) *cobra.Command { if err != nil { return err } - validatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidator)) + validatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator)) if err != nil { return err } @@ -75,7 +75,7 @@ func GetCmdEditValidator(cdc *wire.Codec) *cobra.Command { Short: "edit and existing validator account", RunE: func(cmd *cobra.Command, args []string) error { - validatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidator)) + validatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator)) if err != nil { return err } @@ -115,11 +115,11 @@ func GetCmdDelegate(cdc *wire.Codec) *cobra.Command { return err } - delegatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) + delegatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } - validatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidator)) + validatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator)) if err != nil { return err } @@ -166,15 +166,15 @@ func GetCmdBeginRedelegate(storeName string, cdc *wire.Codec) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { var err error - delegatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) + delegatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } - validatorSrcAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidatorSrc)) + validatorSrcAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorSrc)) if err != nil { return err } - validatorDstAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidatorDst)) + validatorDstAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorDst)) if err != nil { return err } @@ -259,15 +259,15 @@ func GetCmdCompleteRedelegate(cdc *wire.Codec) *cobra.Command { Short: "complete redelegation", RunE: func(cmd *cobra.Command, args []string) error { - delegatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) + delegatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } - validatorSrcAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidatorSrc)) + validatorSrcAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorSrc)) if err != nil { return err } - validatorDstAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidatorDst)) + validatorDstAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidatorDst)) if err != nil { return err } @@ -311,11 +311,11 @@ func GetCmdBeginUnbonding(storeName string, cdc *wire.Codec) *cobra.Command { Short: "begin unbonding", RunE: func(cmd *cobra.Command, args []string) error { - delegatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) + delegatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } - validatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidator)) + validatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator)) if err != nil { return err } @@ -356,11 +356,11 @@ func GetCmdCompleteUnbonding(cdc *wire.Codec) *cobra.Command { Short: "complete unbonding", RunE: func(cmd *cobra.Command, args []string) error { - delegatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressDelegator)) + delegatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressDelegator)) if err != nil { return err } - validatorAddr, err := sdk.GetAccAddressBech32(viper.GetString(FlagAddressValidator)) + validatorAddr, err := sdk.AccAddressFromBech32(viper.GetString(FlagAddressValidator)) if err != nil { return err } diff --git a/x/stake/client/rest/query.go b/x/stake/client/rest/query.go index be6a21f785..a2893ee9b7 100644 --- a/x/stake/client/rest/query.go +++ b/x/stake/client/rest/query.go @@ -48,14 +48,14 @@ func delegationHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.HandlerF bech32delegator := vars["delegator"] bech32validator := vars["validator"] - delegatorAddr, err := sdk.GetAccAddressBech32(bech32delegator) + delegatorAddr, err := sdk.AccAddressFromBech32(bech32delegator) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) return } - validatorAddr, err := sdk.GetAccAddressBech32(bech32validator) + validatorAddr, err := sdk.AccAddressFromBech32(bech32validator) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) @@ -104,14 +104,14 @@ func ubdHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.HandlerFunc { bech32delegator := vars["delegator"] bech32validator := vars["validator"] - delegatorAddr, err := sdk.GetAccAddressBech32(bech32delegator) + delegatorAddr, err := sdk.AccAddressFromBech32(bech32delegator) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) return } - validatorAddr, err := sdk.GetAccAddressBech32(bech32validator) + validatorAddr, err := sdk.AccAddressFromBech32(bech32validator) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) @@ -161,21 +161,21 @@ func redHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.HandlerFunc { bech32validatorSrc := vars["validator_src"] bech32validatorDst := vars["validator_dst"] - delegatorAddr, err := sdk.GetAccAddressBech32(bech32delegator) + delegatorAddr, err := sdk.AccAddressFromBech32(bech32delegator) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) return } - validatorSrcAddr, err := sdk.GetAccAddressBech32(bech32validatorSrc) + validatorSrcAddr, err := sdk.AccAddressFromBech32(bech32validatorSrc) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) return } - validatorDstAddr, err := sdk.GetAccAddressBech32(bech32validatorDst) + validatorDstAddr, err := sdk.AccAddressFromBech32(bech32validatorDst) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(err.Error())) diff --git a/x/stake/client/rest/tx.go b/x/stake/client/rest/tx.go index 415a8af8b3..b723c21c02 100644 --- a/x/stake/client/rest/tx.go +++ b/x/stake/client/rest/tx.go @@ -97,13 +97,13 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte i := 0 for _, msg := range m.Delegations { - delegatorAddr, err := sdk.GetAccAddressBech32(msg.DelegatorAddr) + delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))) return } - validatorAddr, err := sdk.GetAccAddressBech32(msg.ValidatorAddr) + validatorAddr, err := sdk.AccAddressFromBech32(msg.ValidatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) @@ -123,7 +123,7 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte } for _, msg := range m.BeginRedelegates { - delegatorAddr, err := sdk.GetAccAddressBech32(msg.DelegatorAddr) + delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))) @@ -134,13 +134,13 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte w.Write([]byte("Must use own delegator address")) return } - validatorSrcAddr, err := sdk.GetAccAddressBech32(msg.ValidatorSrcAddr) + validatorSrcAddr, err := sdk.AccAddressFromBech32(msg.ValidatorSrcAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) return } - validatorDstAddr, err := sdk.GetAccAddressBech32(msg.ValidatorDstAddr) + validatorDstAddr, err := sdk.AccAddressFromBech32(msg.ValidatorDstAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) @@ -162,19 +162,19 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte } for _, msg := range m.CompleteRedelegates { - delegatorAddr, err := sdk.GetAccAddressBech32(msg.DelegatorAddr) + delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))) return } - validatorSrcAddr, err := sdk.GetAccAddressBech32(msg.ValidatorSrcAddr) + validatorSrcAddr, err := sdk.AccAddressFromBech32(msg.ValidatorSrcAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) return } - validatorDstAddr, err := sdk.GetAccAddressBech32(msg.ValidatorDstAddr) + validatorDstAddr, err := sdk.AccAddressFromBech32(msg.ValidatorDstAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) @@ -194,7 +194,7 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte } for _, msg := range m.BeginUnbondings { - delegatorAddr, err := sdk.GetAccAddressBech32(msg.DelegatorAddr) + delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))) @@ -205,7 +205,7 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte w.Write([]byte("Must use own delegator address")) return } - validatorAddr, err := sdk.GetAccAddressBech32(msg.ValidatorAddr) + validatorAddr, err := sdk.AccAddressFromBech32(msg.ValidatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) @@ -226,13 +226,13 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte } for _, msg := range m.CompleteUnbondings { - delegatorAddr, err := sdk.GetAccAddressBech32(msg.DelegatorAddr) + delegatorAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))) return } - validatorAddr, err := sdk.GetAccAddressBech32(msg.ValidatorAddr) + validatorAddr, err := sdk.AccAddressFromBech32(msg.ValidatorAddr) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))) diff --git a/x/stake/keeper/test_common.go b/x/stake/keeper/test_common.go index b367e56929..983933123f 100644 --- a/x/stake/keeper/test_common.go +++ b/x/stake/keeper/test_common.go @@ -139,7 +139,7 @@ func NewPubKey(pk string) (res crypto.PubKey) { // for incode address generation func TestAddr(addr string, bech string) sdk.AccAddress { - res, err := sdk.GetAccAddressHex(addr) + res, err := sdk.AccAddressFromHex(addr) if err != nil { panic(err) } @@ -148,7 +148,7 @@ func TestAddr(addr string, bech string) sdk.AccAddress { panic("Bech encoding doesn't match reference") } - bechres, err := sdk.GetAccAddressBech32(bech) + bechres, err := sdk.AccAddressFromBech32(bech) if err != nil { panic(err) } @@ -170,7 +170,7 @@ func createTestAddrs(numAddrs int) []sdk.AccAddress { buffer.WriteString("A58856F0FD53BF058B4909A21AEC019107BA6") //base address string buffer.WriteString(numString) //adding on final two digits to make addresses unique - res, _ := sdk.GetAccAddressHex(buffer.String()) + res, _ := sdk.AccAddressFromHex(buffer.String()) bech := res.String() addresses = append(addresses, TestAddr(buffer.String(), bech)) buffer.Reset() From 38aa32c440afe433f94ae48ebb7e5594995bf054 Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Mon, 9 Jul 2018 16:06:40 -0700 Subject: [PATCH 22/38] removed x/auth/mock --- x/auth/mock/app.go | 110 ---------------------------------- x/auth/mock/auth_app_test.go | 92 ---------------------------- x/auth/mock/simulate_block.go | 110 ---------------------------------- 3 files changed, 312 deletions(-) delete mode 100644 x/auth/mock/app.go delete mode 100644 x/auth/mock/auth_app_test.go delete mode 100644 x/auth/mock/simulate_block.go diff --git a/x/auth/mock/app.go b/x/auth/mock/app.go deleted file mode 100644 index 1ef99780d3..0000000000 --- a/x/auth/mock/app.go +++ /dev/null @@ -1,110 +0,0 @@ -package mock - -import ( - "os" - - abci "github.com/tendermint/tendermint/abci/types" - "github.com/tendermint/tendermint/crypto" - dbm "github.com/tendermint/tendermint/libs/db" - "github.com/tendermint/tendermint/libs/log" - - bam "github.com/cosmos/cosmos-sdk/baseapp" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/wire" - "github.com/cosmos/cosmos-sdk/x/auth" -) - -// Extended ABCI application -type App struct { - *bam.BaseApp - Cdc *wire.Codec // public since the codec is passed into the module anyways. - KeyMain *sdk.KVStoreKey - KeyAccount *sdk.KVStoreKey - - // TODO: Abstract this out from not needing to be auth specifically - AccountMapper auth.AccountMapper - FeeCollectionKeeper auth.FeeCollectionKeeper - - GenesisAccounts []auth.Account -} - -// partially construct a new app on the memstore for module and genesis testing -func NewApp() *App { - logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "sdk/app") - db := dbm.NewMemDB() - - // create the cdc with some standard codecs - cdc := wire.NewCodec() - sdk.RegisterWire(cdc) - wire.RegisterCrypto(cdc) - auth.RegisterWire(cdc) - - // create your application object - app := &App{ - BaseApp: bam.NewBaseApp("mock", cdc, logger, db), - Cdc: cdc, - KeyMain: sdk.NewKVStoreKey("main"), - KeyAccount: sdk.NewKVStoreKey("acc"), - } - - // define the accountMapper - app.AccountMapper = auth.NewAccountMapper( - app.Cdc, - app.KeyAccount, // target store - &auth.BaseAccount{}, // prototype - ) - - // initialize the app, the chainers and blockers can be overwritten before calling complete setup - app.SetInitChainer(app.InitChainer) - - app.SetAnteHandler(auth.NewAnteHandler(app.AccountMapper, app.FeeCollectionKeeper)) - - return app -} - -// complete the application setup after the routes have been registered -func (app *App) CompleteSetup(newKeys []*sdk.KVStoreKey) error { - newKeys = append(newKeys, app.KeyMain) - newKeys = append(newKeys, app.KeyAccount) - app.MountStoresIAVL(newKeys...) - err := app.LoadLatestVersion(app.KeyMain) - return err -} - -// custom logic for initialization -func (app *App) InitChainer(ctx sdk.Context, _ abci.RequestInitChain) abci.ResponseInitChain { - - // load the accounts - for _, genacc := range app.GenesisAccounts { - acc := app.AccountMapper.NewAccountWithAddress(ctx, genacc.GetAddress()) - err := acc.SetCoins(genacc.GetCoins()) - if err != nil { - // TODO: Handle with #870 - panic(err) - } - app.AccountMapper.SetAccount(ctx, acc) - } - - return abci.ResponseInitChain{} -} - -// Generate genesis accounts loaded with coins, and returns their addresses, pubkeys, and privkeys -func CreateGenAccounts(numAccs int64, genCoins sdk.Coins) (genAccs []auth.Account, addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) { - for i := int64(0); i < numAccs; i++ { - privKey := crypto.GenPrivKeyEd25519() - pubKey := privKey.PubKey() - addr := sdk.AccAddress(pubKey.Address()) - - genAcc := &auth.BaseAccount{ - Address: addr, - Coins: genCoins, - } - - genAccs = append(genAccs, genAcc) - privKeys = append(privKeys, privKey) - pubKeys = append(pubKeys, pubKey) - addrs = append(addrs, addr) - } - - return -} diff --git a/x/auth/mock/auth_app_test.go b/x/auth/mock/auth_app_test.go deleted file mode 100644 index 5ee4ff95b5..0000000000 --- a/x/auth/mock/auth_app_test.go +++ /dev/null @@ -1,92 +0,0 @@ -package mock - -import ( - "testing" - - "github.com/stretchr/testify/require" - - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth" - - abci "github.com/tendermint/tendermint/abci/types" - "github.com/tendermint/tendermint/crypto" -) - -// A mock transaction that has a validation which can fail. -type testMsg struct { - signers []sdk.AccAddress - positiveNum int64 -} - -// TODO: Clean this up, make it public -const msgType = "testMsg" - -func (tx testMsg) Type() string { return msgType } -func (tx testMsg) GetMsg() sdk.Msg { return tx } -func (tx testMsg) GetMemo() string { return "" } -func (tx testMsg) GetSignBytes() []byte { return nil } -func (tx testMsg) GetSigners() []sdk.AccAddress { return tx.signers } -func (tx testMsg) GetSignatures() []auth.StdSignature { return nil } -func (tx testMsg) ValidateBasic() sdk.Error { - if tx.positiveNum >= 0 { - return nil - } - return sdk.ErrTxDecode("positiveNum should be a non-negative integer.") -} - -// test auth module messages - -var ( - priv1 = crypto.GenPrivKeyEd25519() - addr1 = sdk.AccAddress(priv1.PubKey().Address()) - priv2 = crypto.GenPrivKeyEd25519() - addr2 = sdk.AccAddress(priv2.PubKey().Address()) - - coins = sdk.Coins{sdk.NewCoin("foocoin", 10)} - testMsg1 = testMsg{signers: []sdk.AccAddress{addr1}, positiveNum: 1} -) - -// initialize the mock application for this module -func getMockApp(t *testing.T) *App { - mapp := NewApp() - - mapp.Router().AddRoute(msgType, func(ctx sdk.Context, msg sdk.Msg) (res sdk.Result) { return }) - require.NoError(t, mapp.CompleteSetup([]*sdk.KVStoreKey{})) - return mapp -} - -func TestMsgPrivKeys(t *testing.T) { - mapp := getMockApp(t) - mapp.Cdc.RegisterConcrete(testMsg{}, "mock/testMsg", nil) - - // Construct some genesis bytes to reflect basecoin/types/AppAccount - // Give 77 foocoin to the first key - coins := sdk.Coins{sdk.NewCoin("foocoin", 77)} - acc1 := &auth.BaseAccount{ - Address: addr1, - Coins: coins, - } - accs := []auth.Account{acc1} - - // Construct genesis state - SetGenesis(mapp, accs) - - // A checkTx context (true) - ctxCheck := mapp.BaseApp.NewContext(true, abci.Header{}) - res1 := mapp.AccountMapper.GetAccount(ctxCheck, addr1) - require.Equal(t, acc1, res1.(*auth.BaseAccount)) - - // Run a CheckDeliver - SignCheckDeliver(t, mapp.BaseApp, []sdk.Msg{testMsg1}, []int64{0}, []int64{0}, true, priv1) - - // signing a SendMsg with the wrong privKey should be an auth error - mapp.BeginBlock(abci.RequestBeginBlock{}) - tx := GenTx([]sdk.Msg{testMsg1}, []int64{0}, []int64{1}, priv2) - res := mapp.Deliver(tx) - require.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeUnauthorized), res.Code, res.Log) - - // resigning the tx with the correct priv key should still work - res = SignCheckDeliver(t, mapp.BaseApp, []sdk.Msg{testMsg1}, []int64{0}, []int64{1}, true, priv1) - - require.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeOK), res.Code, res.Log) -} diff --git a/x/auth/mock/simulate_block.go b/x/auth/mock/simulate_block.go deleted file mode 100644 index 90241ae816..0000000000 --- a/x/auth/mock/simulate_block.go +++ /dev/null @@ -1,110 +0,0 @@ -package mock - -import ( - "testing" - - "github.com/cosmos/cosmos-sdk/baseapp" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/auth" - "github.com/stretchr/testify/require" - "github.com/tendermint/tendermint/crypto" - - abci "github.com/tendermint/tendermint/abci/types" -) - -var chainID = "" // TODO - -// set the mock app genesis -func SetGenesis(app *App, accs []auth.Account) { - - // pass the accounts in via the application (lazy) instead of through RequestInitChain - app.GenesisAccounts = accs - - app.InitChain(abci.RequestInitChain{}) - app.Commit() -} - -// check an account balance -func CheckBalance(t *testing.T, app *App, addr sdk.AccAddress, exp sdk.Coins) { - ctxCheck := app.BaseApp.NewContext(true, abci.Header{}) - res := app.AccountMapper.GetAccount(ctxCheck, addr) - require.Equal(t, exp, res.GetCoins()) -} - -// generate a signed transaction -func GenTx(msgs []sdk.Msg, accnums []int64, seq []int64, priv ...crypto.PrivKeyEd25519) auth.StdTx { - - // make the transaction free - fee := auth.StdFee{ - sdk.Coins{sdk.NewCoin("foocoin", 0)}, - 100000, - } - - sigs := make([]auth.StdSignature, len(priv)) - memo := "testmemotestmemo" - for i, p := range priv { - sig, err := p.Sign(auth.StdSignBytes(chainID, accnums[i], seq[i], fee, msgs, memo)) - if err != nil { - panic(err) - } - sigs[i] = auth.StdSignature{ - PubKey: p.PubKey(), - Signature: sig, - AccountNumber: accnums[i], - Sequence: seq[i], - } - } - return auth.NewStdTx(msgs, fee, sigs, memo) -} - -// generate a set of signed transactions a msg, that differ only by having the -// sequence numbers incremented between every transaction. -func GenSequenceOfTxs(msgs []sdk.Msg, accnums []int64, initSeqNums []int64, numToGenerate int, priv ...crypto.PrivKeyEd25519) []auth.StdTx { - txs := make([]auth.StdTx, numToGenerate, numToGenerate) - for i := 0; i < numToGenerate; i++ { - txs[i] = GenTx(msgs, accnums, initSeqNums, priv...) - incrementAllSequenceNumbers(initSeqNums) - } - return txs -} - -func incrementAllSequenceNumbers(initSeqNums []int64) { - for i := 0; i < len(initSeqNums); i++ { - initSeqNums[i]++ - } -} - -// check a transaction result -func SignCheck(app *baseapp.BaseApp, msgs []sdk.Msg, accnums []int64, seq []int64, priv ...crypto.PrivKeyEd25519) sdk.Result { - tx := GenTx(msgs, accnums, seq, priv...) - res := app.Check(tx) - return res -} - -// simulate a block -func SignCheckDeliver(t *testing.T, app *baseapp.BaseApp, msgs []sdk.Msg, accnums []int64, seq []int64, expPass bool, priv ...crypto.PrivKeyEd25519) sdk.Result { - - // Sign the tx - tx := GenTx(msgs, accnums, seq, priv...) - - // Run a Check - res := app.Check(tx) - if expPass { - require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log) - } else { - require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log) - } - - // Simulate a Block - app.BeginBlock(abci.RequestBeginBlock{}) - res = app.Deliver(tx) - if expPass { - require.Equal(t, sdk.ABCICodeOK, res.Code, res.Log) - } else { - require.NotEqual(t, sdk.ABCICodeOK, res.Code, res.Log) - } - app.EndBlock(abci.RequestEndBlock{}) - - app.Commit() - return res -} From 17b5370c2216f3a08acdc818843aefafa122a69a Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 16:08:35 -0700 Subject: [PATCH 23/38] Continue fixing gocyclo errors --- types/errors.go | 1 + types/rational.go | 47 +++++++++++++++++++++---------------- x/stake/client/cli/tx.go | 2 ++ x/stake/client/rest/tx.go | 2 ++ x/stake/keeper/validator.go | 2 ++ 5 files changed, 34 insertions(+), 20 deletions(-) diff --git a/types/errors.go b/types/errors.go index 6969549d90..a106ee9bb7 100644 --- a/types/errors.go +++ b/types/errors.go @@ -66,6 +66,7 @@ const ( ) // NOTE: Don't stringer this, we'll put better messages in later. +// nolint: gocyclo func CodeToDefaultMsg(code CodeType) string { switch code { case CodeInternal: diff --git a/types/rational.go b/types/rational.go index 24072fc09e..f81ee08364 100644 --- a/types/rational.go +++ b/types/rational.go @@ -37,6 +37,30 @@ func NewRat(Numerator int64, Denominator ...int64) Rat { } } +func getNumeratorDenominator(str []string, prec int) (numerator string, denom int64, err Error) { + switch len(str) { + case 1: + if len(str[0]) == 0 { + return "", 0, ErrUnknownRequest("not a decimal string") + } + numerator = str[0] + return numerator, 1, nil + case 2: + if len(str[0]) == 0 || len(str[1]) == 0 { + return "", 0, ErrUnknownRequest("not a decimal string") + } + if len(str[1]) > prec { + return "", 0, ErrUnknownRequest("string has too many decimals") + } + numerator = str[0] + str[1] + len := int64(len(str[1])) + denom = new(big.Int).Exp(big.NewInt(10), big.NewInt(len), nil).Int64() + return numerator, denom, nil + default: + return "", 0, ErrUnknownRequest("not a decimal string") + } +} + // create a rational from decimal string or integer string // precision is the number of values after the decimal point which should be read func NewRatFromDecimal(decimalStr string, prec int) (f Rat, err Error) { @@ -53,26 +77,9 @@ func NewRatFromDecimal(decimalStr string, prec int) (f Rat, err Error) { str := strings.Split(decimalStr, ".") - var numStr string - var denom int64 = 1 - switch len(str) { - case 1: - if len(str[0]) == 0 { - return f, ErrUnknownRequest("not a decimal string") - } - numStr = str[0] - case 2: - if len(str[0]) == 0 || len(str[1]) == 0 { - return f, ErrUnknownRequest("not a decimal string") - } - if len(str[1]) > prec { - return f, ErrUnknownRequest("string has too many decimals") - } - numStr = str[0] + str[1] - len := int64(len(str[1])) - denom = new(big.Int).Exp(big.NewInt(10), big.NewInt(len), nil).Int64() - default: - return f, ErrUnknownRequest("not a decimal string") + numStr, denom, err := getNumeratorDenominator(str, prec) + if err != nil { + return f, err } num, errConv := strconv.Atoi(numStr) diff --git a/x/stake/client/cli/tx.go b/x/stake/client/cli/tx.go index 9b8acb8cc8..4701e4c201 100644 --- a/x/stake/client/cli/tx.go +++ b/x/stake/client/cli/tx.go @@ -208,6 +208,8 @@ func GetCmdBeginRedelegate(storeName string, cdc *wire.Codec) *cobra.Command { return cmd } +// nolint: gocyclo +// TODO: Make this pass gocyclo linting func getShares(storeName string, cdc *wire.Codec, sharesAmountStr, sharesPercentStr string, delegatorAddr, validatorAddr sdk.Address) (sharesAmount sdk.Rat, err error) { diff --git a/x/stake/client/rest/tx.go b/x/stake/client/rest/tx.go index 51a854528d..4475d8c480 100644 --- a/x/stake/client/rest/tx.go +++ b/x/stake/client/rest/tx.go @@ -65,6 +65,8 @@ type EditDelegationsBody struct { CompleteRedelegates []msgCompleteRedelegateInput `json:"complete_redelegates"` } +// nolint: gocyclo +// TODO: Split this up into several smaller functions, and remove the above nolint func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.CoreContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var m EditDelegationsBody diff --git a/x/stake/keeper/validator.go b/x/stake/keeper/validator.go index e8713c04d5..69ca032f4e 100644 --- a/x/stake/keeper/validator.go +++ b/x/stake/keeper/validator.go @@ -194,6 +194,8 @@ func (k Keeper) ClearTendermintUpdates(ctx sdk.Context) { // perfom all the nessisary steps for when a validator changes its power // updates all validator stores as well as tendermint update store // may kick out validators if new validator is entering the bonded validator group +// nolint: gocyclo +// TODO: Remove above nolint, function needs to be simplified func (k Keeper) UpdateValidator(ctx sdk.Context, validator types.Validator) types.Validator { store := ctx.KVStore(k.storeKey) pool := k.GetPool(ctx) From 99e91dd2764587506ea1ebbdfb4de1abac0dd845 Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 16:16:43 -0700 Subject: [PATCH 24/38] Add nolints on remaining functions --- baseapp/baseapp.go | 32 ++++++++++++++++++++------------ client/keys/add.go | 2 ++ x/gov/client/rest/rest.go | 2 ++ x/stake/keeper/validator.go | 2 ++ 4 files changed, 26 insertions(+), 12 deletions(-) diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index 0316663d35..6375c5fc88 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -505,6 +505,23 @@ func (app *BaseApp) Deliver(tx sdk.Tx) (result sdk.Result) { return app.runTx(runTxModeDeliver, nil, tx) } +func validateBasicTxMsgs(msgs []sdk.Msg) sdk.Error { + if msgs == nil || len(msgs) == 0 { + // TODO: probably shouldn't be ErrInternal. Maybe new ErrInvalidMessage, or ? + return sdk.ErrInternal("Tx.GetMsgs() must return at least one message in list") + } + + for _, msg := range msgs { + // Validate the Msg. + err := msg.ValidateBasic() + if err != nil { + err = err.WithDefaultCodespace(sdk.CodespaceRoot) + return err + } + } + return nil +} + // txBytes may be nil in some cases, eg. in tests. // Also, in the future we may support "internal" transactions. func (app *BaseApp) runTx(mode runTxMode, txBytes []byte, tx sdk.Tx) (result sdk.Result) { @@ -533,18 +550,9 @@ func (app *BaseApp) runTx(mode runTxMode, txBytes []byte, tx sdk.Tx) (result sdk // Get the Msg. var msgs = tx.GetMsgs() - if msgs == nil || len(msgs) == 0 { - // TODO: probably shouldn't be ErrInternal. Maybe new ErrInvalidMessage, or ? - return sdk.ErrInternal("Tx.GetMsgs() must return at least one message in list").Result() - } - - for _, msg := range msgs { - // Validate the Msg. - err := msg.ValidateBasic() - if err != nil { - err = err.WithDefaultCodespace(sdk.CodespaceRoot) - return err.Result() - } + err := validateBasicTxMsgs(msgs) + if err != nil { + return err.Result() } // Run the ante handler. diff --git a/client/keys/add.go b/client/keys/add.go index b763546850..22354ac053 100644 --- a/client/keys/add.go +++ b/client/keys/add.go @@ -46,6 +46,8 @@ phrase, otherwise, a new key will be generated.`, return cmd } +// nolint: gocyclo +// TODO remove the above when addressing #1446 func runAddCmd(cmd *cobra.Command, args []string) error { var kb keys.Keybase var err error diff --git a/x/gov/client/rest/rest.go b/x/gov/client/rest/rest.go index 3e185dc914..1972b3dee2 100644 --- a/x/gov/client/rest/rest.go +++ b/x/gov/client/rest/rest.go @@ -369,6 +369,8 @@ func queryVoteHandlerFn(cdc *wire.Codec) http.HandlerFunc { } } +// nolint: gocyclo +// todo: Split this functionality into helper functions to remove the above func queryProposalsWithParameterFn(cdc *wire.Codec) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { bechVoterAddr := r.URL.Query().Get(RestVoter) diff --git a/x/stake/keeper/validator.go b/x/stake/keeper/validator.go index 69ca032f4e..e19c2cd71d 100644 --- a/x/stake/keeper/validator.go +++ b/x/stake/keeper/validator.go @@ -286,6 +286,8 @@ func (k Keeper) UpdateValidator(ctx sdk.Context, validator types.Validator) type // GetValidators. // // Optionally also return the validator from a retrieve address if the validator has been bonded +// nolint: gocyclo +// TODO: Remove the above golint func (k Keeper) UpdateBondedValidators(ctx sdk.Context, affectedValidator types.Validator) (updatedVal types.Validator) { From 472e168a72869a8b220f57e782768830319e14da Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 16:24:20 -0700 Subject: [PATCH 25/38] Minor refactor to reduce complexity, add nolint --- baseapp/baseapp.go | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index 6375c5fc88..180bd20b2b 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -522,8 +522,18 @@ func validateBasicTxMsgs(msgs []sdk.Msg) sdk.Error { return nil } +// Returns deliverState if app is in runTxModeDeliver, otherwhise returns checkstate +func getState(app *BaseApp, mode runTxMode) *state { + if mode == runTxModeCheck || mode == runTxModeSimulate { + return app.checkState + } else { + return app.deliverState + } +} + // txBytes may be nil in some cases, eg. in tests. // Also, in the future we may support "internal" transactions. +// nolint: gocyclo func (app *BaseApp) runTx(mode runTxMode, txBytes []byte, tx sdk.Tx) (result sdk.Result) { //NOTE: GasWanted should be returned by the AnteHandler. // GasUsed is determined by the GasMeter. @@ -567,17 +577,9 @@ func (app *BaseApp) runTx(mode runTxMode, txBytes []byte, tx sdk.Tx) (result sdk gasWanted = anteResult.GasWanted } - // Get the correct cache - var msCache sdk.CacheMultiStore - if mode == runTxModeCheck || mode == runTxModeSimulate { - // CacheWrap app.checkState.ms in case it fails. - msCache = app.checkState.CacheMultiStore() - ctx = ctx.WithMultiStore(msCache) - } else { - // CacheWrap app.deliverState.ms in case it fails. - msCache = app.deliverState.CacheMultiStore() - ctx = ctx.WithMultiStore(msCache) - } + // Get the correct cache, CacheWrap app.checkState.ms in case it fails. + msCache := getState(app, mode).CacheMultiStore() + ctx = ctx.WithMultiStore(msCache) // accumulate results logs := make([]string, 0, len(msgs)) From 30c4abb39427850646dc202b20c46c9f12472aff Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 16:27:51 -0700 Subject: [PATCH 26/38] Fix golint error --- baseapp/baseapp.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index 180bd20b2b..8a896286ee 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -526,9 +526,8 @@ func validateBasicTxMsgs(msgs []sdk.Msg) sdk.Error { func getState(app *BaseApp, mode runTxMode) *state { if mode == runTxModeCheck || mode == runTxModeSimulate { return app.checkState - } else { - return app.deliverState } + return app.deliverState } // txBytes may be nil in some cases, eg. in tests. From f8b625b391f3d38c275a6b21c8c64e8ebc00d385 Mon Sep 17 00:00:00 2001 From: rigelrozanski <rigel.rozanski@gmail.com> Date: Mon, 9 Jul 2018 20:42:57 -0400 Subject: [PATCH 27/38] Merge pull request #1609: prevent create-validator with duplicate pubkey --- CHANGELOG.md | 1 + x/stake/handler.go | 6 ++++- x/stake/handler_test.go | 49 +++++++++++++++++++++++++++++------------ x/stake/stake.go | 17 +++++++------- x/stake/types/errors.go | 8 +++++-- 5 files changed, 56 insertions(+), 25 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 48ddab70f8..76857bdd6a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -124,6 +124,7 @@ BUG FIXES * [x/stake] fix revoke bytes ordering (was putting revoked candidates at the top of the list) * [x/stake] bond count was counting revoked validators as bonded, fixed * \#1565 - fix cliff validator persisting when validator set shrinks from max +* \#1010 - two validators can't bond with the same pubkey anymore ## 0.19.0 diff --git a/x/stake/handler.go b/x/stake/handler.go index 15d52ea9c9..265bb4e913 100644 --- a/x/stake/handler.go +++ b/x/stake/handler.go @@ -65,7 +65,11 @@ func handleMsgCreateValidator(ctx sdk.Context, msg types.MsgCreateValidator, k k // check to see if the pubkey or sender has been registered before _, found := k.GetValidator(ctx, msg.ValidatorAddr) if found { - return ErrValidatorAlreadyExists(k.Codespace()).Result() + return ErrValidatorOwnerExists(k.Codespace()).Result() + } + _, found = k.GetValidatorByPubKey(ctx, msg.PubKey) + if found { + return ErrValidatorPubKeyExists(k.Codespace()).Result() } if msg.SelfDelegation.Denom != k.GetParams(ctx).BondDenom { return ErrBadDenom(k.Codespace()).Result() diff --git a/x/stake/handler_test.go b/x/stake/handler_test.go index 21cf617209..0454db62ca 100644 --- a/x/stake/handler_test.go +++ b/x/stake/handler_test.go @@ -3,6 +3,7 @@ package stake import ( "testing" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tendermint/tendermint/crypto" @@ -118,25 +119,45 @@ func TestValidatorByPowerIndex(t *testing.T) { func TestDuplicatesMsgCreateValidator(t *testing.T) { ctx, _, keeper := keep.CreateTestInput(t, false, 1000) - validatorAddr := keep.Addrs[0] - pk := keep.PKs[0] - msgCreateValidator := newTestMsgCreateValidator(validatorAddr, pk, 10) - got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper) + addr1, addr2 := keep.Addrs[0], keep.Addrs[1] + pk1, pk2 := keep.PKs[0], keep.PKs[1] + + msgCreateValidator1 := newTestMsgCreateValidator(addr1, pk1, 10) + got := handleMsgCreateValidator(ctx, msgCreateValidator1, keeper) require.True(t, got.IsOK(), "%v", got) - validator, found := keeper.GetValidator(ctx, validatorAddr) + validator, found := keeper.GetValidator(ctx, addr1) require.True(t, found) - require.Equal(t, sdk.Bonded, validator.Status()) - require.Equal(t, validatorAddr, validator.Owner) - require.Equal(t, pk, validator.PubKey) - require.Equal(t, sdk.NewRat(10), validator.PoolShares.Bonded()) - require.Equal(t, sdk.NewRat(10), validator.DelegatorShares) - require.Equal(t, Description{}, validator.Description) + assert.Equal(t, sdk.Bonded, validator.Status()) + assert.Equal(t, addr1, validator.Owner) + assert.Equal(t, pk1, validator.PubKey) + assert.Equal(t, sdk.NewRat(10), validator.PoolShares.Bonded()) + assert.Equal(t, sdk.NewRat(10), validator.DelegatorShares) + assert.Equal(t, Description{}, validator.Description) - // one validator cannot bond twice - msgCreateValidator.PubKey = keep.PKs[1] - got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper) + // two validators can't have the same owner address + msgCreateValidator2 := newTestMsgCreateValidator(addr1, pk2, 10) + got = handleMsgCreateValidator(ctx, msgCreateValidator2, keeper) require.False(t, got.IsOK(), "%v", got) + + // two validators can't have the same pubkey + msgCreateValidator3 := newTestMsgCreateValidator(addr2, pk1, 10) + got = handleMsgCreateValidator(ctx, msgCreateValidator3, keeper) + require.False(t, got.IsOK(), "%v", got) + + // must have different pubkey and owner + msgCreateValidator4 := newTestMsgCreateValidator(addr2, pk2, 10) + got = handleMsgCreateValidator(ctx, msgCreateValidator4, keeper) + require.True(t, got.IsOK(), "%v", got) + validator, found = keeper.GetValidator(ctx, addr2) + + require.True(t, found) + assert.Equal(t, sdk.Bonded, validator.Status()) + assert.Equal(t, addr2, validator.Owner) + assert.Equal(t, pk2, validator.PubKey) + assert.Equal(t, sdk.NewRat(10), validator.PoolShares.Bonded()) + assert.Equal(t, sdk.NewRat(10), validator.DelegatorShares) + assert.Equal(t, Description{}, validator.Description) } func TestIncrementsMsgDelegate(t *testing.T) { diff --git a/x/stake/stake.go b/x/stake/stake.go index 869b838ffa..c582fb6357 100644 --- a/x/stake/stake.go +++ b/x/stake/stake.go @@ -92,14 +92,15 @@ const ( ) var ( - ErrNilValidatorAddr = types.ErrNilValidatorAddr - ErrNoValidatorFound = types.ErrNoValidatorFound - ErrValidatorAlreadyExists = types.ErrValidatorAlreadyExists - ErrValidatorRevoked = types.ErrValidatorRevoked - ErrBadRemoveValidator = types.ErrBadRemoveValidator - ErrDescriptionLength = types.ErrDescriptionLength - ErrCommissionNegative = types.ErrCommissionNegative - ErrCommissionHuge = types.ErrCommissionHuge + ErrNilValidatorAddr = types.ErrNilValidatorAddr + ErrNoValidatorFound = types.ErrNoValidatorFound + ErrValidatorOwnerExists = types.ErrValidatorOwnerExists + ErrValidatorPubKeyExists = types.ErrValidatorPubKeyExists + ErrValidatorRevoked = types.ErrValidatorRevoked + ErrBadRemoveValidator = types.ErrBadRemoveValidator + ErrDescriptionLength = types.ErrDescriptionLength + ErrCommissionNegative = types.ErrCommissionNegative + ErrCommissionHuge = types.ErrCommissionHuge ErrNilDelegatorAddr = types.ErrNilDelegatorAddr ErrBadDenom = types.ErrBadDenom diff --git a/x/stake/types/errors.go b/x/stake/types/errors.go index 09ed2d3696..237340b89d 100644 --- a/x/stake/types/errors.go +++ b/x/stake/types/errors.go @@ -30,8 +30,12 @@ func ErrNoValidatorFound(codespace sdk.CodespaceType) sdk.Error { return sdk.NewError(codespace, CodeInvalidValidator, "validator does not exist for that address") } -func ErrValidatorAlreadyExists(codespace sdk.CodespaceType) sdk.Error { - return sdk.NewError(codespace, CodeInvalidValidator, "validator already exist, cannot re-create validator") +func ErrValidatorOwnerExists(codespace sdk.CodespaceType) sdk.Error { + return sdk.NewError(codespace, CodeInvalidValidator, "validator already exist for this owner-address, must use new validator-owner address") +} + +func ErrValidatorPubKeyExists(codespace sdk.CodespaceType) sdk.Error { + return sdk.NewError(codespace, CodeInvalidValidator, "validator already exist for this pubkey, must use new validator pubkey") } func ErrValidatorRevoked(codespace sdk.CodespaceType) sdk.Error { From e27b83805af51e83a928eccaefdcdf2f56005743 Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Mon, 9 Jul 2018 18:35:10 -0700 Subject: [PATCH 28/38] fixed typo --- x/stake/client/rest/query.go | 2 +- x/stake/types/msg.go | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/x/stake/client/rest/query.go b/x/stake/client/rest/query.go index a2893ee9b7..f5a17c7850 100644 --- a/x/stake/client/rest/query.go +++ b/x/stake/client/rest/query.go @@ -231,7 +231,7 @@ type StakeValidatorOutput struct { Commission sdk.Rat `json:"commission"` // XXX the commission rate of fees charged to any delegators CommissionMax sdk.Rat `json:"commission_max"` // XXX maximum commission rate which this validator can ever charge - CommissionChangeRate sdk.Rat `json:"commisrsion_change_rate"` // XXX maximum daily increase of the validator commission + CommissionChangeRate sdk.Rat `json:"commission_change_rate"` // XXX maximum daily increase of the validator commission CommissionChangeToday sdk.Rat `json:"commission_change_today"` // XXX commission rate change today, reset each day (UTC time) // fee related diff --git a/x/stake/types/msg.go b/x/stake/types/msg.go index b179894577..12abb1e026 100644 --- a/x/stake/types/msg.go +++ b/x/stake/types/msg.go @@ -219,8 +219,8 @@ func (msg MsgBeginRedelegate) GetSignBytes() []byte { SharesAmount string `json:"shares"` }{ DelegatorAddr: msg.DelegatorAddr, - ValidatorSrcAddr: msg.ValidatorSrcAddr.Bytes(), - ValidatorDstAddr: msg.ValidatorDstAddr.Bytes(), + ValidatorSrcAddr: msg.ValidatorSrcAddr, + ValidatorDstAddr: msg.ValidatorDstAddr, SharesAmount: msg.SharesAmount.String(), }) if err != nil { From 5827bfe2693621496168ae4f3a2d91924c8cecb9 Mon Sep 17 00:00:00 2001 From: Sunny Aggarwal <sunnya97@gmail.com> Date: Mon, 9 Jul 2018 18:59:16 -0700 Subject: [PATCH 29/38] removed extra structs --- x/stake/types/msg.go | 28 +++------------------------- 1 file changed, 3 insertions(+), 25 deletions(-) diff --git a/x/stake/types/msg.go b/x/stake/types/msg.go index 12abb1e026..5c00002fcb 100644 --- a/x/stake/types/msg.go +++ b/x/stake/types/msg.go @@ -154,15 +154,7 @@ func (msg MsgDelegate) GetSigners() []sdk.AccAddress { // get the bytes for the message signer to sign on func (msg MsgDelegate) GetSignBytes() []byte { - b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr sdk.AccAddress `json:"delegator_addr"` - ValidatorAddr sdk.AccAddress `json:"validator_addr"` - Bond sdk.Coin `json:"bond"` - }{ - DelegatorAddr: msg.DelegatorAddr, - ValidatorAddr: msg.ValidatorAddr, - Bond: msg.Bond, - }) + b, err := MsgCdc.MarshalJSON(msg) if err != nil { panic(err) } @@ -274,15 +266,7 @@ func (msg MsgCompleteRedelegate) GetSigners() []sdk.AccAddress { // get the bytes for the message signer to sign on func (msg MsgCompleteRedelegate) GetSignBytes() []byte { - b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr sdk.AccAddress `json:"delegator_addr"` - ValidatorSrcAddr sdk.AccAddress `json:"validator_src_addr"` - ValidatorDstAddr sdk.AccAddress `json:"validator_dst_addr"` - }{ - DelegatorAddr: msg.DelegatorAddr, - ValidatorSrcAddr: msg.ValidatorSrcAddr, - ValidatorDstAddr: msg.ValidatorDstAddr, - }) + b, err := MsgCdc.MarshalJSON(msg) if err != nil { panic(err) } @@ -379,13 +363,7 @@ func (msg MsgCompleteUnbonding) GetSigners() []sdk.AccAddress { // get the bytes for the message signer to sign on func (msg MsgCompleteUnbonding) GetSignBytes() []byte { - b, err := MsgCdc.MarshalJSON(struct { - DelegatorAddr sdk.AccAddress `json:"delegator_addr"` - ValidatorAddr sdk.AccAddress `json:"validator_src_addr"` - }{ - DelegatorAddr: msg.DelegatorAddr, - ValidatorAddr: msg.ValidatorAddr.Bytes(), - }) + b, err := MsgCdc.MarshalJSON(msg) if err != nil { panic(err) } From 39fa70b84a5bb6b57a15660abd7691871d23a86d Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 19:04:24 -0700 Subject: [PATCH 30/38] changelog: Reorder items in the changelog Additionally I've added the following entries: * Added MinInt and MinUint functions * The keys sub-module is now in the sdk * [keys] New keys now have 24 word recovery keys, for heightened security * \#872 - recovery phrases no longer all end in `abandon` --- CHANGELOG.md | 80 +++++++++++++++++++++++++++------------------------- 1 file changed, 41 insertions(+), 39 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 48ddab70f8..4c54899bec 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,8 +13,9 @@ BREAKING CHANGES * Default ports changed from 466xx to 266xx * Amino JSON uses type names instead of prefix bytes * ED25519 addresses are the first 20-bytes of the SHA256 of the raw 32-byte - pubkey + pubkey (Instead of RIPEMD160) * go-crypto, abci, tmlibs have been merged into Tendermint + * The keys sub-module is now in the SDK * Various other fixes * [auth] Signers of a transaction now only sign over their own account and sequence number * [auth] Removed MsgChangePubKey @@ -25,14 +26,6 @@ BREAKING CHANGES * [types] renamed rational.Evaluate to rational.Round{Int64, Int} * [keys] Keybase and Ledger support from go-crypto merged into the SDK in the `crypto` folder * [cli] Rearranged commands under subcommands -* [x/gov] Gov module REST endpoints changed to be more RESTful -* [x/stake] Remove Tick and add EndBlocker -* [x/stake] Introduce concept of unbonding for delegations and validators - * `gaiacli stake unbond` replaced with `gaiacli stake begin-unbonding` - * Introduced: - * `gaiacli stake complete-unbonding` - * `gaiacli stake begin-redelegation` - * `gaiacli stake complete-redelegation` * [x/slashing] Update slashing for unbonding period * Slash according to power at time of infraction instead of power at time of discovery @@ -40,25 +33,38 @@ BREAKING CHANGES to an infraction, slash them proportional to their stake at the time * Add REST endpoint to unrevoke a validator previously revoked for downtime * Add REST endpoint to retrieve liveness signing information for a validator -* [types] renamed rational.Evaluate to rational.Round{Int64, Int} +* [x/stake] Remove Tick and add EndBlocker * [x/stake] most index keys nolonger hold a value - inputs are rearranged to form the desired key -* [lcd] Switch key creation output to return bech32 * [x/stake] store-value for delegation, validator, ubd, and red do not hold duplicate information contained store-key -* [gaiad] genesis transactions now use bech32 addresses / pubkeys +* [x/stake] Introduce concept of unbonding for delegations and validators + * `gaiacli stake unbond` replaced with `gaiacli stake begin-unbonding` + * Introduced: + * `gaiacli stake complete-unbonding` + * `gaiacli stake begin-redelegation` + * `gaiacli stake complete-redelegation` +* [lcd] Switch key creation output to return bech32 * [lcd] Removed shorthand CLI flags (`a`, `c`, `n`, `o`) +* [gaiad] genesis transactions now use bech32 addresses / pubkeys DEPRECATED -* [cli] Deprecate `--name` flag in commands that send txs, in favor of `--from` +* [cli] Deprecated `--name` flag in commands that send txs, in favor of `--from` FEATURES -* [gaiacli] You can now attach a simple text-only memo to any transaction, with the `--memo` flag -* [lcd] Queried TXs now include the tx hash to identify each tx -* [mockapp] CompleteSetup() no longer takes a testing parameter * [x/gov] Implemented MVP * Supported proposal types: just binary (pass/fail) TextProposals for now * Proposals need deposits to be votable; deposits are burned if proposal fails * Delegators delegate votes to validator by default but can override (for their stake) -* Add benchmarks for signing and delivering a block with a single bank transaction +* [gaiacli] Ledger support added + - You can now use a Ledger with `gaiacli --ledger` for all key-related commands + - Ledger keys can be named and tracked locally in the key DB +* [gaiacli] You can now attach a simple text-only memo to any transaction, with the `--memo` flag +* [gaiacli] added the following flags for commands that post transactions to the chain: + * async -- send the tx without waiting for a tendermint response + * json -- return the output in json format for increased readability + * print-response -- return the tx response. (includes fields like gas cost) +* [lcd] Queried TXs now include the tx hash to identify each tx +* [mockapp] CompleteSetup() no longer takes a testing parameter +* [x/bank] Add benchmarks for signing and delivering a block with a single bank transaction * Run with `cd x/bank && go test --bench=.` * [tools] make get_tools installs tendermint's linter, and gometalinter * [tools] Switch gometalinter to the stable version @@ -71,26 +77,21 @@ FEATURES * errcheck * unparam * gocyclo -* [tools] Add `make format` command to automate fixing misspell and gofmt errors. +* [tools] Added `make format` command to automate fixing misspell and gofmt errors. * [server] Default config now creates a profiler at port 6060, and increase p2p send/recv rates -* [tests] Add WaitForNextNBlocksTM helper method * [types] Switches internal representation of Int/Uint/Rat to use pointers +* [types] Added MinInt and MinUint functions * [gaiad] `unsafe_reset_all` now resets addrbook.json * [democoin] add x/oracle, x/assoc -* [gaiacli] Ledger support added - - You can now use a Ledger with `gaiacli --ledger` for all key-related commands - - Ledger keys can be named and tracked locally in the key DB -* [testing] created a randomized testing framework. +* [tests] created a randomized testing framework. - Currently bank has limited functionality in the framework - Auth has its invariants checked within the framework -* [gaiacli] added the following flags for commands that post transactions to the chain: - * async -- send the tx without waiting for a tendermint response - * json -- return the output in json format for increased readability - * print-response -- return the tx response. (includes fields like gas cost) +* [tests] Add WaitForNextNBlocksTM helper method +* [keys] New keys now have 24 word recovery keys, for heightened security IMPROVEMENTS -* bank module uses go-wire codec instead of 'encoding/json' -* auth module uses go-wire codec instead of 'encoding/json' +* [x/bank] Now uses go-wire codec instead of 'encoding/json' +* [x/auth] Now uses go-wire codec instead of 'encoding/json' * revised use of endblock and beginblock * [stake] module reorganized to include `types` and `keeper` package * [stake] keeper always loads the store (instead passing around which doesn't really boost efficiency) @@ -105,24 +106,25 @@ BUG FIXES * [x/slashing] \#1510 Unrevoked validators cannot un-revoke themselves * [x/stake] \#1513 Validators slashed to zero power are unbonded and removed from the store * [x/stake] \#1567 Validators decreased in power but not unbonded are now updated in Tendermint +* [x/stake] error strings lower case +* [x/stake] pool loose tokens now accounts for unbonding and unbonding tokens not associated with any validator +* [x/stake] fix revoke bytes ordering (was putting revoked candidates at the top of the list) +* [x/stake] bond count was counting revoked validators as bonded, fixed * [gaia] Added self delegation for validators in the genesis creation * [lcd] tests now don't depend on raw json text -* [stake] error strings lower case -* [stake] pool loose tokens now accounts for unbonding and unbonding tokens not associated with any validator -* \#1259 - fix bug where certain tests that could have a nil pointer in defer -* \#1052 - Make all now works * Retry on HTTP request failure in CLI tests, add option to retry tests in Makefile * Fixed bug where chain ID wasn't passed properly in x/bank REST handler, removed Viper hack from ante handler * Fixed bug where `democli account` didn't decode the account data correctly -* \#1343 - fixed unnecessary parallelism in CI -* \#1367 - set ChainID in InitChain -* \#1353 - CLI: Show pool shares fractions in human-readable format -* \#1258 - printing big.rat's can no longer overflow int64 +* \#872 - recovery phrases no longer all end in `abandon` * \#887 - limit the size of rationals that can be passed in from user input +* \#1052 - Make all now works +* \#1258 - printing big.rat's can no longer overflow int64 +* \#1259 - fix bug where certain tests that could have a nil pointer in defer +* \#1343 - fixed unnecessary parallelism in CI +* \#1353 - CLI: Show pool shares fractions in human-readable format +* \#1367 - set ChainID in InitChain * \#1461 - CLI tests now no longer reset your local environment data * \#1505 - `gaiacli stake validator` no longer panics if validator doesn't exist -* [x/stake] fix revoke bytes ordering (was putting revoked candidates at the top of the list) -* [x/stake] bond count was counting revoked validators as bonded, fixed * \#1565 - fix cliff validator persisting when validator set shrinks from max ## 0.19.0 From 86f68a3e9549a2b93db89ec0d22f1cd8eb2b7b03 Mon Sep 17 00:00:00 2001 From: rigelrozanski <rigel.rozanski@gmail.com> Date: Mon, 9 Jul 2018 22:51:13 -0400 Subject: [PATCH 31/38] prevent zero genesis validators --- cmd/gaia/app/app.go | 6 +++++- cmd/gaia/cmd/gaiadebug/hack.go | 10 +++++---- x/gov/test_common.go | 5 ++++- x/slashing/app_test.go | 5 ++++- x/slashing/test_common.go | 4 +++- x/stake/app_test.go | 5 ++++- x/stake/genesis.go | 11 +++++++++- x/stake/genesis_test.go | 37 ++++++++++++++++++++++++++++++++++ 8 files changed, 73 insertions(+), 10 deletions(-) create mode 100644 x/stake/genesis_test.go diff --git a/cmd/gaia/app/app.go b/cmd/gaia/app/app.go index b355c4ed51..72defe3012 100644 --- a/cmd/gaia/app/app.go +++ b/cmd/gaia/app/app.go @@ -164,7 +164,11 @@ func (app *GaiaApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci } // load the initial stake information - stake.InitGenesis(ctx, app.stakeKeeper, genesisState.StakeData) + err = stake.InitGenesis(ctx, app.stakeKeeper, genesisState.StakeData) + if err != nil { + panic(err) // TODO https://github.com/cosmos/cosmos-sdk/issues/468 + // return sdk.ErrGenesisParse("").TraceCause(err, "") + } gov.InitGenesis(ctx, app.govKeeper, gov.DefaultGenesisState()) diff --git a/cmd/gaia/cmd/gaiadebug/hack.go b/cmd/gaia/cmd/gaiadebug/hack.go index ddc8466c76..b06328d134 100644 --- a/cmd/gaia/cmd/gaiadebug/hack.go +++ b/cmd/gaia/cmd/gaiadebug/hack.go @@ -228,8 +228,7 @@ func (app *GaiaApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci var genesisState gaia.GenesisState err := app.cdc.UnmarshalJSON(stateJSON, &genesisState) if err != nil { - panic(err) // TODO https://github.com/cosmos/cosmos-sdk/issues/468 - // return sdk.ErrGenesisParse("").TraceCause(err, "") + panic(err) // TODO https://github.com/cosmos/cosmos-sdk/issues/468 // return sdk.ErrGenesisParse("").TraceCause(err, "") } // load the accounts @@ -239,7 +238,10 @@ func (app *GaiaApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci } // load the initial stake information - stake.InitGenesis(ctx, app.stakeKeeper, genesisState.StakeData) - return abci.ResponseInitChain{} + err = stake.InitGenesis(ctx, app.stakeKeeper, genesisState.StakeData) + if err != nil { + panic(err) // TODO https://github.com/cosmos/cosmos-sdk/issues/468 // return sdk.ErrGenesisParse("").TraceCause(err, "") + } + return abci.ResponseInitChain{} } diff --git a/x/gov/test_common.go b/x/gov/test_common.go index 70e47e86d7..34dcb4b143 100644 --- a/x/gov/test_common.go +++ b/x/gov/test_common.go @@ -61,7 +61,10 @@ func getInitChainer(mapp *mock.App, keeper Keeper, stakeKeeper stake.Keeper) sdk stakeGenesis := stake.DefaultGenesisState() stakeGenesis.Pool.LooseTokens = 100000 - stake.InitGenesis(ctx, stakeKeeper, stakeGenesis) + err := stake.InitGenesis(ctx, stakeKeeper, stakeGenesis) + if err != nil { + panic(err) + } InitGenesis(ctx, keeper, DefaultGenesisState()) return abci.ResponseInitChain{} } diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go index d6fb0d9fe8..158eb21812 100644 --- a/x/slashing/app_test.go +++ b/x/slashing/app_test.go @@ -55,7 +55,10 @@ func getInitChainer(mapp *mock.App, keeper stake.Keeper) sdk.InitChainer { mapp.InitChainer(ctx, req) stakeGenesis := stake.DefaultGenesisState() stakeGenesis.Pool.LooseTokens = 100000 - stake.InitGenesis(ctx, keeper, stakeGenesis) + err := stake.InitGenesis(ctx, keeper, stakeGenesis) + if err != nil { + panic(err) + } return abci.ResponseInitChain{} } } diff --git a/x/slashing/test_common.go b/x/slashing/test_common.go index 77b553317a..f92778a1f0 100644 --- a/x/slashing/test_common.go +++ b/x/slashing/test_common.go @@ -64,7 +64,9 @@ func createTestInput(t *testing.T) (sdk.Context, bank.Keeper, stake.Keeper, Keep sk := stake.NewKeeper(cdc, keyStake, ck, stake.DefaultCodespace) genesis := stake.DefaultGenesisState() genesis.Pool.LooseTokens = initCoins.MulRaw(int64(len(addrs))).Int64() - stake.InitGenesis(ctx, sk, genesis) + err = stake.InitGenesis(ctx, sk, genesis) + require.Nil(t, err) + for _, addr := range addrs { _, _, err = ck.AddCoins(ctx, addr, sdk.Coins{ {sk.GetParams(ctx).BondDenom, initCoins}, diff --git a/x/stake/app_test.go b/x/stake/app_test.go index 02dd091341..4e39bb18b9 100644 --- a/x/stake/app_test.go +++ b/x/stake/app_test.go @@ -62,7 +62,10 @@ func getInitChainer(mapp *mock.App, keeper Keeper) sdk.InitChainer { stakeGenesis := DefaultGenesisState() stakeGenesis.Pool.LooseTokens = 100000 - InitGenesis(ctx, keeper, stakeGenesis) + err := InitGenesis(ctx, keeper, stakeGenesis) + if err != nil { + panic(err) + } return abci.ResponseInitChain{} } diff --git a/x/stake/genesis.go b/x/stake/genesis.go index 1116a4748d..7632b9aee1 100644 --- a/x/stake/genesis.go +++ b/x/stake/genesis.go @@ -3,6 +3,7 @@ package stake import ( sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/stake/types" + "github.com/pkg/errors" tmtypes "github.com/tendermint/tendermint/types" ) @@ -11,7 +12,7 @@ import ( // validator in the keeper along with manually setting the indexes. In // addition, it also sets any delegations found in data. Finally, it updates // the bonded validators. -func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) { +func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) error { keeper.SetPool(ctx, data.Pool) keeper.SetNewParams(ctx, data.Params) keeper.InitIntraTxCounter(ctx) @@ -19,6 +20,13 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) { for _, validator := range data.Validators { keeper.SetValidator(ctx, validator) + if validator.PoolShares.Amount.IsZero() { + return errors.Errorf("genesis validator cannot have zero power, validator: %v", validator) + } + if validator.DelegatorShares.IsZero() { + return errors.Errorf("genesis validator cannot have zero power, validator: %v", validator) + } + // Manually set indexes for the first time keeper.SetValidatorByPubKeyIndex(ctx, validator) keeper.SetValidatorByPowerIndex(ctx, validator, data.Pool) @@ -33,6 +41,7 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) { } keeper.UpdateBondedValidatorsFull(ctx) + return nil } // WriteGenesis returns a GenesisState for a given context and keeper. The diff --git a/x/stake/genesis_test.go b/x/stake/genesis_test.go new file mode 100644 index 0000000000..4ad5b3978d --- /dev/null +++ b/x/stake/genesis_test.go @@ -0,0 +1,37 @@ +package stake + +import ( + "testing" + + "github.com/stretchr/testify/require" + + sdk "github.com/cosmos/cosmos-sdk/types" + keep "github.com/cosmos/cosmos-sdk/x/stake/keeper" + "github.com/cosmos/cosmos-sdk/x/stake/types" +) + +func TestInitGenesis(t *testing.T) { + ctx, _, keeper := keep.CreateTestInput(t, false, 1000) + + pool := keeper.GetPool(ctx) + pool.UnbondedTokens = 1 + pool.UnbondedShares = sdk.OneRat() + + params := keeper.GetParams(ctx) + var delegations []Delegation + + validators := []Validator{ + NewValidator(keep.Addrs[0], keep.PKs[0], Description{Moniker: "hoop"}), + } + + genesisState := types.NewGenesisState(pool, params, validators, delegations) + err := InitGenesis(ctx, keeper, genesisState) + require.Error(t, err) + + validators[0].PoolShares.Amount = sdk.OneRat() + validators[0].DelegatorShares = sdk.OneRat() + + genesisState = types.NewGenesisState(pool, params, validators, delegations) + err = InitGenesis(ctx, keeper, genesisState) + require.NoError(t, err) +} From 74a9e33533140784a1d92ede4ca59477d90d0d5e Mon Sep 17 00:00:00 2001 From: rigelrozanski <rigel.rozanski@gmail.com> Date: Mon, 9 Jul 2018 22:52:34 -0400 Subject: [PATCH 32/38] changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 48ddab70f8..3e4fe0197a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -124,6 +124,7 @@ BUG FIXES * [x/stake] fix revoke bytes ordering (was putting revoked candidates at the top of the list) * [x/stake] bond count was counting revoked validators as bonded, fixed * \#1565 - fix cliff validator persisting when validator set shrinks from max +* \#1287 - prevent zero power validators at genesis ## 0.19.0 From 47616122889d828d9854649457925b2a69333362 Mon Sep 17 00:00:00 2001 From: mossid <torecursedivine@gmail.com> Date: Tue, 26 Jun 2018 18:53:41 -0700 Subject: [PATCH 33/38] Merge pull request #1400: Cleanup Baseapp fix lint apply requests revert removing newCtx refactor fix errors --- baseapp/baseapp.go | 182 ++++++++++++++++++--------------------------- baseapp/helpers.go | 16 ++++ 2 files changed, 89 insertions(+), 109 deletions(-) diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index 8a896286ee..c8c178229b 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -204,36 +204,6 @@ func (app *BaseApp) initFromStore(mainKey sdk.StoreKey) error { return errors.New("baseapp expects MultiStore with 'main' KVStore") } - // XXX: Do we really need the header? What does it have that we want - // here that's not already in the CommitID ? If an app wants to have it, - // they can do so in their BeginBlocker. If we force it in baseapp, - // then either we force the AppHash to change with every block (since the header - // will be in the merkle store) or we can't write the state and the header to the - // db atomically without doing some surgery on the store interfaces ... - - // if we've committed before, we expect <dbHeaderKey> to exist in the db - /* - var lastCommitID = app.cms.LastCommitID() - var header abci.Header - - if !lastCommitID.IsZero() { - headerBytes := app.db.Get(dbHeaderKey) - if len(headerBytes) == 0 { - errStr := fmt.Sprintf("Version > 0 but missing key %s", dbHeaderKey) - return errors.New(errStr) - } - err := proto.Unmarshal(headerBytes, &header) - if err != nil { - return errors.Wrap(err, "failed to parse Header") - } - lastVersion := lastCommitID.Version - if header.Height != lastVersion { - errStr := fmt.Sprintf("expected db://%s.Height %v but got %v", dbHeaderKey, lastVersion, header.Height) - return errors.New(errStr) - } - } - */ - return nil } @@ -490,21 +460,7 @@ func (app *BaseApp) DeliverTx(txBytes []byte) (res abci.ResponseDeliverTx) { } } -// nolint - Mostly for testing -func (app *BaseApp) Check(tx sdk.Tx) (result sdk.Result) { - return app.runTx(runTxModeCheck, nil, tx) -} - -// nolint - full tx execution -func (app *BaseApp) Simulate(tx sdk.Tx) (result sdk.Result) { - return app.runTx(runTxModeSimulate, nil, tx) -} - -// nolint -func (app *BaseApp) Deliver(tx sdk.Tx) (result sdk.Result) { - return app.runTx(runTxModeDeliver, nil, tx) -} - +// Basic validator for msgs func validateBasicTxMsgs(msgs []sdk.Msg) sdk.Error { if msgs == nil || len(msgs) == 0 { // TODO: probably shouldn't be ErrInternal. Maybe new ErrInvalidMessage, or ? @@ -519,9 +475,75 @@ func validateBasicTxMsgs(msgs []sdk.Msg) sdk.Error { return err } } + return nil } +func (app *BaseApp) getContextForAnte(mode runTxMode, txBytes []byte) (ctx sdk.Context) { + // Get the context + if mode == runTxModeCheck || mode == runTxModeSimulate { + ctx = app.checkState.ctx.WithTxBytes(txBytes) + } else { + ctx = app.deliverState.ctx.WithTxBytes(txBytes) + ctx = ctx.WithSigningValidators(app.signedValidators) + } + + // Simulate a DeliverTx for gas calculation + if mode == runTxModeSimulate { + ctx = ctx.WithIsCheckTx(false) + } + + return +} + +// Iterates through msgs and executes them +func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg) (result sdk.Result) { + // accumulate results + logs := make([]string, 0, len(msgs)) + var data []byte // NOTE: we just append them all (?!) + var tags sdk.Tags // also just append them all + var code sdk.ABCICodeType + for msgIdx, msg := range msgs { + // Match route. + msgType := msg.Type() + handler := app.router.Route(msgType) + if handler == nil { + return sdk.ErrUnknownRequest("Unrecognized Msg type: " + msgType).Result() + } + + msgResult := handler(ctx, msg) + + // NOTE: GasWanted is determined by ante handler and + // GasUsed by the GasMeter + + // Append Data and Tags + data = append(data, msgResult.Data...) + tags = append(tags, msgResult.Tags...) + + // Stop execution and return on first failed message. + if !msgResult.IsOK() { + logs = append(logs, fmt.Sprintf("Msg %d failed: %s", msgIdx, msgResult.Log)) + code = msgResult.Code + break + } + + // Construct usable logs in multi-message transactions. + logs = append(logs, fmt.Sprintf("Msg %d: %s", msgIdx, msgResult.Log)) + } + + // Set the final gas values. + result = sdk.Result{ + Code: code, + Data: data, + Log: strings.Join(logs, "\n"), + GasUsed: ctx.GasMeter().GasConsumed(), + // TODO: FeeAmount/FeeDenom + Tags: tags, + } + + return result +} + // Returns deliverState if app is in runTxModeDeliver, otherwhise returns checkstate func getState(app *BaseApp, mode runTxMode) *state { if mode == runTxModeCheck || mode == runTxModeSimulate { @@ -559,6 +581,7 @@ func (app *BaseApp) runTx(mode runTxMode, txBytes []byte, tx sdk.Tx) (result sdk // Get the Msg. var msgs = tx.GetMsgs() + err := validateBasicTxMsgs(msgs) if err != nil { return err.Result() @@ -573,81 +596,22 @@ func (app *BaseApp) runTx(mode runTxMode, txBytes []byte, tx sdk.Tx) (result sdk if !newCtx.IsZero() { ctx = newCtx } - gasWanted = anteResult.GasWanted + gasWanted = result.GasWanted } - // Get the correct cache, CacheWrap app.checkState.ms in case it fails. + // CacheWrap the state in case it fails. msCache := getState(app, mode).CacheMultiStore() ctx = ctx.WithMultiStore(msCache) - // accumulate results - logs := make([]string, 0, len(msgs)) - var data []byte // NOTE: we just append them all (?!) - var tags sdk.Tags // also just append them all - var code sdk.ABCICodeType - for msgIdx, msg := range msgs { - // Match route. - msgType := msg.Type() - handler := app.router.Route(msgType) - if handler == nil { - return sdk.ErrUnknownRequest("Unrecognized Msg type: " + msgType).Result() - } - - msgResult := handler(ctx, msg) - - // NOTE: GasWanted is determined by ante handler and - // GasUsed by the GasMeter - - // Append Data and Tags - data = append(data, msgResult.Data...) - tags = append(tags, msgResult.Tags...) - - // Stop execution and return on first failed message. - if !msgResult.IsOK() { - logs = append(logs, fmt.Sprintf("Msg %d failed: %s", msgIdx, msgResult.Log)) - code = msgResult.Code - break - } - - // Construct usable logs in multi-message transactions. - logs = append(logs, fmt.Sprintf("Msg %d: %s", msgIdx, msgResult.Log)) - } - - // Set the final gas values. - result = sdk.Result{ - Code: code, - Data: data, - Log: strings.Join(logs, "\n"), - GasWanted: gasWanted, - GasUsed: ctx.GasMeter().GasConsumed(), - // TODO: FeeAmount/FeeDenom - Tags: tags, - } + result = app.runMsgs(ctx, msgs) + result.GasWanted = gasWanted // Only update state if all messages pass and we're not in a simulation. if result.IsOK() && mode != runTxModeSimulate { msCache.Write() } - return result -} - -func (app *BaseApp) getContextForAnte(mode runTxMode, txBytes []byte) sdk.Context { - var ctx sdk.Context - - // Get the context. - if mode == runTxModeCheck || mode == runTxModeSimulate { - ctx = app.checkState.ctx.WithTxBytes(txBytes) - } else { - ctx = app.deliverState.ctx.WithTxBytes(txBytes) - ctx = ctx.WithSigningValidators(app.signedValidators) - } - - // Simulate a DeliverTx for gas calculation. - if mode == runTxModeSimulate { - ctx = ctx.WithIsCheckTx(false) - } - return ctx + return } // Implements ABCI diff --git a/baseapp/helpers.go b/baseapp/helpers.go index 2d7419a98c..f3f1448bcf 100644 --- a/baseapp/helpers.go +++ b/baseapp/helpers.go @@ -1,11 +1,27 @@ package baseapp import ( + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/tendermint/tendermint/abci/server" abci "github.com/tendermint/tendermint/abci/types" cmn "github.com/tendermint/tendermint/libs/common" ) +// nolint - Mostly for testing +func (app *BaseApp) Check(tx sdk.Tx) (result sdk.Result) { + return app.runTx(runTxModeCheck, nil, tx) +} + +// nolint - full tx execution +func (app *BaseApp) Simulate(tx sdk.Tx) (result sdk.Result) { + return app.runTx(runTxModeSimulate, nil, tx) +} + +// nolint +func (app *BaseApp) Deliver(tx sdk.Tx) (result sdk.Result) { + return app.runTx(runTxModeDeliver, nil, tx) +} + // RunForever - BasecoinApp execution and cleanup func RunForever(app abci.Application) { From 96d660593a832b65f3b8e5a1d04848077cfb0859 Mon Sep 17 00:00:00 2001 From: rigelrozanski <rigel.rozanski@gmail.com> Date: Tue, 10 Jul 2018 00:07:01 -0400 Subject: [PATCH 34/38] fix cli delegations unmarshalling --- x/stake/client/cli/tx.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/x/stake/client/cli/tx.go b/x/stake/client/cli/tx.go index 4701e4c201..d5c974cad5 100644 --- a/x/stake/client/cli/tx.go +++ b/x/stake/client/cli/tx.go @@ -240,15 +240,10 @@ func getShares(storeName string, cdc *wire.Codec, sharesAmountStr, sharesPercent key := stake.GetDelegationKey(delegatorAddr, validatorAddr) ctx := context.NewCoreContextFromViper() resQuery, err := ctx.QueryStore(key, storeName) - if err != nil { - return sharesAmount, err - } - var delegation stake.Delegation - err = cdc.UnmarshalBinary(resQuery, &delegation) if err != nil { return sharesAmount, errors.Errorf("cannot find delegation to determine percent Error: %v", err) } - + delegation := types.MustUnmarshalDelegation(cdc, key, resQuery) sharesAmount = sharesPercent.Mul(delegation.Shares) } return From ce3fd47f9d4971acd8046f25f9677e501cbf0c74 Mon Sep 17 00:00:00 2001 From: rigelrozanski <rigel.rozanski@gmail.com> Date: Tue, 10 Jul 2018 00:12:50 -0400 Subject: [PATCH 35/38] changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 48ddab70f8..088a4dbd11 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -124,6 +124,7 @@ BUG FIXES * [x/stake] fix revoke bytes ordering (was putting revoked candidates at the top of the list) * [x/stake] bond count was counting revoked validators as bonded, fixed * \#1565 - fix cliff validator persisting when validator set shrinks from max +* [x/stake] fix bug when unbonding/redelegating using `--shares-percent` ## 0.19.0 From a31404c62821d8f5baed593c8c6302179415a3e3 Mon Sep 17 00:00:00 2001 From: rigelrozanski <rigel.rozanski@gmail.com> Date: Tue, 10 Jul 2018 00:18:25 -0400 Subject: [PATCH 36/38] more detailed comments --- x/stake/genesis.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/x/stake/genesis.go b/x/stake/genesis.go index 7632b9aee1..177f89b767 100644 --- a/x/stake/genesis.go +++ b/x/stake/genesis.go @@ -21,10 +21,10 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) error keeper.SetValidator(ctx, validator) if validator.PoolShares.Amount.IsZero() { - return errors.Errorf("genesis validator cannot have zero power, validator: %v", validator) + return errors.Errorf("genesis validator cannot have zero pool shares, validator: %v", validator) } if validator.DelegatorShares.IsZero() { - return errors.Errorf("genesis validator cannot have zero power, validator: %v", validator) + return errors.Errorf("genesis validator cannot have zero delegator shares, validator: %v", validator) } // Manually set indexes for the first time From 985037d2bd51ab3f657f3043b05105a19214e3d4 Mon Sep 17 00:00:00 2001 From: ValarDragon <dojha12@gmail.com> Date: Mon, 9 Jul 2018 22:08:01 -0700 Subject: [PATCH 37/38] Fix unformatted files --- baseapp/baseapp.go | 1 - x/mock/app_test.go | 2 +- x/stake/app_test.go | 1 - x/stake/keeper/key.go | 2 +- 4 files changed, 2 insertions(+), 4 deletions(-) diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index c8c178229b..0d9356960b 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -554,7 +554,6 @@ func getState(app *BaseApp, mode runTxMode) *state { // txBytes may be nil in some cases, eg. in tests. // Also, in the future we may support "internal" transactions. -// nolint: gocyclo func (app *BaseApp) runTx(mode runTxMode, txBytes []byte, tx sdk.Tx) (result sdk.Result) { //NOTE: GasWanted should be returned by the AnteHandler. // GasUsed is determined by the GasMeter. diff --git a/x/mock/app_test.go b/x/mock/app_test.go index 0890b53ecc..0c548280ae 100644 --- a/x/mock/app_test.go +++ b/x/mock/app_test.go @@ -27,7 +27,7 @@ func (tx testMsg) Type() string { return msgType } func (tx testMsg) GetMsg() sdk.Msg { return tx } func (tx testMsg) GetMemo() string { return "" } func (tx testMsg) GetSignBytes() []byte { return nil } -func (tx testMsg) GetSigners() []sdk.AccAddress { return tx.signers } +func (tx testMsg) GetSigners() []sdk.AccAddress { return tx.signers } func (tx testMsg) GetSignatures() []auth.StdSignature { return nil } func (tx testMsg) ValidateBasic() sdk.Error { if tx.positiveNum >= 0 { diff --git a/x/stake/app_test.go b/x/stake/app_test.go index aa25138c95..6d6da617e2 100644 --- a/x/stake/app_test.go +++ b/x/stake/app_test.go @@ -83,7 +83,6 @@ func checkValidator(t *testing.T, mapp *mock.App, keeper Keeper, return validator } - func checkDelegation( t *testing.T, mapp *mock.App, keeper Keeper, delegatorAddr, validatorAddr sdk.AccAddress, expFound bool, expShares sdk.Rat, diff --git a/x/stake/keeper/key.go b/x/stake/keeper/key.go index 132add34a6..ac7fe6e5f2 100644 --- a/x/stake/keeper/key.go +++ b/x/stake/keeper/key.go @@ -156,7 +156,7 @@ func GetUBDsByValIndexKey(validatorAddr sdk.AccAddress) []byte { // get the key for a redelegation // VALUE: stake/types.RedelegationKey -func GetREDKey(delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) []byte { +func GetREDKey(delegatorAddr, validatorSrcAddr, validatorDstAddr sdk.AccAddress) []byte { return append(append( GetREDsKey(delegatorAddr.Bytes()), validatorSrcAddr.Bytes()...), From 338c7b5e4c95dc6decf6da181f117b1494cdedc3 Mon Sep 17 00:00:00 2001 From: Jeremiah Andrews <jlandrews@users.noreply.github.com> Date: Tue, 10 Jul 2018 12:10:59 -0700 Subject: [PATCH 38/38] Merge pull request #1603: Adding option functions to NewBaseApp * adding option functions to baseapp constructor * Added simple test and changed godoc * remove unrelated changelog updates --- CHANGELOG.md | 1 + baseapp/baseapp.go | 6 +++++- baseapp/baseapp_test.go | 15 +++++++++++++++ 3 files changed, 21 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 879eaacb0b..1a4c6acf7b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,7 @@ BREAKING CHANGES * [auth] Removed MsgChangePubKey * [auth] Removed SetPubKey from account mapper * [auth] AltBytes renamed to Memo, now a string, max 100 characters, costs a bit of gas +* [baseapp] NewBaseApp now takes option functions as parameters * [types] `GetMsg()` -> `GetMsgs()` as txs wrap many messages * [types] Removed GetMemo from Tx (it is still on StdTx) * [types] renamed rational.Evaluate to rational.Round{Int64, Int} diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index 0d9356960b..b17e797774 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -73,7 +73,8 @@ var _ abci.Application = (*BaseApp)(nil) // Create and name new BaseApp // NOTE: The db is used to store the version number for now. -func NewBaseApp(name string, cdc *wire.Codec, logger log.Logger, db dbm.DB) *BaseApp { +// Accepts variable number of option functions, which act on the BaseApp to set configuration choices +func NewBaseApp(name string, cdc *wire.Codec, logger log.Logger, db dbm.DB, options ...func(*BaseApp)) *BaseApp { app := &BaseApp{ Logger: logger, name: name, @@ -86,6 +87,9 @@ func NewBaseApp(name string, cdc *wire.Codec, logger log.Logger, db dbm.DB) *Bas } // Register the undefined & root codespaces, which should not be used by any modules app.codespacer.RegisterOrPanic(sdk.CodespaceRoot) + for _, option := range options { + option(app) + } return app } diff --git a/baseapp/baseapp_test.go b/baseapp/baseapp_test.go index 4448d0e339..00897392ec 100644 --- a/baseapp/baseapp_test.go +++ b/baseapp/baseapp_test.go @@ -139,6 +139,21 @@ func testLoadVersionHelper(t *testing.T, app *BaseApp, expectedHeight int64, exp require.Equal(t, expectedID, lastID) } +func TestOptionFunction(t *testing.T) { + logger := defaultLogger() + db := dbm.NewMemDB() + codec := wire.NewCodec() + registerTestCodec(codec) + bap := NewBaseApp("starting name", codec, logger, db, testChangeNameHelper("new name")) + require.Equal(t, bap.name, "new name", "BaseApp should have had name changed via option function") +} + +func testChangeNameHelper(name string) func(*BaseApp) { + return func(bap *BaseApp) { + bap.name = name + } +} + // Test that the app hash is static // TODO: https://github.com/cosmos/cosmos-sdk/issues/520 /*func TestStaticAppHash(t *testing.T) {