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

Swap to panic/recover version

This commit is contained in:
Christopher Goes 2018-05-08 17:34:09 +02:00
parent af379b6cf6
commit 1f8ef62d28
No known key found for this signature in database
GPG Key ID: E828D98232D328D3
3 changed files with 74 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
types/gas.go
View File

@ -5,12 +5,15 @@ import ()
// Gas measured by the SDK // Gas measured by the SDK
type Gas = int64 type Gas = int64
// Error thrown when out of gas
type ErrorOutOfGas struct {
Descriptor string
}
// GasMeter interface to track gas consumption // GasMeter interface to track gas consumption
type GasMeter interface { type GasMeter interface {
GasExceeded() bool
GasConsumed() Gas GasConsumed() Gas
ConsumeGas(amount Gas) ConsumeGas(amount Gas, descriptor string)
ConsumeGasOrFail(amount Gas) bool
} }
type basicGasMeter struct { type basicGasMeter struct {
@ -25,19 +28,13 @@ func NewGasMeter(limit Gas) GasMeter {
} }
} }
func (g *basicGasMeter) GasExceeded() bool {
return g.consumed > g.limit
}
func (g *basicGasMeter) GasConsumed() Gas { func (g *basicGasMeter) GasConsumed() Gas {
return g.consumed return g.consumed
} }
func (g *basicGasMeter) ConsumeGas(amount Gas) { func (g *basicGasMeter) ConsumeGas(amount Gas, descriptor string) {
g.consumed += amount g.consumed += amount
if g.consumed > g.limit {
panic(ErrorOutOfGas{descriptor})
} }
func (g *basicGasMeter) ConsumeGasOrFail(amount Gas) bool {
g.ConsumeGas(amount)
return g.GasExceeded()
} }

40
x/bank/keeper.go
View File

