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

Merge PR #1811: NewCoin takes sdk.Int

This commit is contained in:
Joon 2018-07-30 17:09:50 -07:00 committed by Christopher Goes
parent d3fcfdba57
commit 19b0781e60
34 changed files with 269 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
PENDING.md
View File

@ -25,6 +25,7 @@ BREAKING CHANGES
* `gaiacli gov vote --voter`
* [x/gov] Added tags sub-package, changed tags to use dash-case
* [x/gov] Governance parameters are now stored in globalparams store
* [types] sdk.NewCoin now takes sdk.Int, sdk.NewInt64Coin takes int64
FEATURES
* [lcd] Can now query governance proposals by ProposalStatus

6
client/lcd/lcd_test.go
View File

@ -473,11 +473,11 @@ func TestDeposit(t *testing.T) {
// query proposal
proposal = getProposal(t, port, proposalID)
require.True(t, proposal.GetTotalDeposit().IsEqual(sdk.Coins{sdk.NewCoin("steak", 10)}))
require.True(t, proposal.GetTotalDeposit().IsEqual(sdk.Coins{sdk.NewInt64Coin("steak", 10)}))
// query deposit
deposit := getDeposit(t, port, proposalID, addr)
require.True(t, deposit.Amount.IsEqual(sdk.Coins{sdk.NewCoin("steak", 10)}))
require.True(t, deposit.Amount.IsEqual(sdk.Coins{sdk.NewInt64Coin("steak", 10)}))
}
func TestVote(t *testing.T) {
@ -649,7 +649,7 @@ func doSend(t *testing.T, port, seed, name, password string, addr sdk.AccAddress
chainID := viper.GetString(client.FlagChainID)
// send
coinbz, err := cdc.MarshalJSON(sdk.NewCoin("steak", 1))
coinbz, err := cdc.MarshalJSON(sdk.NewInt64Coin("steak", 1))
if err != nil {
panic(err)
}

2
client/lcd/test_helpers.go
View File

@ -170,7 +170,7 @@ func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress
// add some tokens to init accounts
for _, addr := range initAddrs {
accAuth := auth.NewBaseAccountWithAddress(addr)
accAuth.Coins = sdk.Coins{sdk.NewCoin("steak", 100)}
accAuth.Coins = sdk.Coins{sdk.NewInt64Coin("steak", 100)}
acc := gapp.NewGenesisAccount(&accAuth)
genesisState.Accounts = append(genesisState.Accounts, acc)
genesisState.StakeData.Pool.LooseTokens = genesisState.StakeData.Pool.LooseTokens.Add(sdk.NewRat(100))

2
examples/democoin/x/cool/handler.go
View File

@ -47,7 +47,7 @@ func handleMsgQuiz(ctx sdk.Context, k Keeper, msg MsgQuiz) sdk.Result {
return ErrIncorrectCoolAnswer(k.codespace, msg.CoolAnswer).Result()
}
bonusCoins := sdk.Coins{sdk.NewCoin(msg.CoolAnswer, 69)}
bonusCoins := sdk.Coins{sdk.NewInt64Coin(msg.CoolAnswer, 69)}
_, _, err := k.ck.AddCoins(ctx, msg.Sender, bonusCoins)
if err != nil {

2
examples/democoin/x/pow/keeper.go
View File

@ -125,7 +125,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.AccAddress, newDifficulty uint64, newCount uint64) sdk.Error {
_, _, ckErr := k.ck.AddCoins(ctx, sender, []sdk.Coin{sdk.NewCoin(k.config.Denomination, k.config.Reward)})
_, _, ckErr := k.ck.AddCoins(ctx, sender, []sdk.Coin{sdk.NewInt64Coin(k.config.Denomination, k.config.Reward)})
if ckErr != nil {
return ckErr
}

2
examples/democoin/x/simplestake/keeper.go
View File

@ -93,7 +93,7 @@ func (k Keeper) Unbond(ctx sdk.Context, addr sdk.AccAddress) (crypto.PubKey, int
}
k.deleteBondInfo(ctx, addr)
returnedBond := sdk.NewCoin(stakingToken, bi.Power)
returnedBond := sdk.NewInt64Coin(stakingToken, bi.Power)
_, _, err := k.ck.AddCoins(ctx, addr, []sdk.Coin{returnedBond})
if err != nil {

4
examples/democoin/x/simplestake/keeper_test.go
View File

@ -75,10 +75,10 @@ func TestBonding(t *testing.T) {
_, _, err := stakeKeeper.unbondWithoutCoins(ctx, addr)
require.Equal(t, err, ErrInvalidUnbond(DefaultCodespace))
_, err = stakeKeeper.bondWithoutCoins(ctx, addr, pubKey, sdk.NewCoin("steak", 10))
_, err = stakeKeeper.bondWithoutCoins(ctx, addr, pubKey, sdk.NewInt64Coin("steak", 10))
require.Nil(t, err)
power, err := stakeKeeper.bondWithoutCoins(ctx, addr, pubKey, sdk.NewCoin("steak", 10))
power, err := stakeKeeper.bondWithoutCoins(ctx, addr, pubKey, sdk.NewInt64Coin("steak", 10))
require.Nil(t, err)
require.Equal(t, int64(20), power)

4
examples/democoin/x/simplestake/msgs_test.go
View File

@ -15,8 +15,8 @@ func TestBondMsgValidation(t *testing.T) {
valid bool
msgBond MsgBond
}{
{true, NewMsgBond(sdk.AccAddress{}, sdk.NewCoin("mycoin", 5), privKey.PubKey())},
{false, NewMsgBond(sdk.AccAddress{}, sdk.NewCoin("mycoin", 0), privKey.PubKey())},
{true, NewMsgBond(sdk.AccAddress{}, sdk.NewInt64Coin("mycoin", 5), privKey.PubKey())},
{false, NewMsgBond(sdk.AccAddress{}, sdk.NewInt64Coin("mycoin", 0), privKey.PubKey())},
}
for i, tc := range cases {

10
types/coin.go
View File

@ -14,17 +14,17 @@ type Coin struct {
Amount Int `json:"amount"`
}
func NewCoin(denom string, amount int64) Coin {
return NewIntCoin(denom, NewInt(amount))
}
func NewIntCoin(denom string, amount Int) Coin {
func NewCoin(denom string, amount Int) Coin {
return Coin{
Denom: denom,
Amount: amount,
}
}
func NewInt64Coin(denom string, amount int64) Coin {
return NewCoin(denom, NewInt(amount))
}
// String provides a human-readable representation of a coin
func (coin Coin) String() string {
return fmt.Sprintf("%v%v", coin.Amount, coin.Denom)

110
types/coin_test.go
View File

@ -12,9 +12,9 @@ func TestIsPositiveCoin(t *testing.T) {
inputOne Coin
expected bool
}{
{NewCoin("A", 1), true},
{NewCoin("A", 0), false},
{NewCoin("a", -1), false},
{NewInt64Coin("A", 1), true},
{NewInt64Coin("A", 0), false},
{NewInt64Coin("a", -1), false},
}
for tcIndex, tc := range cases {
@ -28,9 +28,9 @@ func TestIsNotNegativeCoin(t *testing.T) {
inputOne Coin
expected bool
}{
{NewCoin("A", 1), true},
{NewCoin("A", 0), true},
{NewCoin("a", -1), false},
{NewInt64Coin("A", 1), true},
{NewInt64Coin("A", 0), true},
{NewInt64Coin("a", -1), false},
}
for tcIndex, tc := range cases {
@ -45,11 +45,11 @@ func TestSameDenomAsCoin(t *testing.T) {
inputTwo Coin
expected bool
}{
{NewCoin("A", 1), NewCoin("A", 1), true},
{NewCoin("A", 1), NewCoin("a", 1), false},
{NewCoin("a", 1), NewCoin("b", 1), false},
{NewCoin("steak", 1), NewCoin("steak", 10), true},
{NewCoin("steak", -11), NewCoin("steak", 10), true},
{NewInt64Coin("A", 1), NewInt64Coin("A", 1), true},
{NewInt64Coin("A", 1), NewInt64Coin("a", 1), false},
{NewInt64Coin("a", 1), NewInt64Coin("b", 1), false},
{NewInt64Coin("steak", 1), NewInt64Coin("steak", 10), true},
{NewInt64Coin("steak", -11), NewInt64Coin("steak", 10), true},
}
for tcIndex, tc := range cases {
@ -64,10 +64,10 @@ func TestIsGTECoin(t *testing.T) {
inputTwo Coin
expected bool
}{
{NewCoin("A", 1), NewCoin("A", 1), true},
{NewCoin("A", 2), NewCoin("A", 1), true},
{NewCoin("A", -1), NewCoin("A", 5), false},
{NewCoin("a", 1), NewCoin("b", 1), false},
{NewInt64Coin("A", 1), NewInt64Coin("A", 1), true},
{NewInt64Coin("A", 2), NewInt64Coin("A", 1), true},
{NewInt64Coin("A", -1), NewInt64Coin("A", 5), false},
{NewInt64Coin("a", 1), NewInt64Coin("b", 1), false},
}
for tcIndex, tc := range cases {
@ -82,11 +82,11 @@ func TestIsEqualCoin(t *testing.T) {
inputTwo Coin
expected bool
}{
{NewCoin("A", 1), NewCoin("A", 1), true},
{NewCoin("A", 1), NewCoin("a", 1), false},
{NewCoin("a", 1), NewCoin("b", 1), false},
{NewCoin("steak", 1), NewCoin("steak", 10), false},
{NewCoin("steak", -11), NewCoin("steak", 10), false},
{NewInt64Coin("A", 1), NewInt64Coin("A", 1), true},
{NewInt64Coin("A", 1), NewInt64Coin("a", 1), false},
{NewInt64Coin("a", 1), NewInt64Coin("b", 1), false},
{NewInt64Coin("steak", 1), NewInt64Coin("steak", 10), false},
{NewInt64Coin("steak", -11), NewInt64Coin("steak", 10), false},
}
for tcIndex, tc := range cases {
@ -101,9 +101,9 @@ func TestPlusCoin(t *testing.T) {
inputTwo Coin
expected Coin
}{
{NewCoin("A", 1), NewCoin("A", 1), NewCoin("A", 2)},
{NewCoin("A", 1), NewCoin("B", 1), NewCoin("A", 1)},
{NewCoin("asdf", -4), NewCoin("asdf", 5), NewCoin("asdf", 1)},
{NewInt64Coin("A", 1), NewInt64Coin("A", 1), NewInt64Coin("A", 2)},
{NewInt64Coin("A", 1), NewInt64Coin("B", 1), NewInt64Coin("A", 1)},
{NewInt64Coin("asdf", -4), NewInt64Coin("asdf", 5), NewInt64Coin("asdf", 1)},
}
for tcIndex, tc := range cases {
@ -115,7 +115,7 @@ func TestPlusCoin(t *testing.T) {
inputOne Coin
inputTwo Coin
expected int64
}{NewCoin("asdf", -1), NewCoin("asdf", 1), 0}
}{NewInt64Coin("asdf", -1), NewInt64Coin("asdf", 1), 0}
res := tc.inputOne.Plus(tc.inputTwo)
require.Equal(t, tc.expected, res.Amount.Int64())
}
@ -127,9 +127,9 @@ func TestMinusCoin(t *testing.T) {
expected Coin
}{
{NewCoin("A", 1), NewCoin("B", 1), NewCoin("A", 1)},
{NewCoin("asdf", -4), NewCoin("asdf", 5), NewCoin("asdf", -9)},
{NewCoin("asdf", 10), NewCoin("asdf", 1), NewCoin("asdf", 9)},
{NewInt64Coin("A", 1), NewInt64Coin("B", 1), NewInt64Coin("A", 1)},
{NewInt64Coin("asdf", -4), NewInt64Coin("asdf", 5), NewInt64Coin("asdf", -9)},
{NewInt64Coin("asdf", 10), NewInt64Coin("asdf", 1), NewInt64Coin("asdf", 9)},
}
for tcIndex, tc := range cases {
@ -141,7 +141,7 @@ func TestMinusCoin(t *testing.T) {
inputOne Coin
inputTwo Coin
expected int64
}{NewCoin("A", 1), NewCoin("A", 1), 0}
}{NewInt64Coin("A", 1), NewInt64Coin("A", 1), 0}
res := tc.inputOne.Minus(tc.inputTwo)
require.Equal(t, tc.expected, res.Amount.Int64())
@ -256,32 +256,32 @@ func TestParse(t *testing.T) {
func TestSortCoins(t *testing.T) {
good := Coins{
NewCoin("GAS", 1),
NewCoin("MINERAL", 1),
NewCoin("TREE", 1),
NewInt64Coin("GAS", 1),
NewInt64Coin("MINERAL", 1),
NewInt64Coin("TREE", 1),
}
empty := Coins{
NewCoin("GOLD", 0),
NewInt64Coin("GOLD", 0),
}
badSort1 := Coins{
NewCoin("TREE", 1),
NewCoin("GAS", 1),
NewCoin("MINERAL", 1),
NewInt64Coin("TREE", 1),
NewInt64Coin("GAS", 1),
NewInt64Coin("MINERAL", 1),
}
badSort2 := Coins{ // both are after the first one, but the second and third are in the wrong order
NewCoin("GAS", 1),
NewCoin("TREE", 1),
NewCoin("MINERAL", 1),
NewInt64Coin("GAS", 1),
NewInt64Coin("TREE", 1),
NewInt64Coin("MINERAL", 1),
}
badAmt := Coins{
NewCoin("GAS", 1),
NewCoin("TREE", 0),
NewCoin("MINERAL", 1),
NewInt64Coin("GAS", 1),
NewInt64Coin("TREE", 0),
NewInt64Coin("MINERAL", 1),
}
dup := Coins{
NewCoin("GAS", 1),
NewCoin("GAS", 1),
NewCoin("MINERAL", 1),
NewInt64Coin("GAS", 1),
NewInt64Coin("GAS", 1),
NewInt64Coin("MINERAL", 1),
}
cases := []struct {
@ -307,31 +307,31 @@ func TestAmountOf(t *testing.T) {
case0 := Coins{}
case1 := Coins{
NewCoin("", 0),
NewInt64Coin("", 0),
}
case2 := Coins{
NewCoin(" ", 0),
NewInt64Coin(" ", 0),
}
case3 := Coins{
NewCoin("GOLD", 0),
NewInt64Coin("GOLD", 0),
}
case4 := Coins{
NewCoin("GAS", 1),
NewCoin("MINERAL", 1),
NewCoin("TREE", 1),
NewInt64Coin("GAS", 1),
NewInt64Coin("MINERAL", 1),
NewInt64Coin("TREE", 1),
}
case5 := Coins{
NewCoin("MINERAL", 1),
NewCoin("TREE", 1),
NewInt64Coin("MINERAL", 1),
NewInt64Coin("TREE", 1),
}
case6 := Coins{
NewCoin("", 6),
NewInt64Coin("", 6),
}
case7 := Coins{
NewCoin(" ", 7),
NewInt64Coin(" ", 7),
}
case8 := Coins{
NewCoin("GAS", 8),
NewInt64Coin("GAS", 8),
}
cases := []struct {

4
x/auth/account_test.go
View File

@ -56,7 +56,7 @@ func TestBaseAccountCoins(t *testing.T) {
_, _, addr := keyPubAddr()
acc := NewBaseAccountWithAddress(addr)
someCoins := sdk.Coins{sdk.NewCoin("atom", 123), sdk.NewCoin("eth", 246)}
someCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 246)}
err := acc.SetCoins(someCoins)
require.Nil(t, err)
@ -78,7 +78,7 @@ func TestBaseAccountMarshal(t *testing.T) {
_, pub, addr := keyPubAddr()
acc := NewBaseAccountWithAddress(addr)
someCoins := sdk.Coins{sdk.NewCoin("atom", 123), sdk.NewCoin("eth", 246)}
someCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 246)}
seq := int64(7)
// set everything on the account

18
x/auth/ante_test.go
View File

@ -20,14 +20,14 @@ func newTestMsg(addrs ...sdk.AccAddress) *sdk.TestMsg {
func newStdFee() StdFee {
return NewStdFee(5000,
sdk.NewCoin("atom", 150),
sdk.NewInt64Coin("atom", 150),
)
}
// coins to more than cover the fee
func newCoins() sdk.Coins {
return sdk.Coins{
sdk.NewCoin("atom", 10000000),
sdk.NewInt64Coin("atom", 10000000),
}
}
@ -325,17 +325,17 @@ func TestAnteHandlerFees(t *testing.T) {
tx = newTestTx(ctx, msgs, privs, accnums, seqs, fee)
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInsufficientFunds)
acc1.SetCoins(sdk.Coins{sdk.NewCoin("atom", 149)})
acc1.SetCoins(sdk.Coins{sdk.NewInt64Coin("atom", 149)})
mapper.SetAccount(ctx, acc1)
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInsufficientFunds)
require.True(t, feeCollector.GetCollectedFees(ctx).IsEqual(emptyCoins))
acc1.SetCoins(sdk.Coins{sdk.NewCoin("atom", 150)})
acc1.SetCoins(sdk.Coins{sdk.NewInt64Coin("atom", 150)})
mapper.SetAccount(ctx, acc1)
checkValidTx(t, anteHandler, ctx, tx)
require.True(t, feeCollector.GetCollectedFees(ctx).IsEqual(sdk.Coins{sdk.NewCoin("atom", 150)}))
require.True(t, feeCollector.GetCollectedFees(ctx).IsEqual(sdk.Coins{sdk.NewInt64Coin("atom", 150)}))
}
// Test logic around memo gas consumption.
@ -360,24 +360,24 @@ func TestAnteHandlerMemoGas(t *testing.T) {
var tx sdk.Tx
msg := newTestMsg(addr1)
privs, accnums, seqs := []crypto.PrivKey{priv1}, []int64{0}, []int64{0}
fee := NewStdFee(0, sdk.NewCoin("atom", 0))
fee := NewStdFee(0, sdk.NewInt64Coin("atom", 0))
// tx does not have enough gas
tx = newTestTx(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee)
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeOutOfGas)
// tx with memo doesn't have enough gas
fee = NewStdFee(801, sdk.NewCoin("atom", 0))
fee = NewStdFee(801, sdk.NewInt64Coin("atom", 0))
tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, "abcininasidniandsinasindiansdiansdinaisndiasndiadninsd")
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeOutOfGas)
// memo too large
fee = NewStdFee(2001, sdk.NewCoin("atom", 0))
fee = NewStdFee(2001, sdk.NewInt64Coin("atom", 0))
tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, "abcininasidniandsinasindiansdiansdinaisndiasndiadninsdabcininasidniandsinasindiansdiansdinaisndiasndiadninsdabcininasidniandsinasindiansdiansdinaisndiasndiadninsd")
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeMemoTooLarge)
// tx with memo has enough gas
fee = NewStdFee(1100, sdk.NewCoin("atom", 0))
fee = NewStdFee(1100, sdk.NewInt64Coin("atom", 0))
tx = newTestTxWithMemo(ctx, []sdk.Msg{msg}, privs, accnums, seqs, fee, "abcininasidniandsinasindiansdiansdinaisndiasndiadninsd")
checkValidTx(t, anteHandler, ctx, tx)
}

4
x/auth/feekeeper_test.go
View File

@ -14,8 +14,8 @@ import (
var (
emptyCoins = sdk.Coins{}
oneCoin = sdk.Coins{sdk.NewCoin("foocoin", 1)}
twoCoins = sdk.Coins{sdk.NewCoin("foocoin", 2)}
oneCoin = sdk.Coins{sdk.NewInt64Coin("foocoin", 1)}
twoCoins = sdk.Coins{sdk.NewInt64Coin("foocoin", 2)}
)
func TestFeeCollectionKeeperGetSet(t *testing.T) {

46
x/bank/app_test.go
View File

@ -39,10 +39,10 @@ var (
priv4 = ed25519.GenPrivKey()
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)}
freeFee = auth.NewStdFee(100000, sdk.Coins{sdk.NewCoin("foocoin", 0)}...)
coins = sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}
halfCoins = sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}
manyCoins = sdk.Coins{sdk.NewInt64Coin("foocoin", 1), sdk.NewInt64Coin("barcoin", 1)}
freeFee = auth.NewStdFee(100000, sdk.Coins{sdk.NewInt64Coin("foocoin", 0)}...)
sendMsg1 = MsgSend{
Inputs: []Input{NewInput(addr1, coins)},
@ -94,7 +94,7 @@ func TestMsgSendWithAccounts(t *testing.T) {
mapp := getMockApp(t)
acc := &auth.BaseAccount{
Address: addr1,
Coins: sdk.Coins{sdk.NewCoin("foocoin", 67)},
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 67)},
}
mock.SetGenesis(mapp, []auth.Account{acc})
@ -113,8 +113,8 @@ func TestMsgSendWithAccounts(t *testing.T) {
expPass: true,
privKeys: []crypto.PrivKey{priv1},
expectedBalances: []expectedBalance{
expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 57)}},
expectedBalance{addr2, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
expectedBalance{addr1, sdk.Coins{sdk.NewInt64Coin("foocoin", 57)}},
expectedBalance{addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}},
},
},
{
@ -152,11 +152,11 @@ func TestMsgSendMultipleOut(t *testing.T) {
acc1 := &auth.BaseAccount{
Address: addr1,
Coins: sdk.Coins{sdk.NewCoin("foocoin", 42)},
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)},
}
acc2 := &auth.BaseAccount{
Address: addr2,
Coins: sdk.Coins{sdk.NewCoin("foocoin", 42)},
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)},
}
mock.SetGenesis(mapp, []auth.Account{acc1, acc2})
@ -169,9 +169,9 @@ func TestMsgSendMultipleOut(t *testing.T) {
expPass: true,
privKeys: []crypto.PrivKey{priv1},
expectedBalances: []expectedBalance{
expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
expectedBalance{addr2, sdk.Coins{sdk.NewCoin("foocoin", 47)}},
expectedBalance{addr3, sdk.Coins{sdk.NewCoin("foocoin", 5)}},
expectedBalance{addr1, sdk.Coins{sdk.NewInt64Coin("foocoin", 32)}},
expectedBalance{addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 47)}},
expectedBalance{addr3, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}},
},
},
}
@ -190,15 +190,15 @@ func TestSengMsgMultipleInOut(t *testing.T) {
acc1 := &auth.BaseAccount{
Address: addr1,
Coins: sdk.Coins{sdk.NewCoin("foocoin", 42)},
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)},
}
acc2 := &auth.BaseAccount{
Address: addr2,
Coins: sdk.Coins{sdk.NewCoin("foocoin", 42)},
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)},
}
acc4 := &auth.BaseAccount{
Address: addr4,
Coins: sdk.Coins{sdk.NewCoin("foocoin", 42)},
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)},
}
mock.SetGenesis(mapp, []auth.Account{acc1, acc2, acc4})
@ -211,10 +211,10 @@ func TestSengMsgMultipleInOut(t *testing.T) {
expPass: true,
privKeys: []crypto.PrivKey{priv1, priv4},
expectedBalances: []expectedBalance{
expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
expectedBalance{addr4, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
expectedBalance{addr2, sdk.Coins{sdk.NewCoin("foocoin", 52)}},
expectedBalance{addr3, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
expectedBalance{addr1, sdk.Coins{sdk.NewInt64Coin("foocoin", 32)}},
expectedBalance{addr4, sdk.Coins{sdk.NewInt64Coin("foocoin", 32)}},
expectedBalance{addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 52)}},
expectedBalance{addr3, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}},
},
},
}
@ -233,7 +233,7 @@ func TestMsgSendDependent(t *testing.T) {
acc1 := &auth.BaseAccount{
Address: addr1,
Coins: sdk.Coins{sdk.NewCoin("foocoin", 42)},
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 42)},
}
mock.SetGenesis(mapp, []auth.Account{acc1})
@ -246,8 +246,8 @@ func TestMsgSendDependent(t *testing.T) {
expPass: true,
privKeys: []crypto.PrivKey{priv1},
expectedBalances: []expectedBalance{
expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 32)}},
expectedBalance{addr2, sdk.Coins{sdk.NewCoin("foocoin", 10)}},
expectedBalance{addr1, sdk.Coins{sdk.NewInt64Coin("foocoin", 32)}},
expectedBalance{addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}},
},
},
{
@ -257,7 +257,7 @@ func TestMsgSendDependent(t *testing.T) {
expPass: true,
privKeys: []crypto.PrivKey{priv2},
expectedBalances: []expectedBalance{
expectedBalance{addr1, sdk.Coins{sdk.NewCoin("foocoin", 42)}},
expectedBalance{addr1, sdk.Coins{sdk.NewInt64Coin("foocoin", 42)}},
},
},
}

