certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

testing staking 

...

...
This commit is contained in:
rigelrozanski 2018-03-19 16:53:20 +01:00
parent b8cdf05921
commit c1d8aefecd
6 changed files with 91 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
x/auth/mapper.go
View File

@ -165,7 +165,6 @@ func (am accountMapper) decodeAccount(bz []byte) sdk.Account {
accI := oldwire.ReadBinary(struct{ sdk.Account }{}, r, len(bz), n, err) accI := oldwire.ReadBinary(struct{ sdk.Account }{}, r, len(bz), n, err)
if *err != nil { if *err != nil {
panic(*err) panic(*err)
} }
acc := accI.(struct{ sdk.Account }).Account acc := accI.(struct{ sdk.Account }).Account

149
x/stake/handler_test.go
View File

@ -14,21 +14,12 @@ import (
//______________________________________________________________________ //______________________________________________________________________
// XXX delete need to init accounts in the transact!
func initAccounts(amount int64) map[string]int64 {
accStore := map[string]int64{}
for _, addr := range addrs {
accStore[string(addr)] = amount
}
return accStore
}
func newTestMsgDeclareCandidacy(address sdk.Address, pubKey crypto.PubKey, amt int64) MsgDeclareCandidacy { func newTestMsgDeclareCandidacy(address sdk.Address, pubKey crypto.PubKey, amt int64) MsgDeclareCandidacy {
return MsgDeclareCandidacy{ return MsgDeclareCandidacy{
MsgAddr: NewMsgAddr(address), MsgAddr: NewMsgAddr(address),
PubKey: pubKey,
Bond: sdk.Coin{"fermion", amt},
Description: Description{}, Description: Description{},
Bond: sdk.Coin{"fermion", amt},
PubKey: pubKey,
} }
} }
@ -40,45 +31,40 @@ func newTestMsgDelegate(amt int64, address sdk.Address) MsgDelegate {
} }
func TestDuplicatesMsgDeclareCandidacy(t *testing.T) { func TestDuplicatesMsgDeclareCandidacy(t *testing.T) {
//accStore := initAccounts(1000) _, _, _, deliverer := createTestInput(t, addrs[0], false, 1000)
// XXX initalize values in accounts to 1000 _, _, _, checker := createTestInput(t, addrs[0], true, 1000)
_, deliverer := createTestInput(t, addrs[0], false)
_, checker := createTestInput(t, addrs[0], true)
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10) msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
got := deliverer.declareCandidacy(txDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
assert.NoError(t, got, "expected no error on runMsgDeclareCandidacy") assert.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
// one sender can bond to two different addresses // one sender can bond to two different addresses
txDeclareCandidacy.Address = addrs[1] msgDeclareCandidacy.Address = addrs[1]
err := checker.declareCandidacy(txDeclareCandidacy) err := checker.declareCandidacy(msgDeclareCandidacy)
assert.Nil(t, err, "didn't expected error on checkTx") assert.Nil(t, err, "didn't expected error on checkTx")
// two addrs cant bond to the same pubkey // two addrs cant bond to the same pubkey
checker.sender = addrs[1] checker.sender = addrs[1]
txDeclareCandidacy.Address = addrs[0] msgDeclareCandidacy.Address = addrs[0]
err = checker.declareCandidacy(txDeclareCandidacy) err = checker.declareCandidacy(msgDeclareCandidacy)
assert.NotNil(t, err, "expected error on checkTx") assert.NotNil(t, err, "expected error on checkTx")
} }
func TestIncrementsMsgDelegate(t *testing.T) { func TestIncrementsMsgDelegate(t *testing.T) {
//initSender := int64(1000) _, _, mapper, deliverer := createTestInput(t, addrs[0], false, 1000)
//accStore := initAccounts(initSender) // for accounts
// XXX initalize values in accounts to 1000
mapper, deliverer := createTestInput(t, addrs[0], false)
// first declare candidacy // first declare candidacy
bondAmount := int64(10) bondAmount := int64(10)
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], bondAmount) msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], bondAmount)
got := deliverer.declareCandidacy(txDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
assert.NoError(t, got, "expected declare candidacy tx to be ok, got %v", got) assert.NoError(t, got, "expected declare candidacy msg to be ok, got %v", got)
expectedBond := bondAmount // 1 since we send 1 at the start of loop, expectedBond := bondAmount // 1 since we send 1 at the start of loop,
// just send the same txbond multiple times // just send the same msgbond multiple times
txDelegate := newTestMsgDelegate(bondAmount, addrs[0]) msgDelegate := newTestMsgDelegate(bondAmount, addrs[0])
for i := 0; i < 5; i++ { for i := 0; i < 5; i++ {
got := deliverer.delegate(txDelegate) got := deliverer.delegate(msgDelegate)
assert.NoError(t, got, "expected tx %d to be ok, got %v", i, got) assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the accounts and the bond account have the appropriate values //Check that the accounts and the bond account have the appropriate values
candidates := mapper.loadCandidates() candidates := mapper.loadCandidates()
@ -92,25 +78,22 @@ func TestIncrementsMsgDelegate(t *testing.T) {
} }
func TestIncrementsMsgUnbond(t *testing.T) { func TestIncrementsMsgUnbond(t *testing.T) {
//initSender := int64(0) _, _, mapper, deliverer := createTestInput(t, addrs[0], false, 0)
//accStore := initAccounts(initSender) // for accounts
// XXX initalize values in accounts to 0
mapper, deliverer := createTestInput(t, addrs[0], false)
// set initial bond // set initial bond
initBond := int64(1000) initBond := int64(1000)
//accStore[string(deliverer.sender)] = initBond //XXX use StoreMapper //accStore[string(deliverer.sender)] = initBond //XXX use StoreMapper
got := deliverer.declareCandidacy(newTestMsgDeclareCandidacy(addrs[0], pks[0], initBond)) got := deliverer.declareCandidacy(newTestMsgDeclareCandidacy(addrs[0], pks[0], initBond))
assert.NoError(t, got, "expected initial bond tx to be ok, got %v", got) assert.NoError(t, got, "expected initial bond msg to be ok, got %v", got)
// just send the same txunbond multiple times // just send the same msgunbond multiple times
// XXX use decimals here // XXX use decimals here
unbondShares, unbondSharesStr := int64(10), "10" unbondShares, unbondSharesStr := int64(10), "10"
txUndelegate := NewMsgUnbond(addrs[0], unbondSharesStr) msgUndelegate := NewMsgUnbond(addrs[0], unbondSharesStr)
nUnbonds := 5 nUnbonds := 5
for i := 0; i < nUnbonds; i++ { for i := 0; i < nUnbonds; i++ {
got := deliverer.unbond(txUndelegate) got := deliverer.unbond(msgUndelegate)
assert.NoError(t, got, "expected tx %d to be ok, got %v", i, got) assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the accounts and the bond account have the appropriate values //Check that the accounts and the bond account have the appropriate values
candidates := mapper.loadCandidates() candidates := mapper.loadCandidates()
@ -133,41 +116,42 @@ func TestIncrementsMsgUnbond(t *testing.T) {
} }
for _, c := range errorCases { for _, c := range errorCases {
unbondShares := strconv.Itoa(int(c)) unbondShares := strconv.Itoa(int(c))
txUndelegate := NewMsgUnbond(addrs[0], unbondShares) msgUndelegate := NewMsgUnbond(addrs[0], unbondShares)
got = deliverer.unbond(txUndelegate) got = deliverer.unbond(msgUndelegate)
assert.Error(t, got, "expected unbond tx to fail") assert.Error(t, got, "expected unbond msg to fail")
} }
leftBonded := initBond - unbondShares*int64(nUnbonds) leftBonded := initBond - unbondShares*int64(nUnbonds)
// should be unable to unbond one more than we have // should be unable to unbond one more than we have
txUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)+1)) msgUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)+1))
got = deliverer.unbond(txUndelegate) got = deliverer.unbond(msgUndelegate)
assert.Error(t, got, "expected unbond tx to fail") assert.Error(t, got, "expected unbond msg to fail")
// should be able to unbond just what we have // should be able to unbond just what we have
txUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded))) msgUndelegate = NewMsgUnbond(addrs[0], strconv.Itoa(int(leftBonded)))
got = deliverer.unbond(txUndelegate) got = deliverer.unbond(msgUndelegate)
assert.NoError(t, got, "expected unbond tx to pass") assert.NoError(t, got, "expected unbond msg to pass")
} }
func TestMultipleMsgDeclareCandidacy(t *testing.T) { func TestMultipleMsgDeclareCandidacy(t *testing.T) {
initSender := int64(1000) initSender := int64(1000)
accStore := initAccounts(initSender) ctx, accStore, mapper, deliverer := createTestInput(t, addrs[0], false, initSender)
addrs := []sdk.Address{addrs[0], addrs[1], addrs[2]} addrs := []sdk.Address{addrs[0], addrs[1], addrs[2]}
mapper, deliverer := createTestInput(t, addrs[0], false)
// bond them all // bond them all
for i, addr := range addrs { for i, addr := range addrs {
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[i], pks[i], 10) msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[i], pks[i], 10)
deliverer.sender = addr deliverer.sender = addr
got := deliverer.declareCandidacy(txDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
assert.NoError(t, got, "expected tx %d to be ok, got %v", i, got) assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the account is bonded //Check that the account is bonded
candidates := mapper.loadCandidates() candidates := mapper.loadCandidates()
require.Equal(t, i, len(candidates))
val := candidates[i] val := candidates[i]
balanceGot, balanceExpd := accStore[string(val.Address)], initSender-10 balanceExpd := initSender - 10
balanceGot := accStore.GetAccount(ctx, val.Address).GetCoins()
assert.Equal(t, i+1, len(candidates), "expected %d candidates got %d, candidates: %v", i+1, len(candidates), candidates) assert.Equal(t, i+1, len(candidates), "expected %d candidates got %d, candidates: %v", i+1, len(candidates), candidates)
assert.Equal(t, 10, int(val.Liabilities.Evaluate()), "expected %d shares, got %d", 10, val.Liabilities) assert.Equal(t, 10, int(val.Liabilities.Evaluate()), "expected %d shares, got %d", 10, val.Liabilities)
assert.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot) assert.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot)
@ -176,39 +160,38 @@ func TestMultipleMsgDeclareCandidacy(t *testing.T) {
// unbond them all // unbond them all
for i, addr := range addrs { for i, addr := range addrs {
candidatePre := mapper.loadCandidate(addrs[i]) candidatePre := mapper.loadCandidate(addrs[i])
txUndelegate := NewMsgUnbond(addrs[i], "10") msgUndelegate := NewMsgUnbond(addrs[i], "10")
deliverer.sender = addr deliverer.sender = addr
got := deliverer.unbond(txUndelegate) got := deliverer.unbond(msgUndelegate)
assert.NoError(t, got, "expected tx %d to be ok, got %v", i, got) assert.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the account is unbonded //Check that the account is unbonded
candidates := mapper.loadCandidates() candidates := mapper.loadCandidates()
assert.Equal(t, len(addrs)-(i+1), len(candidates), "expected %d candidates got %d", len(addrs)-(i+1), len(candidates)) assert.Equal(t, len(addrs)-(i+1), len(candidates), "expected %d candidates got %d", len(addrs)-(i+1), len(candidates))
candidatePost := mapper.loadCandidate(addrs[i]) candidatePost := mapper.loadCandidate(addrs[i])
balanceGot, balanceExpd := accStore[string(candidatePre.Address)], initSender balanceExpd := initSender
balanceGot := accStore.GetAccount(ctx, candidatePre.Address).GetCoins()
assert.Nil(t, candidatePost, "expected nil candidate retrieve, got %d", 0, candidatePost) assert.Nil(t, candidatePost, "expected nil candidate retrieve, got %d", 0, candidatePost)
assert.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot) assert.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot)
} }
} }
func TestMultipleMsgDelegate(t *testing.T) { func TestMultipleMsgDelegate(t *testing.T) {
//accStore := initAccounts(1000)
// XXX initalize values in accounts to 1000
sender, delegators := addrs[0], addrs[1:] sender, delegators := addrs[0], addrs[1:]
mapper, deliverer := createTestInput(t, addrs[0], false) _, _, mapper, deliverer := createTestInput(t, addrs[0], false, 1000)
//first make a candidate //first make a candidate
txDeclareCandidacy := newTestMsgDeclareCandidacy(sender, pks[0], 10) msgDeclareCandidacy := newTestMsgDeclareCandidacy(sender, pks[0], 10)
got := deliverer.declareCandidacy(txDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
require.NoError(t, got, "expected tx to be ok, got %v", got) require.NoError(t, got, "expected msg to be ok, got %v", got)
// delegate multiple parties // delegate multiple parties
for i, delegator := range delegators { for i, delegator := range delegators {
txDelegate := newTestMsgDelegate(10, sender) msgDelegate := newTestMsgDelegate(10, sender)
deliverer.sender = delegator deliverer.sender = delegator
got := deliverer.delegate(txDelegate) got := deliverer.delegate(msgDelegate)
require.NoError(t, got, "expected tx %d to be ok, got %v", i, got) require.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the account is bonded //Check that the account is bonded
bond := mapper.loadDelegatorBond(delegator, sender) bond := mapper.loadDelegatorBond(delegator, sender)
@ -217,10 +200,10 @@ func TestMultipleMsgDelegate(t *testing.T) {
// unbond them all // unbond them all
for i, delegator := range delegators { for i, delegator := range delegators {
txUndelegate := NewMsgUnbond(sender, "10") msgUndelegate := NewMsgUnbond(sender, "10")
deliverer.sender = delegator deliverer.sender = delegator
got := deliverer.unbond(txUndelegate) got := deliverer.unbond(msgUndelegate)
require.NoError(t, got, "expected tx %d to be ok, got %v", i, got) require.NoError(t, got, "expected msg %d to be ok, got %v", i, got)
//Check that the account is unbonded //Check that the account is unbonded
bond := mapper.loadDelegatorBond(delegator, sender) bond := mapper.loadDelegatorBond(delegator, sender)
@ -229,38 +212,36 @@ func TestMultipleMsgDelegate(t *testing.T) {
} }
func TestVoidCandidacy(t *testing.T) { func TestVoidCandidacy(t *testing.T) {
// XXX use accountMapper to init all accounts to 1000
//accStore := initAccounts(1000)
sender, delegator := addrs[0], addrs[1] sender, delegator := addrs[0], addrs[1]
_, deliverer := createTestInput(t, addrs[0], false) _, _, _, deliverer := createTestInput(t, addrs[0], false, 1000)
// create the candidate // create the candidate
txDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10) msgDeclareCandidacy := newTestMsgDeclareCandidacy(addrs[0], pks[0], 10)
got := deliverer.declareCandidacy(txDeclareCandidacy) got := deliverer.declareCandidacy(msgDeclareCandidacy)
require.NoError(t, got, "expected no error on runMsgDeclareCandidacy") require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
// bond a delegator // bond a delegator
txDelegate := newTestMsgDelegate(10, addrs[0]) msgDelegate := newTestMsgDelegate(10, addrs[0])
deliverer.sender = delegator deliverer.sender = delegator
got = deliverer.delegate(txDelegate) got = deliverer.delegate(msgDelegate)
require.NoError(t, got, "expected ok, got %v", got) require.NoError(t, got, "expected ok, got %v", got)
// unbond the candidates bond portion // unbond the candidates bond portion
txUndelegate := NewMsgUnbond(addrs[0], "10") msgUndelegate := NewMsgUnbond(addrs[0], "10")
deliverer.sender = sender deliverer.sender = sender
got = deliverer.unbond(txUndelegate) got = deliverer.unbond(msgUndelegate)
require.NoError(t, got, "expected no error on runMsgDeclareCandidacy") require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
// test that this pubkey cannot yet be bonded too // test that this pubkey cannot yet be bonded too
deliverer.sender = delegator deliverer.sender = delegator
got = deliverer.delegate(txDelegate) got = deliverer.delegate(msgDelegate)
assert.Error(t, got, "expected error, got %v", got) assert.Error(t, got, "expected error, got %v", got)
// test that the delegator can still withdraw their bonds // test that the delegator can still withdraw their bonds
got = deliverer.unbond(txUndelegate) got = deliverer.unbond(msgUndelegate)
require.NoError(t, got, "expected no error on runMsgDeclareCandidacy") require.NoError(t, got, "expected no error on runMsgDeclareCandidacy")
// verify that the pubkey can now be reused // verify that the pubkey can now be reused
got = deliverer.declareCandidacy(txDeclareCandidacy) got = deliverer.declareCandidacy(msgDeclareCandidacy)
assert.NoError(t, got, "expected ok, got %v", got) assert.NoError(t, got, "expected ok, got %v", got)
} }

4
x/stake/mapper_test.go
View File

@ -161,7 +161,7 @@ import (
//} //}
func TestState(t *testing.T) { func TestState(t *testing.T) {
mapper, _ := createTestInput(t, nil, false) _, _, mapper, _ := createTestInput(t, nil, false, 0)
addrDel := sdk.Address([]byte("addressdelegator")) addrDel := sdk.Address([]byte("addressdelegator"))
addrVal := sdk.Address([]byte("addressvalidator")) addrVal := sdk.Address([]byte("addressvalidator"))
@ -258,7 +258,7 @@ func TestState(t *testing.T) {
} }
func TestGetValidators(t *testing.T) { func TestGetValidators(t *testing.T) {
mapper, _ := createTestInput(t, nil, false) _, _, mapper, _ := createTestInput(t, nil, false, 0)
candidatesFromAddrs(mapper, addrs, []int64{400, 200, 0, 0, 0}) candidatesFromAddrs(mapper, addrs, []int64{400, 200, 0, 0, 0})
validators := mapper.getValidators(5) validators := mapper.getValidators(5)

36
x/stake/test_common.go
View File

@ -75,11 +75,10 @@ func paramsNoInflation() Params {
} }
// hogpodge of all sorts of input required for testing // hogpodge of all sorts of input required for testing
//func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool) (sdk.KVStore, sdk.Context, sdk.StoreKey, Mapper, bank.CoinKeeper, transact) { func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool, initCoins int64) (sdk.Context, sdk.AccountMapper, Mapper, transact) {
func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool) (Mapper, transact) {
db := dbm.NewMemDB() db := dbm.NewMemDB()
keyMain := sdk.NewKVStoreKey("main")
keyStake := sdk.NewKVStoreKey("stake") keyStake := sdk.NewKVStoreKey("stake")
keyMain := keyStake //sdk.NewKVStoreKey("main") //XXX fix multistore
ms := store.NewCommitMultiStore(db) ms := store.NewCommitMultiStore(db)
ms.MountStoreWithDB(keyStake, sdk.StoreTypeIAVL, db) ms.MountStoreWithDB(keyStake, sdk.StoreTypeIAVL, db)
@ -96,12 +95,17 @@ func createTestInput(t *testing.T, sender sdk.Address, isCheckTx bool) (Mapper,
&auth.BaseAccount{}, // prototype &auth.BaseAccount{}, // prototype
) )
ck := bank.NewCoinKeeper(accountMapper) ck := bank.NewCoinKeeper(accountMapper)
params := paramsNoInflation() params := paramsNoInflation()
mapper.saveParams(params) mapper.saveParams(params)
// fill all the addresses with some coins
for _, addr := range addrs {
ck.AddCoins(ctx, addr, sdk.Coins{{params.BondDenom, initCoins}})
}
tr := newTransact(ctx, sender, mapper, ck) tr := newTransact(ctx, sender, mapper, ck)
return mapper, tr return ctx, accountMapper, mapper, tr
} }
func newPubKey(pk string) (res crypto.PubKey) { func newPubKey(pk string) (res crypto.PubKey) {
@ -130,7 +134,7 @@ var pks = []crypto.PubKey{
// for incode address generation // for incode address generation
func testAddr(addr string) sdk.Address { func testAddr(addr string) sdk.Address {
res, err := sdk.GetAddress("0XA58856F0FD53BF058B4909A21AEC019107BA6160") res, err := sdk.GetAddress(addr)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -139,16 +143,16 @@ func testAddr(addr string) sdk.Address {
// dummy addresses used for testing // dummy addresses used for testing
var addrs = []sdk.Address{ var addrs = []sdk.Address{
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6160"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6160"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6161"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6161"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6162"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6162"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6163"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6163"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6164"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6164"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6165"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6165"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6166"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6166"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6167"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6167"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6168"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6168"),
testAddr("0XA58856F0FD53BF058B4909A21AEC019107BA6169"), testAddr("A58856F0FD53BF058B4909A21AEC019107BA6169"),
} }
// NOTE: PubKey is supposed to be the binaryBytes of the crypto.PubKey // NOTE: PubKey is supposed to be the binaryBytes of the crypto.PubKey

4
x/stake/tick_test.go
View File

@ -8,7 +8,7 @@ import (
) )
func TestGetInflation(t *testing.T) { func TestGetInflation(t *testing.T) {
mapper, _ := createTestInput(t, nil, false) _, _, mapper, _ := createTestInput(t, nil, false, 0)
params := mapper.loadParams() params := mapper.loadParams()
gs := mapper.loadGlobalState() gs := mapper.loadGlobalState()
@ -53,7 +53,7 @@ func TestGetInflation(t *testing.T) {
} }
func TestProcessProvisions(t *testing.T) { func TestProcessProvisions(t *testing.T) {
mapper, _ := createTestInput(t, nil, false) _, _, mapper, _ := createTestInput(t, nil, false, 0)
params := mapper.loadParams() params := mapper.loadParams()
gs := mapper.loadGlobalState() gs := mapper.loadGlobalState()

2
x/stake/tx.go
View File

@ -50,7 +50,6 @@ type MsgDeclareCandidacy struct {
MsgAddr MsgAddr
Description Description
Bond sdk.Coin `json:"bond"` Bond sdk.Coin `json:"bond"`
Address sdk.Address `json:"address"`
PubKey crypto.PubKey `json:"pubkey"` PubKey crypto.PubKey `json:"pubkey"`
} }
@ -59,7 +58,6 @@ func NewMsgDeclareCandidacy(address sdk.Address, pubkey crypto.PubKey, bond sdk.
MsgAddr: NewMsgAddr(address), MsgAddr: NewMsgAddr(address),
Description: description, Description: description,
Bond: bond, Bond: bond,
Address: address,
PubKey: pubkey, PubKey: pubkey,
} }
} }