2018-03-12 17:40:04 -07:00
|
|
|
package auth
|
|
|
|
|
|
|
|
import (
|
2018-06-20 12:27:36 -07:00
|
|
|
"fmt"
|
2018-03-12 17:40:04 -07:00
|
|
|
"testing"
|
|
|
|
|
|
|
|
"github.com/stretchr/testify/assert"
|
2018-03-17 11:54:18 -07:00
|
|
|
"github.com/stretchr/testify/require"
|
2018-03-12 17:40:04 -07:00
|
|
|
abci "github.com/tendermint/abci/types"
|
|
|
|
crypto "github.com/tendermint/go-crypto"
|
2018-04-23 03:35:09 -07:00
|
|
|
"github.com/tendermint/tmlibs/log"
|
2018-04-07 00:02:00 -07:00
|
|
|
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
wire "github.com/cosmos/cosmos-sdk/wire"
|
2018-03-12 17:40:04 -07:00
|
|
|
)
|
|
|
|
|
2018-03-17 13:53:27 -07:00
|
|
|
func newTestMsg(addrs ...sdk.Address) *sdk.TestMsg {
|
|
|
|
return sdk.NewTestMsg(addrs...)
|
2018-03-12 17:40:04 -07:00
|
|
|
}
|
|
|
|
|
2018-05-23 22:09:01 -07:00
|
|
|
func newStdFee() StdFee {
|
2018-06-20 12:27:36 -07:00
|
|
|
return NewStdFee(5000,
|
2018-06-15 14:16:45 -07:00
|
|
|
sdk.NewCoin("atom", 150),
|
2018-03-17 11:54:18 -07:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
// coins to more than cover the fee
|
|
|
|
func newCoins() sdk.Coins {
|
|
|
|
return sdk.Coins{
|
2018-06-15 14:16:45 -07:00
|
|
|
sdk.NewCoin("atom", 10000000),
|
2018-03-17 11:54:18 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-12 17:40:04 -07:00
|
|
|
// generate a priv key and return it with its address
|
|
|
|
func privAndAddr() (crypto.PrivKey, sdk.Address) {
|
|
|
|
priv := crypto.GenPrivKeyEd25519()
|
|
|
|
addr := priv.PubKey().Address()
|
2018-04-06 17:25:08 -07:00
|
|
|
return priv, addr
|
2018-03-12 17:40:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// run the tx through the anteHandler and ensure its valid
|
|
|
|
func checkValidTx(t *testing.T, anteHandler sdk.AnteHandler, ctx sdk.Context, tx sdk.Tx) {
|
|
|
|
_, result, abort := anteHandler(ctx, tx)
|
|
|
|
assert.False(t, abort)
|
2018-04-17 19:16:21 -07:00
|
|
|
assert.Equal(t, sdk.ABCICodeOK, result.Code)
|
2018-03-12 17:40:04 -07:00
|
|
|
assert.True(t, result.IsOK())
|
|
|
|
}
|
|
|
|
|
|
|
|
// run the tx through the anteHandler and ensure it fails with the given code
|
|
|
|
func checkInvalidTx(t *testing.T, anteHandler sdk.AnteHandler, ctx sdk.Context, tx sdk.Tx, code sdk.CodeType) {
|
2018-06-20 12:27:36 -07:00
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
switch r.(type) {
|
|
|
|
case sdk.ErrorOutOfGas:
|
|
|
|
assert.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, code), sdk.ToABCICode(sdk.CodespaceRoot, sdk.CodeOutOfGas),
|
|
|
|
fmt.Sprintf("Expected ErrorOutOfGas, got %v", r))
|
|
|
|
default:
|
|
|
|
panic(r)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
2018-03-12 17:40:04 -07:00
|
|
|
_, result, abort := anteHandler(ctx, tx)
|
|
|
|
assert.True(t, abort)
|
2018-06-20 12:27:36 -07:00
|
|
|
assert.Equal(t, sdk.ToABCICode(sdk.CodespaceRoot, code), result.Code,
|
|
|
|
fmt.Sprintf("Expected %v, got %v", sdk.ToABCICode(sdk.CodespaceRoot, code), result))
|
2018-03-12 17:40:04 -07:00
|
|
|
}
|
|
|
|
|
2018-06-11 19:30:54 -07:00
|
|
|
func newTestTx(ctx sdk.Context, msg sdk.Msg, privs []crypto.PrivKey, accNums []int64, seqs []int64, fee StdFee) sdk.Tx {
|
2018-06-20 12:27:36 -07:00
|
|
|
signBytes := StdSignBytes(ctx.ChainID(), accNums, seqs, fee, msg, "")
|
|
|
|
return newTestTxWithSignBytes(msg, privs, accNums, seqs, fee, signBytes, "")
|
2018-03-16 17:57:28 -07:00
|
|
|
}
|
|
|
|
|
2018-06-20 12:27:36 -07:00
|
|
|
func newTestTxWithMemo(ctx sdk.Context, msg sdk.Msg, privs []crypto.PrivKey, accNums []int64, seqs []int64, fee StdFee, memo string) sdk.Tx {
|
|
|
|
signBytes := StdSignBytes(ctx.ChainID(), accNums, seqs, fee, msg, memo)
|
|
|
|
return newTestTxWithSignBytes(msg, privs, accNums, seqs, fee, signBytes, memo)
|
|
|
|
}
|
|
|
|
|
|
|
|
func newTestTxWithSignBytes(msg sdk.Msg, privs []crypto.PrivKey, accNums []int64, seqs []int64, fee StdFee, signBytes []byte, memo string) sdk.Tx {
|
2018-05-23 22:09:01 -07:00
|
|
|
sigs := make([]StdSignature, len(privs))
|
2018-03-12 17:40:04 -07:00
|
|
|
for i, priv := range privs {
|
2018-06-11 19:30:54 -07:00
|
|
|
sigs[i] = StdSignature{PubKey: priv.PubKey(), Signature: priv.Sign(signBytes), AccountNumber: accNums[i], Sequence: seqs[i]}
|
2018-03-12 17:40:04 -07:00
|
|
|
}
|
2018-06-20 12:27:36 -07:00
|
|
|
tx := NewStdTx(msg, fee, sigs, memo)
|
2018-03-15 09:37:39 -07:00
|
|
|
return tx
|
2018-03-12 17:40:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Test various error cases in the AnteHandler control flow.
|
|
|
|
func TestAnteHandlerSigErrors(t *testing.T) {
|
|
|
|
// setup
|
2018-05-25 20:29:40 -07:00
|
|
|
ms, capKey, capKey2 := setupMultiStore()
|
2018-04-07 00:02:00 -07:00
|
|
|
cdc := wire.NewCodec()
|
|
|
|
RegisterBaseAccount(cdc)
|
|
|
|
mapper := NewAccountMapper(cdc, capKey, &BaseAccount{})
|
2018-05-25 20:29:40 -07:00
|
|
|
feeCollector := NewFeeCollectionKeeper(cdc, capKey2)
|
|
|
|
anteHandler := NewAnteHandler(mapper, feeCollector)
|
2018-04-23 03:35:09 -07:00
|
|
|
ctx := sdk.NewContext(ms, abci.Header{ChainID: "mychainid"}, false, nil, log.NewNopLogger())
|
2018-03-12 17:40:04 -07:00
|
|
|
|
|
|
|
// keys and addresses
|
|
|
|
priv1, addr1 := privAndAddr()
|
|
|
|
priv2, addr2 := privAndAddr()
|
|
|
|
|
|
|
|
// msg and signatures
|
|
|
|
var tx sdk.Tx
|
|
|
|
msg := newTestMsg(addr1, addr2)
|
2018-03-17 11:54:18 -07:00
|
|
|
fee := newStdFee()
|
2018-03-12 17:40:04 -07:00
|
|
|
|
|
|
|
// test no signatures
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accNums, seqs := []crypto.PrivKey{}, []int64{}, []int64{}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accNums, seqs, fee)
|
2018-03-12 17:40:04 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeUnauthorized)
|
|
|
|
|
|
|
|
// test num sigs dont match GetSigners
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accNums, seqs = []crypto.PrivKey{priv1}, []int64{0}, []int64{0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accNums, seqs, fee)
|
2018-03-12 17:40:04 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeUnauthorized)
|
|
|
|
|
|
|
|
// test an unrecognized account
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accNums, seqs = []crypto.PrivKey{priv1, priv2}, []int64{0, 1}, []int64{0, 0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accNums, seqs, fee)
|
2018-03-17 19:42:54 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeUnknownAddress)
|
2018-03-12 17:40:04 -07:00
|
|
|
|
|
|
|
// save the first account, but second is still unrecognized
|
|
|
|
acc1 := mapper.NewAccountWithAddress(ctx, addr1)
|
2018-03-17 11:54:18 -07:00
|
|
|
acc1.SetCoins(fee.Amount)
|
2018-03-12 17:40:04 -07:00
|
|
|
mapper.SetAccount(ctx, acc1)
|
2018-03-17 19:42:54 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeUnknownAddress)
|
2018-03-12 17:40:04 -07:00
|
|
|
}
|
|
|
|
|
2018-06-11 19:30:54 -07:00
|
|
|
// Test logic around account number checking with one signer and many signers.
|
|
|
|
func TestAnteHandlerAccountNumbers(t *testing.T) {
|
|
|
|
// setup
|
|
|
|
ms, capKey, capKey2 := setupMultiStore()
|
|
|
|
cdc := wire.NewCodec()
|
|
|
|
RegisterBaseAccount(cdc)
|
|
|
|
mapper := NewAccountMapper(cdc, capKey, &BaseAccount{})
|
|
|
|
feeCollector := NewFeeCollectionKeeper(cdc, capKey2)
|
|
|
|
anteHandler := NewAnteHandler(mapper, feeCollector)
|
|
|
|
ctx := sdk.NewContext(ms, abci.Header{ChainID: "mychainid"}, false, nil, log.NewNopLogger())
|
|
|
|
|
|
|
|
// keys and addresses
|
|
|
|
priv1, addr1 := privAndAddr()
|
|
|
|
priv2, addr2 := privAndAddr()
|
|
|
|
|
|
|
|
// set the accounts
|
|
|
|
acc1 := mapper.NewAccountWithAddress(ctx, addr1)
|
|
|
|
acc1.SetCoins(newCoins())
|
|
|
|
mapper.SetAccount(ctx, acc1)
|
|
|
|
acc2 := mapper.NewAccountWithAddress(ctx, addr2)
|
|
|
|
acc2.SetCoins(newCoins())
|
|
|
|
mapper.SetAccount(ctx, acc2)
|
|
|
|
|
|
|
|
// msg and signatures
|
|
|
|
var tx sdk.Tx
|
|
|
|
msg := newTestMsg(addr1)
|
|
|
|
fee := newStdFee()
|
|
|
|
|
|
|
|
// test good tx from one signer
|
|
|
|
privs, accnums, seqs := []crypto.PrivKey{priv1}, []int64{0}, []int64{0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
|
|
|
|
// new tx from wrong account number
|
|
|
|
seqs = []int64{1}
|
|
|
|
tx = newTestTx(ctx, msg, privs, []int64{1}, seqs, fee)
|
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInvalidSequence)
|
|
|
|
|
|
|
|
// from correct account number
|
|
|
|
seqs = []int64{1}
|
|
|
|
tx = newTestTx(ctx, msg, privs, []int64{0}, seqs, fee)
|
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
|
|
|
|
// new tx with another signer and incorrect account numbers
|
|
|
|
msg = newTestMsg(addr1, addr2)
|
|
|
|
privs, accnums, seqs = []crypto.PrivKey{priv1, priv2}, []int64{1, 0}, []int64{2, 0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInvalidSequence)
|
|
|
|
|
|
|
|
// correct account numbers
|
|
|
|
privs, accnums, seqs = []crypto.PrivKey{priv1, priv2}, []int64{0, 1}, []int64{2, 0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
}
|
|
|
|
|
2018-03-12 17:40:04 -07:00
|
|
|
// Test logic around sequence checking with one signer and many signers.
|
|
|
|
func TestAnteHandlerSequences(t *testing.T) {
|
|
|
|
// setup
|
2018-05-25 20:29:40 -07:00
|
|
|
ms, capKey, capKey2 := setupMultiStore()
|
2018-04-07 00:02:00 -07:00
|
|
|
cdc := wire.NewCodec()
|
|
|
|
RegisterBaseAccount(cdc)
|
|
|
|
mapper := NewAccountMapper(cdc, capKey, &BaseAccount{})
|
2018-05-25 20:29:40 -07:00
|
|
|
feeCollector := NewFeeCollectionKeeper(cdc, capKey2)
|
|
|
|
anteHandler := NewAnteHandler(mapper, feeCollector)
|
2018-04-23 03:35:09 -07:00
|
|
|
ctx := sdk.NewContext(ms, abci.Header{ChainID: "mychainid"}, false, nil, log.NewNopLogger())
|
2018-03-12 17:40:04 -07:00
|
|
|
|
|
|
|
// keys and addresses
|
|
|
|
priv1, addr1 := privAndAddr()
|
|
|
|
priv2, addr2 := privAndAddr()
|
|
|
|
|
|
|
|
// set the accounts
|
|
|
|
acc1 := mapper.NewAccountWithAddress(ctx, addr1)
|
2018-03-17 11:54:18 -07:00
|
|
|
acc1.SetCoins(newCoins())
|
2018-03-12 17:40:04 -07:00
|
|
|
mapper.SetAccount(ctx, acc1)
|
|
|
|
acc2 := mapper.NewAccountWithAddress(ctx, addr2)
|
2018-03-17 11:54:18 -07:00
|
|
|
acc2.SetCoins(newCoins())
|
2018-03-12 17:40:04 -07:00
|
|
|
mapper.SetAccount(ctx, acc2)
|
|
|
|
|
|
|
|
// msg and signatures
|
|
|
|
var tx sdk.Tx
|
|
|
|
msg := newTestMsg(addr1)
|
2018-03-17 11:54:18 -07:00
|
|
|
fee := newStdFee()
|
2018-03-12 17:40:04 -07:00
|
|
|
|
|
|
|
// test good tx from one signer
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs := []crypto.PrivKey{priv1}, []int64{0}, []int64{0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-12 17:40:04 -07:00
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
|
|
|
|
// test sending it again fails (replay protection)
|
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInvalidSequence)
|
|
|
|
|
|
|
|
// fix sequence, should pass
|
2018-03-17 11:54:18 -07:00
|
|
|
seqs = []int64{1}
|
2018-06-11 19:30:54 -07:00
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-12 17:40:04 -07:00
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
|
|
|
|
// new tx with another signer and correct sequences
|
|
|
|
msg = newTestMsg(addr1, addr2)
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs = []crypto.PrivKey{priv1, priv2}, []int64{0, 1}, []int64{2, 0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-12 17:40:04 -07:00
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
|
|
|
|
// replay fails
|
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInvalidSequence)
|
|
|
|
|
|
|
|
// tx from just second signer with incorrect sequence fails
|
|
|
|
msg = newTestMsg(addr2)
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs = []crypto.PrivKey{priv2}, []int64{1}, []int64{0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-12 17:40:04 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInvalidSequence)
|
|
|
|
|
|
|
|
// fix the sequence and it passes
|
2018-06-11 19:30:54 -07:00
|
|
|
tx = newTestTx(ctx, msg, []crypto.PrivKey{priv2}, []int64{1}, []int64{1}, fee)
|
2018-03-12 17:40:04 -07:00
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
|
|
|
|
// another tx from both of them that passes
|
|
|
|
msg = newTestMsg(addr1, addr2)
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs = []crypto.PrivKey{priv1, priv2}, []int64{0, 1}, []int64{3, 2}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-12 17:40:04 -07:00
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
}
|
|
|
|
|
2018-03-15 09:37:39 -07:00
|
|
|
// Test logic around fee deduction.
|
|
|
|
func TestAnteHandlerFees(t *testing.T) {
|
2018-03-17 13:20:24 -07:00
|
|
|
// setup
|
2018-05-25 20:29:40 -07:00
|
|
|
ms, capKey, capKey2 := setupMultiStore()
|
2018-04-07 00:02:00 -07:00
|
|
|
cdc := wire.NewCodec()
|
|
|
|
RegisterBaseAccount(cdc)
|
|
|
|
mapper := NewAccountMapper(cdc, capKey, &BaseAccount{})
|
2018-05-25 20:29:40 -07:00
|
|
|
feeCollector := NewFeeCollectionKeeper(cdc, capKey2)
|
|
|
|
anteHandler := NewAnteHandler(mapper, feeCollector)
|
2018-04-23 03:35:09 -07:00
|
|
|
ctx := sdk.NewContext(ms, abci.Header{ChainID: "mychainid"}, false, nil, log.NewNopLogger())
|
2018-03-17 13:20:24 -07:00
|
|
|
|
|
|
|
// keys and addresses
|
|
|
|
priv1, addr1 := privAndAddr()
|
|
|
|
|
|
|
|
// set the accounts
|
|
|
|
acc1 := mapper.NewAccountWithAddress(ctx, addr1)
|
|
|
|
mapper.SetAccount(ctx, acc1)
|
|
|
|
|
|
|
|
// msg and signatures
|
|
|
|
var tx sdk.Tx
|
|
|
|
msg := newTestMsg(addr1)
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs := []crypto.PrivKey{priv1}, []int64{0}, []int64{0}
|
2018-06-20 12:27:36 -07:00
|
|
|
fee := newStdFee()
|
2018-03-17 13:20:24 -07:00
|
|
|
|
|
|
|
// signer does not have enough funds to pay the fee
|
2018-06-11 19:30:54 -07:00
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-17 13:20:24 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInsufficientFunds)
|
|
|
|
|
2018-06-15 14:16:45 -07:00
|
|
|
acc1.SetCoins(sdk.Coins{sdk.NewCoin("atom", 149)})
|
2018-03-17 13:20:24 -07:00
|
|
|
mapper.SetAccount(ctx, acc1)
|
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInsufficientFunds)
|
|
|
|
|
2018-05-25 21:10:09 -07:00
|
|
|
assert.True(t, feeCollector.GetCollectedFees(ctx).IsEqual(emptyCoins))
|
|
|
|
|
2018-06-15 14:16:45 -07:00
|
|
|
acc1.SetCoins(sdk.Coins{sdk.NewCoin("atom", 150)})
|
2018-03-17 13:20:24 -07:00
|
|
|
mapper.SetAccount(ctx, acc1)
|
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
2018-05-25 21:10:09 -07:00
|
|
|
|
2018-06-15 14:16:45 -07:00
|
|
|
assert.True(t, feeCollector.GetCollectedFees(ctx).IsEqual(sdk.Coins{sdk.NewCoin("atom", 150)}))
|
2018-03-15 09:37:39 -07:00
|
|
|
}
|
|
|
|
|
2018-06-20 12:27:36 -07:00
|
|
|
// Test logic around memo gas consumption.
|
|
|
|
func TestAnteHandlerMemoGas(t *testing.T) {
|
|
|
|
// setup
|
|
|
|
ms, capKey, capKey2 := setupMultiStore()
|
|
|
|
cdc := wire.NewCodec()
|
|
|
|
RegisterBaseAccount(cdc)
|
|
|
|
mapper := NewAccountMapper(cdc, capKey, &BaseAccount{})
|
|
|
|
feeCollector := NewFeeCollectionKeeper(cdc, capKey2)
|
|
|
|
anteHandler := NewAnteHandler(mapper, feeCollector)
|
|
|
|
ctx := sdk.NewContext(ms, abci.Header{ChainID: "mychainid"}, false, nil, log.NewNopLogger())
|
|
|
|
|
|
|
|
// keys and addresses
|
|
|
|
priv1, addr1 := privAndAddr()
|
|
|
|
|
|
|
|
// set the accounts
|
|
|
|
acc1 := mapper.NewAccountWithAddress(ctx, addr1)
|
|
|
|
mapper.SetAccount(ctx, acc1)
|
|
|
|
|
|
|
|
// msg and signatures
|
|
|
|
var tx sdk.Tx
|
|
|
|
msg := newTestMsg(addr1)
|
|
|
|
privs, accnums, seqs := []crypto.PrivKey{priv1}, []int64{0}, []int64{0}
|
|
|
|
fee := NewStdFee(0, sdk.NewCoin("atom", 0))
|
|
|
|
|
|
|
|
// tx does not have enough gas
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeOutOfGas)
|
|
|
|
|
|
|
|
// tx with memo doesn't have enough gas
|
|
|
|
fee = NewStdFee(1001, sdk.NewCoin("atom", 0))
|
|
|
|
tx = newTestTxWithMemo(ctx, msg, privs, accnums, seqs, fee, "abcininasidniandsinasindiansdiansdinaisndiasndiadninsd")
|
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeOutOfGas)
|
|
|
|
|
|
|
|
// memo too large
|
|
|
|
fee = NewStdFee(2001, sdk.NewCoin("atom", 0))
|
|
|
|
tx = newTestTxWithMemo(ctx, 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))
|
|
|
|
tx = newTestTxWithMemo(ctx, msg, privs, accnums, seqs, fee, "abcininasidniandsinasindiansdiansdinaisndiasndiadninsd")
|
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
}
|
|
|
|
|
2018-03-12 17:40:04 -07:00
|
|
|
func TestAnteHandlerBadSignBytes(t *testing.T) {
|
2018-03-16 17:57:28 -07:00
|
|
|
// setup
|
2018-05-25 20:29:40 -07:00
|
|
|
ms, capKey, capKey2 := setupMultiStore()
|
2018-04-07 00:02:00 -07:00
|
|
|
cdc := wire.NewCodec()
|
|
|
|
RegisterBaseAccount(cdc)
|
|
|
|
mapper := NewAccountMapper(cdc, capKey, &BaseAccount{})
|
2018-05-25 20:29:40 -07:00
|
|
|
feeCollector := NewFeeCollectionKeeper(cdc, capKey2)
|
|
|
|
anteHandler := NewAnteHandler(mapper, feeCollector)
|
2018-04-23 03:35:09 -07:00
|
|
|
ctx := sdk.NewContext(ms, abci.Header{ChainID: "mychainid"}, false, nil, log.NewNopLogger())
|
2018-03-16 17:57:28 -07:00
|
|
|
|
|
|
|
// keys and addresses
|
|
|
|
priv1, addr1 := privAndAddr()
|
|
|
|
priv2, addr2 := privAndAddr()
|
|
|
|
|
|
|
|
// set the accounts
|
|
|
|
acc1 := mapper.NewAccountWithAddress(ctx, addr1)
|
2018-03-17 11:54:18 -07:00
|
|
|
acc1.SetCoins(newCoins())
|
2018-03-16 17:57:28 -07:00
|
|
|
mapper.SetAccount(ctx, acc1)
|
|
|
|
acc2 := mapper.NewAccountWithAddress(ctx, addr2)
|
2018-03-17 11:54:18 -07:00
|
|
|
acc2.SetCoins(newCoins())
|
2018-03-16 17:57:28 -07:00
|
|
|
mapper.SetAccount(ctx, acc2)
|
|
|
|
|
|
|
|
var tx sdk.Tx
|
2018-03-17 11:54:18 -07:00
|
|
|
msg := newTestMsg(addr1)
|
|
|
|
fee := newStdFee()
|
2018-03-17 13:53:27 -07:00
|
|
|
fee2 := newStdFee()
|
|
|
|
fee2.Gas += 100
|
|
|
|
fee3 := newStdFee()
|
2018-06-15 14:16:45 -07:00
|
|
|
fee3.Amount[0].Amount = fee3.Amount[0].Amount.AddRaw(100)
|
2018-03-16 17:57:28 -07:00
|
|
|
|
|
|
|
// test good tx and signBytes
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs := []crypto.PrivKey{priv1}, []int64{0}, []int64{0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-16 17:57:28 -07:00
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
|
2018-03-17 11:54:18 -07:00
|
|
|
chainID := ctx.ChainID()
|
2018-03-17 13:53:27 -07:00
|
|
|
chainID2 := chainID + "somemorestuff"
|
2018-03-17 11:54:18 -07:00
|
|
|
codeUnauth := sdk.CodeUnauthorized
|
|
|
|
|
|
|
|
cases := []struct {
|
|
|
|
chainID string
|
2018-06-11 19:30:54 -07:00
|
|
|
accnums []int64
|
2018-03-17 11:54:18 -07:00
|
|
|
seqs []int64
|
2018-05-23 22:09:01 -07:00
|
|
|
fee StdFee
|
2018-03-17 11:54:18 -07:00
|
|
|
msg sdk.Msg
|
|
|
|
code sdk.CodeType
|
|
|
|
}{
|
2018-06-11 19:30:54 -07:00
|
|
|
{chainID2, []int64{0}, []int64{1}, fee, msg, codeUnauth}, // test wrong chain_id
|
|
|
|
{chainID, []int64{0}, []int64{2}, fee, msg, codeUnauth}, // test wrong seqs
|
|
|
|
{chainID, []int64{0}, []int64{1, 2}, fee, msg, codeUnauth}, // test wrong seqs
|
|
|
|
{chainID, []int64{1}, []int64{1}, fee, msg, codeUnauth}, // test wrong accnum
|
|
|
|
{chainID, []int64{0}, []int64{1}, fee, newTestMsg(addr2), codeUnauth}, // test wrong msg
|
|
|
|
{chainID, []int64{0}, []int64{1}, fee2, msg, codeUnauth}, // test wrong fee
|
|
|
|
{chainID, []int64{0}, []int64{1}, fee3, msg, codeUnauth}, // test wrong fee
|
2018-03-17 11:54:18 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
privs, seqs = []crypto.PrivKey{priv1}, []int64{1}
|
|
|
|
for _, cs := range cases {
|
|
|
|
tx := newTestTxWithSignBytes(
|
2018-06-11 19:30:54 -07:00
|
|
|
msg, privs, accnums, seqs, fee,
|
2018-06-20 12:27:36 -07:00
|
|
|
StdSignBytes(cs.chainID, cs.accnums, cs.seqs, cs.fee, cs.msg, ""),
|
|
|
|
"",
|
2018-03-17 11:54:18 -07:00
|
|
|
)
|
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, cs.code)
|
|
|
|
}
|
2018-03-16 17:57:28 -07:00
|
|
|
|
|
|
|
// test wrong signer if public key exist
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs = []crypto.PrivKey{priv2}, []int64{0}, []int64{1}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-16 17:57:28 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeUnauthorized)
|
|
|
|
|
|
|
|
// test wrong signer if public doesn't exist
|
|
|
|
msg = newTestMsg(addr2)
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs = []crypto.PrivKey{priv1}, []int64{1}, []int64{0}
|
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-17 11:54:18 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInvalidPubKey)
|
2018-03-16 17:57:28 -07:00
|
|
|
|
2018-03-12 17:40:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestAnteHandlerSetPubKey(t *testing.T) {
|
2018-03-16 17:57:28 -07:00
|
|
|
// setup
|
2018-05-25 20:29:40 -07:00
|
|
|
ms, capKey, capKey2 := setupMultiStore()
|
2018-04-07 00:02:00 -07:00
|
|
|
cdc := wire.NewCodec()
|
|
|
|
RegisterBaseAccount(cdc)
|
|
|
|
mapper := NewAccountMapper(cdc, capKey, &BaseAccount{})
|
2018-05-25 20:29:40 -07:00
|
|
|
feeCollector := NewFeeCollectionKeeper(cdc, capKey2)
|
|
|
|
anteHandler := NewAnteHandler(mapper, feeCollector)
|
2018-04-23 03:35:09 -07:00
|
|
|
ctx := sdk.NewContext(ms, abci.Header{ChainID: "mychainid"}, false, nil, log.NewNopLogger())
|
2018-03-16 17:57:28 -07:00
|
|
|
|
|
|
|
// keys and addresses
|
|
|
|
priv1, addr1 := privAndAddr()
|
|
|
|
_, addr2 := privAndAddr()
|
|
|
|
|
|
|
|
// set the accounts
|
|
|
|
acc1 := mapper.NewAccountWithAddress(ctx, addr1)
|
2018-03-17 11:54:18 -07:00
|
|
|
acc1.SetCoins(newCoins())
|
2018-03-16 17:57:28 -07:00
|
|
|
mapper.SetAccount(ctx, acc1)
|
|
|
|
acc2 := mapper.NewAccountWithAddress(ctx, addr2)
|
2018-03-17 11:54:18 -07:00
|
|
|
acc2.SetCoins(newCoins())
|
2018-03-16 17:57:28 -07:00
|
|
|
mapper.SetAccount(ctx, acc2)
|
|
|
|
|
|
|
|
var tx sdk.Tx
|
|
|
|
|
|
|
|
// test good tx and set public key
|
|
|
|
msg := newTestMsg(addr1)
|
2018-06-11 19:30:54 -07:00
|
|
|
privs, accnums, seqs := []crypto.PrivKey{priv1}, []int64{0}, []int64{0}
|
2018-03-17 11:54:18 -07:00
|
|
|
fee := newStdFee()
|
2018-06-11 19:30:54 -07:00
|
|
|
tx = newTestTx(ctx, msg, privs, accnums, seqs, fee)
|
2018-03-16 17:57:28 -07:00
|
|
|
checkValidTx(t, anteHandler, ctx, tx)
|
|
|
|
|
|
|
|
acc1 = mapper.GetAccount(ctx, addr1)
|
2018-03-17 11:54:18 -07:00
|
|
|
require.Equal(t, acc1.GetPubKey(), priv1.PubKey())
|
2018-03-16 17:57:28 -07:00
|
|
|
|
|
|
|
// test public key not found
|
|
|
|
msg = newTestMsg(addr2)
|
2018-06-11 19:30:54 -07:00
|
|
|
tx = newTestTx(ctx, msg, privs, []int64{1}, seqs, fee)
|
2018-05-23 22:09:01 -07:00
|
|
|
sigs := tx.(StdTx).GetSignatures()
|
2018-04-06 17:25:08 -07:00
|
|
|
sigs[0].PubKey = nil
|
2018-03-17 11:54:18 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInvalidPubKey)
|
2018-03-16 17:57:28 -07:00
|
|
|
|
|
|
|
acc2 = mapper.GetAccount(ctx, addr2)
|
2018-04-06 17:25:08 -07:00
|
|
|
assert.Nil(t, acc2.GetPubKey())
|
2018-03-16 17:57:28 -07:00
|
|
|
|
|
|
|
// test invalid signature and public key
|
2018-06-11 19:30:54 -07:00
|
|
|
tx = newTestTx(ctx, msg, privs, []int64{1}, seqs, fee)
|
2018-03-17 11:54:18 -07:00
|
|
|
checkInvalidTx(t, anteHandler, ctx, tx, sdk.CodeInvalidPubKey)
|
2018-03-16 17:57:28 -07:00
|
|
|
|
|
|
|
acc2 = mapper.GetAccount(ctx, addr2)
|
2018-04-06 17:25:08 -07:00
|
|
|
assert.Nil(t, acc2.GetPubKey())
|
2018-03-12 17:40:04 -07:00
|
|
|
}
|