2
x/bank/bench_test.go
View File

@ -30,7 +30,7 @@ func BenchmarkOneBankSendTxPerBlock(b *testing.B) {
acc := &auth.BaseAccount{
Address: addr1,
// Some value conceivably higher than the benchmarks would ever go
Coins: sdk.Coins{sdk.NewCoin("foocoin", 100000000000)},
Coins: sdk.Coins{sdk.NewInt64Coin("foocoin", 100000000000)},
}
accs := []auth.Account{acc}

146
x/bank/keeper_test.go
View File

@ -45,69 +45,69 @@ func TestKeeper(t *testing.T) {
accountMapper.SetAccount(ctx, acc)
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 10)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 10)}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
// Test HasCoins
require.True(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 10)}))
require.True(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 5)}))
require.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 15)}))
require.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 5)}))
require.True(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
require.True(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
require.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)}))
require.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 5)}))
// Test AddCoins
coinKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 15)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 25)}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 25)}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 15)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 15), sdk.NewCoin("foocoin", 25)}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 15)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 15), sdk.NewInt64Coin("foocoin", 25)}))
// Test SubtractCoins
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 10)})
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 5)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 10), sdk.NewCoin("foocoin", 15)}))
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)})
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 5)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15)}))
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 11)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 10), sdk.NewCoin("foocoin", 15)}))
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 11)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 15)}))
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 10)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 15)}))
require.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 1)}))
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 10)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 15)}))
require.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 1)}))
// Test SendCoins
coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewCoin("foocoin", 5)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 10)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 5)}))
coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
_, err2 := coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewCoin("foocoin", 50)})
_, err2 := coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 50)})
assert.Implements(t, (*sdk.Error)(nil), err2)
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 10)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 5)}))
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 30)})
coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewCoin("barcoin", 10), sdk.NewCoin("foocoin", 5)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 20), sdk.NewCoin("foocoin", 5)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 10), sdk.NewCoin("foocoin", 10)}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 30)})
coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10)}))
// Test InputOutputCoins
input1 := NewInput(addr2, sdk.Coins{sdk.NewCoin("foocoin", 2)})
output1 := NewOutput(addr, sdk.Coins{sdk.NewCoin("foocoin", 2)})
input1 := NewInput(addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 2)})
output1 := NewOutput(addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 2)})
coinKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1})
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 20), sdk.NewCoin("foocoin", 7)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 10), sdk.NewCoin("foocoin", 8)}))
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 7)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 8)}))
inputs := []Input{
NewInput(addr, sdk.Coins{sdk.NewCoin("foocoin", 3)}),
NewInput(addr2, sdk.Coins{sdk.NewCoin("barcoin", 3), sdk.NewCoin("foocoin", 2)}),
NewInput(addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 3)}),
NewInput(addr2, sdk.Coins{sdk.NewInt64Coin("barcoin", 3), sdk.NewInt64Coin("foocoin", 2)}),
}
outputs := []Output{
NewOutput(addr, sdk.Coins{sdk.NewCoin("barcoin", 1)}),
NewOutput(addr3, sdk.Coins{sdk.NewCoin("barcoin", 2), sdk.NewCoin("foocoin", 5)}),
NewOutput(addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 1)}),
NewOutput(addr3, sdk.Coins{sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5)}),
}
coinKeeper.InputOutputCoins(ctx, inputs, outputs)
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 21), sdk.NewCoin("foocoin", 4)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 7), sdk.NewCoin("foocoin", 6)}))
require.True(t, coinKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 2), sdk.NewCoin("foocoin", 5)}))
require.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 21), sdk.NewInt64Coin("foocoin", 4)}))
require.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 7), sdk.NewInt64Coin("foocoin", 6)}))
require.True(t, coinKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5)}))
}
@ -131,52 +131,52 @@ func TestSendKeeper(t *testing.T) {
accountMapper.SetAccount(ctx, acc)
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 10)})
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 10)}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)})
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
// Test HasCoins
require.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 10)}))
require.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 5)}))
require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 15)}))
require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 5)}))
require.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
require.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)}))
require.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 5)}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 15)})
coinKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)})
// Test SendCoins
sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewCoin("foocoin", 5)})
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 10)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 5)}))
sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)})
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
_, err2 := sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewCoin("foocoin", 50)})
_, err2 := sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 50)})
assert.Implements(t, (*sdk.Error)(nil), err2)
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 10)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 5)}))
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 30)})
sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewCoin("barcoin", 10), sdk.NewCoin("foocoin", 5)})
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 20), sdk.NewCoin("foocoin", 5)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 10), sdk.NewCoin("foocoin", 10)}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 30)})
sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 5)})
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 5)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 10)}))
// Test InputOutputCoins
input1 := NewInput(addr2, sdk.Coins{sdk.NewCoin("foocoin", 2)})
output1 := NewOutput(addr, sdk.Coins{sdk.NewCoin("foocoin", 2)})
input1 := NewInput(addr2, sdk.Coins{sdk.NewInt64Coin("foocoin", 2)})
output1 := NewOutput(addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 2)})
sendKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1})
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 20), sdk.NewCoin("foocoin", 7)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 10), sdk.NewCoin("foocoin", 8)}))
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 20), sdk.NewInt64Coin("foocoin", 7)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 10), sdk.NewInt64Coin("foocoin", 8)}))
inputs := []Input{
NewInput(addr, sdk.Coins{sdk.NewCoin("foocoin", 3)}),
NewInput(addr2, sdk.Coins{sdk.NewCoin("barcoin", 3), sdk.NewCoin("foocoin", 2)}),
NewInput(addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 3)}),
NewInput(addr2, sdk.Coins{sdk.NewInt64Coin("barcoin", 3), sdk.NewInt64Coin("foocoin", 2)}),
}
outputs := []Output{
NewOutput(addr, sdk.Coins{sdk.NewCoin("barcoin", 1)}),
NewOutput(addr3, sdk.Coins{sdk.NewCoin("barcoin", 2), sdk.NewCoin("foocoin", 5)}),
NewOutput(addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 1)}),
NewOutput(addr3, sdk.Coins{sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5)}),
}
sendKeeper.InputOutputCoins(ctx, inputs, outputs)
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 21), sdk.NewCoin("foocoin", 4)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 7), sdk.NewCoin("foocoin", 6)}))
require.True(t, sendKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{sdk.NewCoin("barcoin", 2), sdk.NewCoin("foocoin", 5)}))
require.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 21), sdk.NewInt64Coin("foocoin", 4)}))
require.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 7), sdk.NewInt64Coin("foocoin", 6)}))
require.True(t, sendKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{sdk.NewInt64Coin("barcoin", 2), sdk.NewInt64Coin("foocoin", 5)}))
}
@ -198,12 +198,12 @@ func TestViewKeeper(t *testing.T) {
accountMapper.SetAccount(ctx, acc)
require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 10)})
require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewCoin("foocoin", 10)}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)})
require.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
// Test HasCoins
require.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 10)}))
require.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 5)}))
require.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("foocoin", 15)}))
require.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewCoin("barcoin", 5)}))
require.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}))
require.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 5)}))
require.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("foocoin", 15)}))
require.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{sdk.NewInt64Coin("barcoin", 5)}))
}