@ -17,7 +17,7 @@ func NewKeeper(am sdk.AccountMapper) Keeper {
} }
// GetCoins returns the coins at the addr. // GetCoins returns the coins at the addr.
func (keeper Keeper) GetCoins(ctx sdk.Context, addr sdk.Address) (sdk.Coins, sdk.Error) { func (keeper Keeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins {
return getCoins(ctx, keeper.am, addr) return getCoins(ctx, keeper.am, addr)
} }
@ -27,7 +27,7 @@ func (keeper Keeper) SetCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins)
} }
// HasCoins returns whether or not an account has at least amt coins. // 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, sdk.Error) { func (keeper Keeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool {
return hasCoins(ctx, keeper.am, addr, amt) return hasCoins(ctx, keeper.am, addr, amt)
} }
@ -64,12 +64,12 @@ func NewSendKeeper(am sdk.AccountMapper) SendKeeper {
} }
// GetCoins returns the coins at the addr. // GetCoins returns the coins at the addr.
func (keeper SendKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) (sdk.Coins, sdk.Error) { func (keeper SendKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins {
return getCoins(ctx, keeper.am, addr) return getCoins(ctx, keeper.am, addr)
} }
// HasCoins returns whether or not an account has at least amt coins. // 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, sdk.Error) { func (keeper SendKeeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool {
return hasCoins(ctx, keeper.am, addr, amt) return hasCoins(ctx, keeper.am, addr, amt)
} }
@ -96,32 +96,28 @@ func NewViewKeeper(am sdk.AccountMapper) ViewKeeper {
} }
// GetCoins returns the coins at the addr. // GetCoins returns the coins at the addr.
func (keeper ViewKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) (sdk.Coins, sdk.Error) { func (keeper ViewKeeper) GetCoins(ctx sdk.Context, addr sdk.Address) sdk.Coins {
return getCoins(ctx, keeper.am, addr) return getCoins(ctx, keeper.am, addr)
} }
// HasCoins returns whether or not an account has at least amt coins. // 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, sdk.Error) { func (keeper ViewKeeper) HasCoins(ctx sdk.Context, addr sdk.Address, amt sdk.Coins) bool {
return hasCoins(ctx, keeper.am, addr, amt) return hasCoins(ctx, keeper.am, addr, amt)
} }
//______________________________________________________________________________________________ //______________________________________________________________________________________________
func getCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address) (sdk.Coins, sdk.Error) { func getCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address) sdk.Coins {
if ctx.GasMeter().ConsumeGasOrFail(10) { ctx.GasMeter().ConsumeGas(10, "getCoins")
return sdk.Coins{}, sdk.ErrOutOfGas("out of gas in getCoins")
}
acc := am.GetAccount(ctx, addr) acc := am.GetAccount(ctx, addr)
if acc == nil { if acc == nil {
return sdk.Coins{}, nil return sdk.Coins{}
} }
return acc.GetCoins(), nil return acc.GetCoins()
} }
func setCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) sdk.Error { func setCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) sdk.Error {
if ctx.GasMeter().ConsumeGasOrFail(100) { ctx.GasMeter().ConsumeGas(100, "setCoins")
return sdk.ErrOutOfGas("out of gas in setCoins")
}
acc := am.GetAccount(ctx, addr) acc := am.GetAccount(ctx, addr)
if acc == nil { if acc == nil {
acc = am.NewAccountWithAddress(ctx, addr) acc = am.NewAccountWithAddress(ctx, addr)
@ -132,19 +128,14 @@ func setCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.C
} }
// HasCoins returns whether or not an account has at least amt coins. // HasCoins returns whether or not an account has at least amt coins.
func hasCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) (bool, sdk.Error) { func hasCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) bool {
if ctx.GasMeter().ConsumeGasOrFail(10) { ctx.GasMeter().ConsumeGas(10, "hasCoins")
return false, sdk.ErrOutOfGas("out of gas in hasCoins") return getCoins(ctx, am, addr).IsGTE(amt)
}
coins, err := getCoins(ctx, am, addr)
if err != nil {
return false, err
}
return coins.IsGTE(amt), nil
} }
// SubtractCoins subtracts amt from the coins at the addr. // SubtractCoins subtracts amt from the coins at the addr.
func subtractCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { func subtractCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) {
ctx.GasMeter().ConsumeGas(10, "subtractCoins")
oldCoins := getCoins(ctx, am, addr) oldCoins := getCoins(ctx, am, addr)
newCoins := oldCoins.Minus(amt) newCoins := oldCoins.Minus(amt)
if !newCoins.IsNotNegative() { if !newCoins.IsNotNegative() {
@ -157,6 +148,7 @@ func subtractCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt
// AddCoins adds amt to the coins at the addr. // AddCoins adds amt to the coins at the addr.
func addCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) { func addCoins(ctx sdk.Context, am sdk.AccountMapper, addr sdk.Address, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error) {
ctx.GasMeter().ConsumeGas(10, "addCoins")
oldCoins := getCoins(ctx, am, addr) oldCoins := getCoins(ctx, am, addr)
newCoins := oldCoins.Plus(amt) newCoins := oldCoins.Plus(amt)
if !newCoins.IsNotNegative() { if !newCoins.IsNotNegative() {

170
x/bank/keeper_test.go
View File

@ -42,79 +42,58 @@ func TestKeeper(t *testing.T) {
// Test GetCoins/SetCoins // Test GetCoins/SetCoins
accountMapper.SetAccount(ctx, acc) accountMapper.SetAccount(ctx, acc)
coins, err := coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
assert.Nil(t, err)
assert.True(t, coins.IsEqual(sdk.Coins{}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}) coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
// Test HasCoins // Test HasCoins
foo, _ := coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}) assert.True(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}))
assert.True(t, foo) assert.True(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}))
foo, _ = coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}) assert.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}}))
assert.True(t, foo) assert.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}}))
foo, _ = coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
assert.False(t, foo)
bar, _ := coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}})
assert.False(t, bar)
// Test AddCoins // Test AddCoins
coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"foocoin", 15}}) coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 25}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 25}}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 15}}) coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 15}})
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 15}, {"foocoin", 25}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 15}, {"foocoin", 25}}))
// Test SubtractCoins // Test SubtractCoins
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}) coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 5}}) coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 5}})
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 15}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 15}}))
_, err = coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 11}}) _, err := coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 11}})
assert.Implements(t, (*sdk.Error)(nil), err) assert.Implements(t, (*sdk.Error)(nil), err)
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 15}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 15}}))
coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 10}}) coinKeeper.SubtractCoins(ctx, addr, sdk.Coins{{"barcoin", 10}})
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 15}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 15}})) assert.False(t, coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 1}}))
bar, _ = coinKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 1}})
assert.False(t, bar)
// Test SendCoins // Test SendCoins
coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 5}}) coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 5}})
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}})) assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"foocoin", 5}}))
coins, err = coinKeeper.GetCoins(ctx, addr2)
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 5}}))
_, err2 := coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 50}}) _, err2 := coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 50}})
assert.Implements(t, (*sdk.Error)(nil), err2) assert.Implements(t, (*sdk.Error)(nil), err2)
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}})) assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"foocoin", 5}}))
coins, err = coinKeeper.GetCoins(ctx, addr2)
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 5}}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 30}}) coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 30}})
coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"barcoin", 10}, {"foocoin", 5}}) coinKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"barcoin", 10}, {"foocoin", 5}})
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 5}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 5}})) assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 10}}))
coins, err = coinKeeper.GetCoins(ctx, addr2)
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 10}}))
// Test InputOutputCoins // Test InputOutputCoins
input1 := NewInput(addr2, sdk.Coins{{"foocoin", 2}}) input1 := NewInput(addr2, sdk.Coins{{"foocoin", 2}})
output1 := NewOutput(addr, sdk.Coins{{"foocoin", 2}}) output1 := NewOutput(addr, sdk.Coins{{"foocoin", 2}})
coinKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1}) coinKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1})
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 7}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 7}})) assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 8}}))
coins, err = coinKeeper.GetCoins(ctx, addr2)
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 8}}))
inputs := []Input{ inputs := []Input{
NewInput(addr, sdk.Coins{{"foocoin", 3}}), NewInput(addr, sdk.Coins{{"foocoin", 3}}),
@ -126,40 +105,12 @@ func TestKeeper(t *testing.T) {
NewOutput(addr3, sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}), NewOutput(addr3, sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}),
} }
coinKeeper.InputOutputCoins(ctx, inputs, outputs) coinKeeper.InputOutputCoins(ctx, inputs, outputs)
coins, err = coinKeeper.GetCoins(ctx, addr) assert.True(t, coinKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 21}, {"foocoin", 4}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 21}, {"foocoin", 4}})) assert.True(t, coinKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 7}, {"foocoin", 6}}))
coins, err = coinKeeper.GetCoins(ctx, addr2) assert.True(t, coinKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 7}, {"foocoin", 6}}))
coins, err = coinKeeper.GetCoins(ctx, addr3)
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}))
} }
func TestKeeperGas(t *testing.T) {
ms, authKey := setupMultiStore()
cdc := wire.NewCodec()
auth.RegisterBaseAccount(cdc)
ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 10)
accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{})
coinKeeper := NewKeeper(accountMapper)
addr := sdk.Address([]byte("addr1"))
acc := accountMapper.NewAccountWithAddress(ctx, addr)
// Test GetCoins/SetCoins
accountMapper.SetAccount(ctx, acc)
coins, err := coinKeeper.GetCoins(ctx, addr)
assert.Nil(t, err)
assert.True(t, coins.IsEqual(sdk.Coins{}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
coins, err = coinKeeper.GetCoins(ctx, addr)
assert.NotNil(t, err)
assert.True(t, coins.IsEqual(sdk.Coins{}))
}
func TestSendKeeper(t *testing.T) { func TestSendKeeper(t *testing.T) {
ms, authKey := setupMultiStore() ms, authKey := setupMultiStore()
@ -178,55 +129,40 @@ func TestSendKeeper(t *testing.T) {
// Test GetCoins/SetCoins // Test GetCoins/SetCoins
accountMapper.SetAccount(ctx, acc) accountMapper.SetAccount(ctx, acc)
coins, err := sendKeeper.GetCoins(ctx, addr) assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
assert.Nil(t, err)
assert.True(t, coins.IsEqual(sdk.Coins{}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}) coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
coins, err = sendKeeper.GetCoins(ctx, addr) assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
// Test HasCoins // Test HasCoins
foo, _ := sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}) assert.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}))
assert.True(t, foo) assert.True(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}))
foo, _ = sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}) assert.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}}))
assert.True(t, foo) assert.False(t, sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}}))
foo, _ = sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
assert.False(t, foo)
bar, _ := sendKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}})
assert.False(t, bar)
coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 15}}) coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
// Test SendCoins // Test SendCoins
sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 5}}) sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 5}})
coins, err = sendKeeper.GetCoins(ctx, addr) assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}})) assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"foocoin", 5}}))
coins, err = sendKeeper.GetCoins(ctx, addr2)
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 5}}))
_, err2 := sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 50}}) _, err2 := sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"foocoin", 50}})
assert.Implements(t, (*sdk.Error)(nil), err2) assert.Implements(t, (*sdk.Error)(nil), err2)
coins, err = sendKeeper.GetCoins(ctx, addr) assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}})) assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"foocoin", 5}}))
coins, err = sendKeeper.GetCoins(ctx, addr2)
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 5}}))
coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 30}}) coinKeeper.AddCoins(ctx, addr, sdk.Coins{{"barcoin", 30}})
sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"barcoin", 10}, {"foocoin", 5}}) sendKeeper.SendCoins(ctx, addr, addr2, sdk.Coins{{"barcoin", 10}, {"foocoin", 5}})
coins, err = sendKeeper.GetCoins(ctx, addr) assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 5}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 5}})) assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 10}}))
coins, err = sendKeeper.GetCoins(ctx, addr2)
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 10}}))
// Test InputOutputCoins // Test InputOutputCoins
input1 := NewInput(addr2, sdk.Coins{{"foocoin", 2}}) input1 := NewInput(addr2, sdk.Coins{{"foocoin", 2}})
output1 := NewOutput(addr, sdk.Coins{{"foocoin", 2}}) output1 := NewOutput(addr, sdk.Coins{{"foocoin", 2}})
sendKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1}) sendKeeper.InputOutputCoins(ctx, []Input{input1}, []Output{output1})
coins, err = sendKeeper.GetCoins(ctx, addr) assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 7}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 20}, {"foocoin", 7}})) assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 8}}))
coins, err = sendKeeper.GetCoins(ctx, addr2)
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 10}, {"foocoin", 8}}))
inputs := []Input{ inputs := []Input{
NewInput(addr, sdk.Coins{{"foocoin", 3}}), NewInput(addr, sdk.Coins{{"foocoin", 3}}),
@ -238,12 +174,9 @@ func TestSendKeeper(t *testing.T) {
NewOutput(addr3, sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}), NewOutput(addr3, sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}),
} }
sendKeeper.InputOutputCoins(ctx, inputs, outputs) sendKeeper.InputOutputCoins(ctx, inputs, outputs)
coins, err = sendKeeper.GetCoins(ctx, addr) assert.True(t, sendKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"barcoin", 21}, {"foocoin", 4}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 21}, {"foocoin", 4}})) assert.True(t, sendKeeper.GetCoins(ctx, addr2).IsEqual(sdk.Coins{{"barcoin", 7}, {"foocoin", 6}}))
coins, err = sendKeeper.GetCoins(ctx, addr2) assert.True(t, sendKeeper.GetCoins(ctx, addr3).IsEqual(sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 7}, {"foocoin", 6}}))
coins, err = sendKeeper.GetCoins(ctx, addr3)
assert.True(t, coins.IsEqual(sdk.Coins{{"barcoin", 2}, {"foocoin", 5}}))
} }
@ -253,7 +186,7 @@ func TestViewKeeper(t *testing.T) {
cdc := wire.NewCodec() cdc := wire.NewCodec()
auth.RegisterBaseAccount(cdc) auth.RegisterBaseAccount(cdc)
ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 100000) ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger(), 10000)
accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{}) accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{})
coinKeeper := NewKeeper(accountMapper) coinKeeper := NewKeeper(accountMapper)
viewKeeper := NewViewKeeper(accountMapper) viewKeeper := NewViewKeeper(accountMapper)
@ -263,21 +196,14 @@ func TestViewKeeper(t *testing.T) {
// Test GetCoins/SetCoins // Test GetCoins/SetCoins
accountMapper.SetAccount(ctx, acc) accountMapper.SetAccount(ctx, acc)
coins, err := viewKeeper.GetCoins(ctx, addr) assert.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{}))
assert.Nil(t, err)
assert.True(t, coins.IsEqual(sdk.Coins{}))
coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}) coinKeeper.SetCoins(ctx, addr, sdk.Coins{{"foocoin", 10}})
coins, err = viewKeeper.GetCoins(ctx, addr) assert.True(t, viewKeeper.GetCoins(ctx, addr).IsEqual(sdk.Coins{{"foocoin", 10}}))
assert.True(t, coins.IsEqual(sdk.Coins{{"foocoin", 10}}))
// Test HasCoins // Test HasCoins
foo, _ := viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}) assert.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 10}}))
assert.True(t, foo) assert.True(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}))
foo, _ = viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 5}}) assert.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}}))
assert.True(t, foo) assert.False(t, viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}}))
foo, _ = viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"foocoin", 15}})
assert.False(t, foo)
bar, _ := viewKeeper.HasCoins(ctx, addr, sdk.Coins{{"barcoin", 5}})
assert.False(t, bar)
} }