46
x/bank/msgs_test.go
View File

@ -15,7 +15,7 @@ func TestMsgSendType(t *testing.T) {
// Construct a MsgSend
addr1 := sdk.AccAddress([]byte("input"))
addr2 := sdk.AccAddress([]byte("output"))
coins := sdk.Coins{sdk.NewCoin("atom", 10)}
coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
var msg = MsgSend{
Inputs: []Input{NewInput(addr1, coins)},
Outputs: []Output{NewOutput(addr2, coins)},
@ -28,16 +28,16 @@ func TestMsgSendType(t *testing.T) {
func TestInputValidation(t *testing.T) {
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)}
someCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
multiCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20)}
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)}
minusCoins := sdk.Coins{sdk.NewCoin("eth", -34)}
someMinusCoins := sdk.Coins{sdk.NewCoin("atom", 20), sdk.NewCoin("eth", -34)}
unsortedCoins := sdk.Coins{sdk.NewCoin("eth", 1), sdk.NewCoin("atom", 1)}
emptyCoins2 := sdk.Coins{sdk.NewInt64Coin("eth", 0)}
someEmptyCoins := sdk.Coins{sdk.NewInt64Coin("eth", 10), sdk.NewInt64Coin("atom", 0)}
minusCoins := sdk.Coins{sdk.NewInt64Coin("eth", -34)}
someMinusCoins := sdk.Coins{sdk.NewInt64Coin("atom", 20), sdk.NewInt64Coin("eth", -34)}
unsortedCoins := sdk.Coins{sdk.NewInt64Coin("eth", 1), sdk.NewInt64Coin("atom", 1)}
cases := []struct {
valid bool
@ -70,16 +70,16 @@ func TestInputValidation(t *testing.T) {
func TestOutputValidation(t *testing.T) {
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)}
someCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
multiCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 20)}
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)}
minusCoins := sdk.Coins{sdk.NewCoin("eth", -34)}
someMinusCoins := sdk.Coins{sdk.NewCoin("atom", 20), sdk.NewCoin("eth", -34)}
unsortedCoins := sdk.Coins{sdk.NewCoin("eth", 1), sdk.NewCoin("atom", 1)}
emptyCoins2 := sdk.Coins{sdk.NewInt64Coin("eth", 0)}
someEmptyCoins := sdk.Coins{sdk.NewInt64Coin("eth", 10), sdk.NewInt64Coin("atom", 0)}
minusCoins := sdk.Coins{sdk.NewInt64Coin("eth", -34)}
someMinusCoins := sdk.Coins{sdk.NewInt64Coin("atom", 20), sdk.NewInt64Coin("eth", -34)}
unsortedCoins := sdk.Coins{sdk.NewInt64Coin("eth", 1), sdk.NewInt64Coin("atom", 1)}
cases := []struct {
valid bool
@ -112,10 +112,10 @@ func TestOutputValidation(t *testing.T) {
func TestMsgSendValidation(t *testing.T) {
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)}
atom123eth123 := sdk.Coins{sdk.NewCoin("atom", 123), sdk.NewCoin("eth", 123)}
atom123 := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
atom124 := sdk.Coins{sdk.NewInt64Coin("atom", 124)}
eth123 := sdk.Coins{sdk.NewInt64Coin("eth", 123)}
atom123eth123 := sdk.Coins{sdk.NewInt64Coin("atom", 123), sdk.NewInt64Coin("eth", 123)}
input1 := NewInput(addr1, atom123)
input2 := NewInput(addr1, eth123)
@ -180,7 +180,7 @@ func TestMsgSendValidation(t *testing.T) {
func TestMsgSendGetSignBytes(t *testing.T) {
addr1 := sdk.AccAddress([]byte("input"))
addr2 := sdk.AccAddress([]byte("output"))
coins := sdk.Coins{sdk.NewCoin("atom", 10)}
coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
var msg = MsgSend{
Inputs: []Input{NewInput(addr1, coins)},
Outputs: []Output{NewOutput(addr2, coins)},
@ -213,7 +213,7 @@ func TestMsgSendSigners(t *testing.T) {
{7, 8, 9},
}
someCoins := sdk.Coins{sdk.NewCoin("atom", 123)}
someCoins := sdk.Coins{sdk.NewInt64Coin("atom", 123)}
inputs := make([]Input, len(signers))
for i, signer := range signers {
inputs[i] = NewInput(signer, someCoins)
@ -234,7 +234,7 @@ func TestNewMsgIssue(t *testing.T) {
func TestMsgIssueType(t *testing.T) {
// Construct an MsgIssue
addr := sdk.AccAddress([]byte("loan-from-bank"))
coins := sdk.Coins{sdk.NewCoin("atom", 10)}
coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
var msg = MsgIssue{
Banker: sdk.AccAddress([]byte("input")),
Outputs: []Output{NewOutput(addr, coins)},
@ -250,7 +250,7 @@ func TestMsgIssueValidation(t *testing.T) {
func TestMsgIssueGetSignBytes(t *testing.T) {
addr := sdk.AccAddress([]byte("loan-from-bank"))
coins := sdk.Coins{sdk.NewCoin("atom", 10)}
coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
var msg = MsgIssue{
Banker: sdk.AccAddress([]byte("input")),
Outputs: []Output{NewOutput(addr, coins)},

16
x/gov/endblocker_test.go
View File

@ -19,7 +19,7 @@ func TestTickExpiredDepositPeriod(t *testing.T) {
require.Nil(t, keeper.InactiveProposalQueuePeek(ctx))
require.False(t, shouldPopInactiveProposalQueue(ctx, keeper))
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewCoin("steak", 5)})
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin("steak", 5)})
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())
@ -50,7 +50,7 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
require.Nil(t, keeper.InactiveProposalQueuePeek(ctx))
require.False(t, shouldPopInactiveProposalQueue(ctx, keeper))
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewCoin("steak", 5)})
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin("steak", 5)})
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())
@ -64,7 +64,7 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
require.NotNil(t, keeper.InactiveProposalQueuePeek(ctx))
require.False(t, shouldPopInactiveProposalQueue(ctx, keeper))
newProposalMsg2 := NewMsgSubmitProposal("Test2", "test2", ProposalTypeText, addrs[1], sdk.Coins{sdk.NewCoin("steak", 5)})
newProposalMsg2 := NewMsgSubmitProposal("Test2", "test2", ProposalTypeText, addrs[1], sdk.Coins{sdk.NewInt64Coin("steak", 5)})
res = govHandler(ctx, newProposalMsg2)
require.True(t, res.IsOK())
@ -94,7 +94,7 @@ func TestTickPassedDepositPeriod(t *testing.T) {
require.Nil(t, keeper.ActiveProposalQueuePeek(ctx))
require.False(t, shouldPopActiveProposalQueue(ctx, keeper))
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewCoin("steak", 5)})
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin("steak", 5)})
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())
@ -110,7 +110,7 @@ func TestTickPassedDepositPeriod(t *testing.T) {
require.NotNil(t, keeper.InactiveProposalQueuePeek(ctx))
require.False(t, shouldPopInactiveProposalQueue(ctx, keeper))
newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewCoin("steak", 5)})
newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewInt64Coin("steak", 5)})
res = govHandler(ctx, newDepositMsg)
require.True(t, res.IsOK())
@ -138,7 +138,7 @@ func TestTickPassedVotingPeriod(t *testing.T) {
require.Nil(t, keeper.ActiveProposalQueuePeek(ctx))
require.False(t, shouldPopActiveProposalQueue(ctx, keeper))
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewCoin("steak", 5)})
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin("steak", 5)})
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())
@ -146,7 +146,7 @@ func TestTickPassedVotingPeriod(t *testing.T) {
keeper.cdc.UnmarshalBinaryBare(res.Data, &proposalID)
ctx = ctx.WithBlockHeight(10)
newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewCoin("steak", 5)})
newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewInt64Coin("steak", 5)})
res = govHandler(ctx, newDepositMsg)
require.True(t, res.IsOK())
@ -183,7 +183,7 @@ func TestSlashing(t *testing.T) {
val1Initial := keeper.ds.GetValidatorSet().Validator(ctx, addrs[1]).GetPower().Quo(initTotalPower)
val2Initial := keeper.ds.GetValidatorSet().Validator(ctx, addrs[2]).GetPower().Quo(initTotalPower)
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewCoin("steak", 15)})
newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin("steak", 15)})
res := govHandler(ctx, newProposalMsg)
require.True(t, res.IsOK())

2
x/gov/genesis.go
View File

@ -26,7 +26,7 @@ func DefaultGenesisState() GenesisState {
return GenesisState{
StartingProposalID: 1,
DepositProcedure: DepositProcedure{
MinDeposit: sdk.Coins{sdk.NewCoin("steak", 10)},
MinDeposit: sdk.Coins{sdk.NewInt64Coin("steak", 10)},
MaxDepositPeriod: 200,
},
VotingProcedure: VotingProcedure{

8
x/gov/keeper_test.go
View File

@ -63,14 +63,14 @@ func TestDeposits(t *testing.T) {
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
proposalID := proposal.GetProposalID()
fourSteak := sdk.Coins{sdk.NewCoin("steak", 4)}
fiveSteak := sdk.Coins{sdk.NewCoin("steak", 5)}
fourSteak := sdk.Coins{sdk.NewInt64Coin("steak", 4)}
fiveSteak := sdk.Coins{sdk.NewInt64Coin("steak", 5)}
addr0Initial := keeper.ck.GetCoins(ctx, addrs[0])
addr1Initial := keeper.ck.GetCoins(ctx, addrs[1])
// require.True(t, addr0Initial.IsEqual(sdk.Coins{sdk.NewCoin("steak", 42)}))
require.Equal(t, sdk.Coins{sdk.NewCoin("steak", 42)}, addr0Initial)
// require.True(t, addr0Initial.IsEqual(sdk.Coins{sdk.NewInt64Coin("steak", 42)}))
require.Equal(t, sdk.Coins{sdk.NewInt64Coin("steak", 42)}, addr0Initial)
require.True(t, proposal.GetTotalDeposit().IsEqual(sdk.Coins{}))

8
x/gov/msgs_test.go
View File

@ -10,11 +10,11 @@ import (
)
var (
coinsPos = sdk.Coins{sdk.NewCoin("steak", 1000)}
coinsPos = sdk.Coins{sdk.NewInt64Coin("steak", 1000)}
coinsZero = sdk.Coins{}
coinsNeg = sdk.Coins{sdk.NewCoin("steak", -10000)}
coinsPosNotAtoms = sdk.Coins{sdk.NewCoin("foo", 10000)}
coinsMulti = sdk.Coins{sdk.NewCoin("foo", 10000), sdk.NewCoin("steak", 1000)}
coinsNeg = sdk.Coins{sdk.NewInt64Coin("steak", -10000)}
coinsPosNotAtoms = sdk.Coins{sdk.NewInt64Coin("foo", 10000)}
coinsMulti = sdk.Coins{sdk.NewInt64Coin("foo", 10000), sdk.NewInt64Coin("steak", 1000)}
)
// test ValidateBasic for MsgCreateValidator

25
x/gov/tally_test.go
View File

@ -21,7 +21,7 @@ func createValidators(t *testing.T, stakeHandler sdk.Handler, ctx sdk.Context, a
require.True(t, len(addrs) <= len(pubkeys), "Not enough pubkeys specified at top of file.")
dummyDescription := stake.NewDescription("T", "E", "S", "T")
for i := 0; i < len(addrs); i++ {
valCreateMsg := stake.NewMsgCreateValidator(addrs[i], pubkeys[i], sdk.NewCoin("steak", coinAmt[i]), dummyDescription)
valCreateMsg := stake.NewMsgCreateValidator(addrs[i], pubkeys[i], sdk.NewInt64Coin("steak", coinAmt[i]), dummyDescription)
res := stakeHandler(ctx, valCreateMsg)
require.True(t, res.IsOK())
}
@ -224,7 +224,7 @@ func TestTallyDelgatorOverride(t *testing.T) {
createValidators(t, stakeHandler, ctx, addrs[:3], []int64{5, 6, 7})
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewCoin("steak", 30))
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 30))
stakeHandler(ctx, delegator1Msg)
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@ -254,7 +254,7 @@ func TestTallyDelgatorInherit(t *testing.T) {
createValidators(t, stakeHandler, ctx, addrs[:3], []int64{5, 6, 7})
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewCoin("steak", 30))
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 30))
stakeHandler(ctx, delegator1Msg)
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@ -283,9 +283,9 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
createValidators(t, stakeHandler, ctx, addrs[:3], []int64{5, 6, 7})
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewCoin("steak", 10))
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 10))
stakeHandler(ctx, delegator1Msg)
delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewCoin("steak", 10))
delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewInt64Coin("steak", 10))
stakeHandler(ctx, delegator1Msg2)
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@ -314,16 +314,16 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
stakeHandler := stake.NewHandler(sk)
dummyDescription := stake.NewDescription("T", "E", "S", "T")
val1CreateMsg := stake.NewMsgCreateValidator(addrs[0], ed25519.GenPrivKey().PubKey(), sdk.NewCoin("steak", 25), dummyDescription)
val1CreateMsg := stake.NewMsgCreateValidator(addrs[0], ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 25), dummyDescription)
stakeHandler(ctx, val1CreateMsg)
val2CreateMsg := stake.NewMsgCreateValidator(addrs[1], ed25519.GenPrivKey().PubKey(), sdk.NewCoin("steak", 6), dummyDescription)
val2CreateMsg := stake.NewMsgCreateValidator(addrs[1], ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 6), dummyDescription)
stakeHandler(ctx, val2CreateMsg)
val3CreateMsg := stake.NewMsgCreateValidator(addrs[2], ed25519.GenPrivKey().PubKey(), sdk.NewCoin("steak", 7), dummyDescription)
val3CreateMsg := stake.NewMsgCreateValidator(addrs[2], ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin("steak", 7), dummyDescription)
stakeHandler(ctx, val3CreateMsg)
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewCoin("steak", 10))
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 10))
stakeHandler(ctx, delegator1Msg)
delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewCoin("steak", 10))
delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewInt64Coin("steak", 10))
stakeHandler(ctx, delegator1Msg2)
proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@ -350,10 +350,9 @@ func TestTallyRevokedValidator(t *testing.T) {
stakeHandler := stake.NewHandler(sk)
createValidators(t, stakeHandler, ctx, addrs[:3], []int64{25, 6, 7})
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewCoin("steak", 10))
delegator1Msg := stake.NewMsgDelegate(addrs[3], addrs[2], sdk.NewInt64Coin("steak", 10))
stakeHandler(ctx, delegator1Msg)
delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewCoin("steak", 10))
delegator1Msg2 := stake.NewMsgDelegate(addrs[3], addrs[1], sdk.NewInt64Coin("steak", 10))
stakeHandler(ctx, delegator1Msg2)
val2, found := sk.GetValidator(ctx, addrs[1])

2
x/gov/test_common.go
View File

@ -41,7 +41,7 @@ func getMockApp(t *testing.T, numGenAccs int) (*mock.App, Keeper, stake.Keeper,
mapp.SetEndBlocker(getEndBlocker(keeper))
mapp.SetInitChainer(getInitChainer(mapp, keeper, sk))
genAccs, addrs, pubKeys, privKeys := mock.CreateGenAccounts(numGenAccs, sdk.Coins{sdk.NewCoin("steak", 42)})
genAccs, addrs, pubKeys, privKeys := mock.CreateGenAccounts(numGenAccs, sdk.Coins{sdk.NewInt64Coin("steak", 42)})
mock.SetGenesis(mapp, genAccs)
return mapp, keeper, sk, addrs, pubKeys, privKeys

2
x/ibc/app_test.go
View File

@ -36,7 +36,7 @@ func TestIBCMsgs(t *testing.T) {
priv1 := ed25519.GenPrivKey()
addr1 := sdk.AccAddress(priv1.PubKey().Address())
coins := sdk.Coins{sdk.NewCoin("foocoin", 10)}
coins := sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}
var emptyCoins sdk.Coins
acc := &auth.BaseAccount{

2
x/ibc/ibc_test.go
View File

@ -71,7 +71,7 @@ func TestIBC(t *testing.T) {
dest := newAddress()
chainid := "ibcchain"
zero := sdk.Coins(nil)
mycoins := sdk.Coins{sdk.NewCoin("mycoin", 10)}
mycoins := sdk.Coins{sdk.NewInt64Coin("mycoin", 10)}
coins, _, err := ck.AddCoins(ctx, src, mycoins)
require.Nil(t, err)

2
x/ibc/types_test.go
View File

@ -100,7 +100,7 @@ func TestIBCReceiveMsgValidation(t *testing.T) {
func constructIBCPacket(valid bool) IBCPacket {
srcAddr := sdk.AccAddress([]byte("source"))
destAddr := sdk.AccAddress([]byte("destination"))
coins := sdk.Coins{sdk.NewCoin("atom", 10)}
coins := sdk.Coins{sdk.NewInt64Coin("atom", 10)}
srcChain := "source-chain"
destChain := "dest-chain"

2
x/mock/app.go
View File

@ -130,7 +130,7 @@ func SetGenesis(app *App, accs []auth.Account) {
func GenTx(msgs []sdk.Msg, accnums []int64, seq []int64, priv ...crypto.PrivKey) auth.StdTx {
// Make the transaction free
fee := auth.StdFee{
Amount: sdk.Coins{sdk.NewCoin("foocoin", 0)},
Amount: sdk.Coins{sdk.NewInt64Coin("foocoin", 0)},
Gas: 100000,
}

2
x/mock/app_test.go
View File

@ -13,7 +13,7 @@ const msgType = "testMsg"
var (
numAccts = 2
genCoins = sdk.Coins{sdk.NewCoin("foocoin", 77)}
genCoins = sdk.Coins{sdk.NewInt64Coin("foocoin", 77)}
accs, addrs, pubKeys, privKeys = CreateGenAccounts(numAccts, genCoins)
)

6
x/slashing/app_test.go
View File

@ -17,7 +17,7 @@ import (
var (
priv1 = ed25519.GenPrivKey()
addr1 = sdk.AccAddress(priv1.PubKey().Address())
coins = sdk.Coins{sdk.NewCoin("foocoin", 10)}
coins = sdk.Coins{sdk.NewInt64Coin("foocoin", 10)}
)
// initialize the mock application for this module
@ -89,8 +89,8 @@ func checkValidatorSigningInfo(t *testing.T, mapp *mock.App, keeper Keeper,
func TestSlashingMsgs(t *testing.T) {
mapp, stakeKeeper, keeper := getMockApp(t)
genCoin := sdk.NewCoin("steak", 42)
bondCoin := sdk.NewCoin("steak", 10)
genCoin := sdk.NewInt64Coin("steak", 42)
bondCoin := sdk.NewInt64Coin("steak", 10)
acc1 := &auth.BaseAccount{
Address: addr1,

4
x/stake/app_test.go
View File

@ -108,8 +108,8 @@ func checkDelegation(
func TestStakeMsgs(t *testing.T) {
mApp, keeper := getMockApp(t)
genCoin := sdk.NewCoin("steak", 42)
bondCoin := sdk.NewCoin("steak", 10)
genCoin := sdk.NewInt64Coin("steak", 42)
bondCoin := sdk.NewInt64Coin("steak", 10)
acc1 := &auth.BaseAccount{
Address: addr1,

4
x/stake/keeper/delegation_test.go
View File

@ -116,7 +116,7 @@ func TestUnbondingDelegation(t *testing.T) {
ValidatorAddr: addrVals[0],
CreationHeight: 0,
MinTime: 0,
Balance: sdk.NewCoin("steak", 5),
Balance: sdk.NewInt64Coin("steak", 5),
}
// set and retrieve a record
@ -126,7 +126,7 @@ func TestUnbondingDelegation(t *testing.T) {
require.True(t, ubd.Equal(resBond))
// modify a records, save, and retrieve
ubd.Balance = sdk.NewCoin("steak", 21)
ubd.Balance = sdk.NewInt64Coin("steak", 21)
keeper.SetUnbondingDelegation(ctx, ubd)
resBond, found = keeper.GetUnbondingDelegation(ctx, addrDels[0], addrVals[0])
require.True(t, found)

32
x/stake/keeper/slash_test.go
View File

@ -71,8 +71,8 @@ func TestSlashUnbondingDelegation(t *testing.T) {
CreationHeight: 0,
// expiration timestamp (beyond which the unbonding delegation shouldn't be slashed)
MinTime: 0,
InitialBalance: sdk.NewCoin(params.BondDenom, 10),
Balance: sdk.NewCoin(params.BondDenom, 10),
InitialBalance: sdk.NewInt64Coin(params.BondDenom, 10),
Balance: sdk.NewInt64Coin(params.BondDenom, 10),
}
keeper.SetUnbondingDelegation(ctx, ubd)
@ -95,9 +95,9 @@ func TestSlashUnbondingDelegation(t *testing.T) {
ubd, found := keeper.GetUnbondingDelegation(ctx, addrDels[0], addrVals[0])
require.True(t, found)
// initialbalance unchanged
require.Equal(t, sdk.NewCoin(params.BondDenom, 10), ubd.InitialBalance)
require.Equal(t, sdk.NewInt64Coin(params.BondDenom, 10), ubd.InitialBalance)
// balance decreased
require.Equal(t, sdk.NewCoin(params.BondDenom, 5), ubd.Balance)
require.Equal(t, sdk.NewInt64Coin(params.BondDenom, 5), ubd.Balance)
newPool := keeper.GetPool(ctx)
require.Equal(t, int64(5), oldPool.LooseTokens.Sub(newPool.LooseTokens).RoundInt64())
}
@ -117,8 +117,8 @@ func TestSlashRedelegation(t *testing.T) {
MinTime: 0,
SharesSrc: sdk.NewRat(10),
SharesDst: sdk.NewRat(10),
InitialBalance: sdk.NewCoin(params.BondDenom, 10),
Balance: sdk.NewCoin(params.BondDenom, 10),
InitialBalance: sdk.NewInt64Coin(params.BondDenom, 10),
Balance: sdk.NewInt64Coin(params.BondDenom, 10),
}
keeper.SetRedelegation(ctx, rd)
@ -155,9 +155,9 @@ func TestSlashRedelegation(t *testing.T) {
rd, found = keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
require.True(t, found)
// initialbalance unchanged
require.Equal(t, sdk.NewCoin(params.BondDenom, 10), rd.InitialBalance)
require.Equal(t, sdk.NewInt64Coin(params.BondDenom, 10), rd.InitialBalance)
// balance decreased
require.Equal(t, sdk.NewCoin(params.BondDenom, 5), rd.Balance)
require.Equal(t, sdk.NewInt64Coin(params.BondDenom, 5), rd.Balance)
// shares decreased
del, found = keeper.GetDelegation(ctx, addrDels[0], addrVals[1])
require.True(t, found)
@ -210,8 +210,8 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
CreationHeight: 11,
// expiration timestamp (beyond which the unbonding delegation shouldn't be slashed)
MinTime: 0,
InitialBalance: sdk.NewCoin(params.BondDenom, 4),
Balance: sdk.NewCoin(params.BondDenom, 4),
InitialBalance: sdk.NewInt64Coin(params.BondDenom, 4),
Balance: sdk.NewInt64Coin(params.BondDenom, 4),
}
keeper.SetUnbondingDelegation(ctx, ubd)
@ -313,8 +313,8 @@ func TestSlashWithRedelegation(t *testing.T) {
MinTime: 0,
SharesSrc: sdk.NewRat(6),
SharesDst: sdk.NewRat(6),
InitialBalance: sdk.NewCoin(params.BondDenom, 6),
Balance: sdk.NewCoin(params.BondDenom, 6),
InitialBalance: sdk.NewInt64Coin(params.BondDenom, 6),
Balance: sdk.NewInt64Coin(params.BondDenom, 6),
}
keeper.SetRedelegation(ctx, rd)
@ -435,8 +435,8 @@ func TestSlashBoth(t *testing.T) {
MinTime: 0,
SharesSrc: sdk.NewRat(6),
SharesDst: sdk.NewRat(6),
InitialBalance: sdk.NewCoin(params.BondDenom, 6),
Balance: sdk.NewCoin(params.BondDenom, 6),
InitialBalance: sdk.NewInt64Coin(params.BondDenom, 6),
Balance: sdk.NewInt64Coin(params.BondDenom, 6),
}
keeper.SetRedelegation(ctx, rdA)
@ -455,8 +455,8 @@ func TestSlashBoth(t *testing.T) {
CreationHeight: 11,
// expiration timestamp (beyond which the unbonding delegation shouldn't be slashed)
MinTime: 0,
InitialBalance: sdk.NewCoin(params.BondDenom, 4),
Balance: sdk.NewCoin(params.BondDenom, 4),
InitialBalance: sdk.NewInt64Coin(params.BondDenom, 4),
Balance: sdk.NewInt64Coin(params.BondDenom, 4),
}
keeper.SetUnbondingDelegation(ctx, ubdA)

6
x/stake/simulation/msgs.go
View File

@ -39,7 +39,7 @@ func SimulateMsgCreateValidator(m auth.AccountMapper, k stake.Keeper) simulation
ValidatorAddr: address,
DelegatorAddr: address,
PubKey: pubkey,
Delegation: sdk.NewIntCoin(denom, amount),
Delegation: sdk.NewCoin(denom, amount),
}
require.Nil(t, msg.ValidateBasic(), "expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
ctx, write := ctx.CacheContext()
@ -100,7 +100,7 @@ func SimulateMsgDelegate(m auth.AccountMapper, k stake.Keeper) simulation.TestAn
msg := stake.MsgDelegate{
DelegatorAddr: delegatorAddress,
ValidatorAddr: validatorAddress,
Delegation: sdk.NewIntCoin(denom, amount),
Delegation: sdk.NewCoin(denom, amount),
}
require.Nil(t, msg.ValidateBasic(), "expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
ctx, write := ctx.CacheContext()
@ -241,7 +241,7 @@ func Setup(mapp *mock.App, k stake.Keeper) simulation.RandSetup {
loose := sdk.ZeroInt()
mapp.AccountMapper.IterateAccounts(ctx, func(acc auth.Account) bool {
balance := simulation.RandomAmount(r, sdk.NewInt(1000000))
acc.SetCoins(acc.GetCoins().Plus(sdk.Coins{sdk.NewIntCoin(denom, balance)}))
acc.SetCoins(acc.GetCoins().Plus(sdk.Coins{sdk.NewCoin(denom, balance)}))
mapp.AccountMapper.SetAccount(ctx, acc)
loose = loose.Add(balance)
return false

6
x/stake/types/msg_test.go
View File

@ -10,9 +10,9 @@ import (
)
var (
coinPos = sdk.NewCoin("steak", 1000)
coinZero = sdk.NewCoin("steak", 0)
coinNeg = sdk.NewCoin("steak", -10000)
coinPos = sdk.NewInt64Coin("steak", 1000)
coinZero = sdk.NewInt64Coin("steak", 0)
coinNeg = sdk.NewInt64Coin("steak", -10000)
)
// test ValidateBasic for MsgCreateValidator