2018-03-12 17:40:04 -07:00
package auth
import (
2018-06-20 12:27:36 -07:00
"fmt"
2019-01-16 09:30:57 -08:00
"math/rand"
2018-12-10 02:48:19 -08:00
"strings"
2018-03-12 17:40:04 -07:00
"testing"
2018-03-17 11:54:18 -07:00
"github.com/stretchr/testify/require"
2018-06-28 17:54:47 -07:00
"github.com/tendermint/tendermint/crypto"
2018-07-25 13:43:37 -07:00
"github.com/tendermint/tendermint/crypto/ed25519"
2018-11-15 06:30:24 -08:00
"github.com/tendermint/tendermint/crypto/multisig"
2018-08-31 10:04:11 -07:00
"github.com/tendermint/tendermint/crypto/secp256k1"
2018-12-10 06:27:25 -08:00
sdk "github.com/cosmos/cosmos-sdk/types"
2019-06-05 16:26:17 -07:00
"github.com/cosmos/cosmos-sdk/x/auth/types"
2018-03-12 17:40:04 -07:00
)
// run the tx through the anteHandler and ensure its valid
2018-08-25 12:12:14 -07:00
func checkValidTx ( t * testing . T , anteHandler sdk . AnteHandler , ctx sdk . Context , tx sdk . Tx , simulate bool ) {
_ , result , abort := anteHandler ( ctx , tx , simulate )
2019-06-28 13:11:27 -07:00
require . Equal ( t , "" , result . Log )
2018-06-29 18:10:15 -07:00
require . False ( t , abort )
2018-11-16 09:12:24 -08:00
require . Equal ( t , sdk . CodeOK , result . Code )
2018-06-29 18:10:15 -07:00
require . True ( t , result . IsOK ( ) )
2018-03-12 17:40:04 -07:00
}
// run the tx through the anteHandler and ensure it fails with the given code
2018-08-25 12:12:14 -07:00
func checkInvalidTx ( t * testing . T , anteHandler sdk . AnteHandler , ctx sdk . Context , tx sdk . Tx , simulate bool , code sdk . CodeType ) {
newCtx , result , abort := anteHandler ( ctx , tx , simulate )
2018-06-29 18:10:15 -07:00
require . True ( t , abort )
2018-11-16 09:12:24 -08:00
require . Equal ( t , code , result . Code , fmt . Sprintf ( "Expected %v, got %v" , code , result ) )
require . Equal ( t , sdk . CodespaceRoot , result . Codespace )
2018-07-13 10:53:12 -07:00
if code == sdk . CodeOutOfGas {
2019-06-05 16:26:17 -07:00
stdTx , ok := tx . ( types . StdTx )
require . True ( t , ok , "tx must be in form auth.types.StdTx" )
2018-07-13 10:53:12 -07:00
// GasWanted set correctly
require . Equal ( t , stdTx . Fee . Gas , result . GasWanted , "Gas wanted not set correctly" )
require . True ( t , result . GasUsed > result . GasWanted , "GasUsed not greated than GasWanted" )
// Check that context is set correctly
require . Equal ( t , result . GasUsed , newCtx . GasMeter ( ) . GasConsumed ( ) , "Context not updated correctly" )
}
2018-03-12 17:40:04 -07:00
}
// Test various error cases in the AnteHandler control flow.
func TestAnteHandlerSigErrors ( t * testing . T ) {
// setup
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
ctx := input . ctx
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-03-12 17:40:04 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
priv2 , _ , addr2 := types . KeyTestPubAddr ( )
priv3 , _ , addr3 := types . KeyTestPubAddr ( )
2018-03-12 17:40:04 -07:00
// msg and signatures
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg1 := types . NewTestMsg ( addr1 , addr2 )
msg2 := types . NewTestMsg ( addr1 , addr3 )
fee := types . NewTestStdFee ( )
2018-03-12 17:40:04 -07:00
2018-06-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg1 , msg2 }
2018-03-12 17:40:04 -07:00
// test no signatures
2018-11-26 03:29:21 -08:00
privs , accNums , seqs := [ ] crypto . PrivKey { } , [ ] uint64 { } , [ ] uint64 { }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accNums , seqs , fee )
2018-06-21 15:05:25 -07:00
// tx.GetSigners returns addresses in correct order: addr1, addr2, addr3
2018-07-06 00:06:53 -07:00
expectedSigners := [ ] sdk . AccAddress { addr1 , addr2 , addr3 }
2019-06-05 16:26:17 -07:00
stdTx := tx . ( types . StdTx )
2018-06-29 18:10:15 -07:00
require . Equal ( t , expectedSigners , stdTx . GetSigners ( ) )
2018-06-21 15:05:25 -07:00
// Check no signatures fails
2019-01-02 02:05:56 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeNoSignatures )
2018-03-12 17:40:04 -07:00
// test num sigs dont match GetSigners
2018-11-26 03:29:21 -08:00
privs , accNums , seqs = [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accNums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-03-12 17:40:04 -07:00
// test an unrecognized account
2018-11-26 03:29:21 -08:00
privs , accNums , seqs = [ ] crypto . PrivKey { priv1 , priv2 , priv3 } , [ ] uint64 { 0 , 1 , 2 } , [ ] uint64 { 0 , 0 , 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accNums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnknownAddress )
2018-03-12 17:40:04 -07:00
// save the first account, but second is still unrecognized
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2018-03-17 11:54:18 -07:00
acc1 . SetCoins ( fee . Amount )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , 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
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-12-20 11:09:43 -08:00
ctx := input . ctx . WithBlockHeight ( 1 )
2018-06-11 19:30:54 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
priv2 , _ , addr2 := types . KeyTestPubAddr ( )
2018-06-11 19:30:54 -07:00
// set the accounts
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2019-06-10 02:57:38 -07:00
acc1 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc1 . SetAccountNumber ( 0 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2019-06-10 02:57:38 -07:00
acc2 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc2 . SetAccountNumber ( 1 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc2 )
2018-06-11 19:30:54 -07:00
// msg and signatures
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 )
fee := types . NewTestStdFee ( )
2018-06-11 19:30:54 -07:00
2018-06-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg }
2018-06-11 19:30:54 -07:00
// test good tx from one signer
2018-11-26 03:29:21 -08:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-06-11 19:30:54 -07:00
// new tx from wrong account number
2018-11-26 03:29:21 -08:00
seqs = [ ] uint64 { 1 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , [ ] uint64 { 1 } , seqs , fee )
2018-12-03 09:29:50 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-06-11 19:30:54 -07:00
// from correct account number
2018-11-26 03:29:21 -08:00
seqs = [ ] uint64 { 1 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , [ ] uint64 { 0 } , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-06-11 19:30:54 -07:00
// new tx with another signer and incorrect account numbers
2019-06-10 02:57:38 -07:00
msg1 := types . NewTestMsg ( addr1 , addr2 )
msg2 := types . NewTestMsg ( addr2 , addr1 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg1 , msg2 }
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] uint64 { 1 , 0 } , [ ] uint64 { 2 , 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-12-03 09:29:50 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-06-11 19:30:54 -07:00
// correct account numbers
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] uint64 { 0 , 1 } , [ ] uint64 { 2 , 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-06-11 19:30:54 -07:00
}
2018-10-19 11:00:27 -07:00
// Test logic around account number checking with many signers when BlockHeight is 0.
func TestAnteHandlerAccountNumbersAtBlockHeightZero ( t * testing . T ) {
// setup
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-12-20 11:09:43 -08:00
ctx := input . ctx . WithBlockHeight ( 0 )
2018-10-19 11:00:27 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
priv2 , _ , addr2 := types . KeyTestPubAddr ( )
2018-10-19 11:00:27 -07:00
2019-06-28 13:11:27 -07:00
// set the accounts, we don't need the acc numbers as it is in the genesis block
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2019-06-10 02:57:38 -07:00
acc1 . SetCoins ( types . NewTestCoins ( ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2019-06-10 02:57:38 -07:00
acc2 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc2 . SetAccountNumber ( 1 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc2 )
2018-10-19 11:00:27 -07:00
// msg and signatures
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 )
fee := types . NewTestStdFee ( )
2018-10-19 11:00:27 -07:00
msgs := [ ] sdk . Msg { msg }
// test good tx from one signer
2018-11-26 03:29:21 -08:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-10-19 11:00:27 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
// new tx from wrong account number
2018-11-26 03:29:21 -08:00
seqs = [ ] uint64 { 1 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , [ ] uint64 { 1 } , seqs , fee )
2018-12-03 09:29:50 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-10-19 11:00:27 -07:00
// from correct account number
2018-11-26 03:29:21 -08:00
seqs = [ ] uint64 { 1 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , [ ] uint64 { 0 } , seqs , fee )
2018-10-19 11:00:27 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
// new tx with another signer and incorrect account numbers
2019-06-10 02:57:38 -07:00
msg1 := types . NewTestMsg ( addr1 , addr2 )
msg2 := types . NewTestMsg ( addr2 , addr1 )
2018-10-19 11:00:27 -07:00
msgs = [ ] sdk . Msg { msg1 , msg2 }
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] uint64 { 1 , 0 } , [ ] uint64 { 2 , 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-12-03 09:29:50 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-10-19 11:00:27 -07:00
// correct account numbers
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] uint64 { 0 , 0 } , [ ] uint64 { 2 , 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-10-19 11:00:27 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
}
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-12-20 11:09:43 -08:00
input := setupTestInput ( )
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-12-20 11:09:43 -08:00
ctx := input . ctx . WithBlockHeight ( 1 )
2018-03-12 17:40:04 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
priv2 , _ , addr2 := types . KeyTestPubAddr ( )
priv3 , _ , addr3 := types . KeyTestPubAddr ( )
2018-03-12 17:40:04 -07:00
// set the accounts
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2019-06-10 02:57:38 -07:00
acc1 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc1 . SetAccountNumber ( 0 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2019-06-10 02:57:38 -07:00
acc2 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc2 . SetAccountNumber ( 1 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc2 )
acc3 := input . ak . NewAccountWithAddress ( ctx , addr3 )
2019-06-10 02:57:38 -07:00
acc3 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc3 . SetAccountNumber ( 2 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc3 )
2018-03-12 17:40:04 -07:00
// msg and signatures
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 )
fee := types . NewTestStdFee ( )
2018-03-12 17:40:04 -07:00
2018-06-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg }
2018-03-12 17:40:04 -07:00
// test good tx from one signer
2018-11-26 03:29:21 -08:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-03-12 17:40:04 -07:00
// test sending it again fails (replay protection)
2018-12-03 09:29:50 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-03-12 17:40:04 -07:00
// fix sequence, should pass
2018-11-26 03:29:21 -08:00
seqs = [ ] uint64 { 1 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-03-12 17:40:04 -07:00
// new tx with another signer and correct sequences
2019-06-10 02:57:38 -07:00
msg1 := types . NewTestMsg ( addr1 , addr2 )
msg2 := types . NewTestMsg ( addr3 , addr1 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg1 , msg2 }
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 , priv3 } , [ ] uint64 { 0 , 1 , 2 } , [ ] uint64 { 2 , 0 , 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-03-12 17:40:04 -07:00
// replay fails
2018-12-03 09:29:50 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-03-12 17:40:04 -07:00
// tx from just second signer with incorrect sequence fails
2019-06-10 02:57:38 -07:00
msg = types . NewTestMsg ( addr2 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg }
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv2 } , [ ] uint64 { 1 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-12-03 09:29:50 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-03-12 17:40:04 -07:00
// fix the sequence and it passes
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , [ ] crypto . PrivKey { priv2 } , [ ] uint64 { 1 } , [ ] uint64 { 1 } , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-03-12 17:40:04 -07:00
// another tx from both of them that passes
2019-06-10 02:57:38 -07:00
msg = types . NewTestMsg ( addr1 , addr2 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg }
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] uint64 { 0 , 1 } , [ ] uint64 { 3 , 2 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-03-12 17:40:04 -07:00
}
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-12-20 11:09:43 -08:00
input := setupTestInput ( )
ctx := input . ctx
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-03-17 13:20:24 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
2018-03-17 13:20:24 -07:00
// set the accounts
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
input . ak . SetAccount ( ctx , acc1 )
2018-03-17 13:20:24 -07:00
// msg and signatures
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 )
2018-11-26 03:29:21 -08:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
fee := types . NewTestStdFee ( )
2018-06-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg }
2018-03-17 13:20:24 -07:00
// signer does not have enough funds to pay the fee
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInsufficientFunds )
2018-03-17 13:20:24 -07:00
2019-03-07 16:55:08 -08:00
acc1 . SetCoins ( sdk . NewCoins ( sdk . NewInt64Coin ( "atom" , 149 ) ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInsufficientFunds )
2018-03-17 13:20:24 -07:00
2019-06-28 13:11:27 -07:00
require . True ( t , input . sk . GetModuleAccount ( ctx , types . FeeCollectorName ) . GetCoins ( ) . Empty ( ) )
require . True ( sdk . IntEq ( t , input . ak . GetAccount ( ctx , addr1 ) . GetCoins ( ) . AmountOf ( "atom" ) , sdk . NewInt ( 149 ) ) )
2018-05-25 21:10:09 -07:00
2019-03-07 16:55:08 -08:00
acc1 . SetCoins ( sdk . NewCoins ( sdk . NewInt64Coin ( "atom" , 150 ) ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-05-25 21:10:09 -07:00
2019-06-28 13:11:27 -07:00
require . True ( sdk . IntEq ( t , input . sk . GetModuleAccount ( ctx , types . FeeCollectorName ) . GetCoins ( ) . AmountOf ( "atom" ) , sdk . NewInt ( 150 ) ) )
require . True ( sdk . IntEq ( t , input . ak . GetAccount ( ctx , addr1 ) . GetCoins ( ) . AmountOf ( "atom" ) , sdk . NewInt ( 0 ) ) )
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
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-12-20 11:09:43 -08:00
ctx := input . ctx . WithBlockHeight ( 1 )
2018-06-20 12:27:36 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
2018-06-20 12:27:36 -07:00
// set the accounts
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc1 . SetAccountNumber ( 0 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
2018-06-20 12:27:36 -07:00
// msg and signatures
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 )
2018-11-26 03:29:21 -08:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-03-07 16:55:08 -08:00
fee := NewStdFee ( 0 , sdk . NewCoins ( sdk . NewInt64Coin ( "atom" , 0 ) ) )
2018-06-20 12:27:36 -07:00
// tx does not have enough gas
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , [ ] sdk . Msg { msg } , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeOutOfGas )
2018-06-20 12:27:36 -07:00
// tx with memo doesn't have enough gas
2019-03-07 16:55:08 -08:00
fee = NewStdFee ( 801 , sdk . NewCoins ( sdk . NewInt64Coin ( "atom" , 0 ) ) )
2019-06-10 02:57:38 -07:00
tx = types . NewTestTxWithMemo ( ctx , [ ] sdk . Msg { msg } , privs , accnums , seqs , fee , "abcininasidniandsinasindiansdiansdinaisndiasndiadninsd" )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeOutOfGas )
2018-06-20 12:27:36 -07:00
// memo too large
2019-03-07 16:55:08 -08:00
fee = NewStdFee ( 9000 , sdk . NewCoins ( sdk . NewInt64Coin ( "atom" , 0 ) ) )
2019-06-10 02:57:38 -07:00
tx = types . NewTestTxWithMemo ( ctx , [ ] sdk . Msg { msg } , privs , accnums , seqs , fee , strings . Repeat ( "01234567890" , 500 ) )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeMemoTooLarge )
2018-06-20 12:27:36 -07:00
// tx with memo has enough gas
2019-03-07 16:55:08 -08:00
fee = NewStdFee ( 9000 , sdk . NewCoins ( sdk . NewInt64Coin ( "atom" , 0 ) ) )
2019-06-10 02:57:38 -07:00
tx = types . NewTestTxWithMemo ( ctx , [ ] sdk . Msg { msg } , privs , accnums , seqs , fee , strings . Repeat ( "0123456789" , 10 ) )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-06-21 15:05:25 -07:00
}
func TestAnteHandlerMultiSigner ( t * testing . T ) {
// setup
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-12-20 11:09:43 -08:00
ctx := input . ctx . WithBlockHeight ( 1 )
2018-06-21 15:05:25 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
priv2 , _ , addr2 := types . KeyTestPubAddr ( )
priv3 , _ , addr3 := types . KeyTestPubAddr ( )
2018-06-21 15:05:25 -07:00
// set the accounts
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2019-06-10 02:57:38 -07:00
acc1 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc1 . SetAccountNumber ( 0 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2019-06-10 02:57:38 -07:00
acc2 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc2 . SetAccountNumber ( 1 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc2 )
acc3 := input . ak . NewAccountWithAddress ( ctx , addr3 )
2019-06-10 02:57:38 -07:00
acc3 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc3 . SetAccountNumber ( 2 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc3 )
2018-06-21 15:05:25 -07:00
// set up msgs and fee
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg1 := types . NewTestMsg ( addr1 , addr2 )
msg2 := types . NewTestMsg ( addr3 , addr1 )
msg3 := types . NewTestMsg ( addr2 , addr3 )
2018-06-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg1 , msg2 , msg3 }
2019-06-10 02:57:38 -07:00
fee := types . NewTestStdFee ( )
2018-06-21 15:05:25 -07:00
// signers in order
2018-11-26 03:29:21 -08:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 , priv2 , priv3 } , [ ] uint64 { 0 , 1 , 2 } , [ ] uint64 { 0 , 0 , 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTxWithMemo ( ctx , msgs , privs , accnums , seqs , fee , "Check signers are in expected order and different account numbers works" )
2018-06-21 15:05:25 -07:00
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-06-21 15:05:25 -07:00
// change sequence numbers
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , [ ] sdk . Msg { msg1 } , [ ] crypto . PrivKey { priv1 , priv2 } , [ ] uint64 { 0 , 1 } , [ ] uint64 { 1 , 1 } , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , [ ] sdk . Msg { msg2 } , [ ] crypto . PrivKey { priv3 , priv1 } , [ ] uint64 { 2 , 0 } , [ ] uint64 { 1 , 2 } , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-06-21 15:05:25 -07:00
// expected seqs = [3, 2, 2]
2019-06-10 02:57:38 -07:00
tx = types . NewTestTxWithMemo ( ctx , msgs , privs , accnums , [ ] uint64 { 3 , 2 , 2 } , fee , "Check signers are in expected order and different account numbers and sequence numbers works" )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-06-20 12:27:36 -07:00
}
2018-03-12 17:40:04 -07:00
func TestAnteHandlerBadSignBytes ( t * testing . T ) {
2018-03-16 17:57:28 -07:00
// setup
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-12-20 11:09:43 -08:00
ctx := input . ctx . WithBlockHeight ( 1 )
2018-03-16 17:57:28 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
priv2 , _ , addr2 := types . KeyTestPubAddr ( )
2018-03-16 17:57:28 -07:00
// set the accounts
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2019-06-10 02:57:38 -07:00
acc1 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc1 . SetAccountNumber ( 0 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2019-06-10 02:57:38 -07:00
acc2 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc2 . SetAccountNumber ( 1 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc2 )
2018-03-16 17:57:28 -07:00
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 )
2018-06-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg }
2019-06-10 02:57:38 -07:00
fee := types . NewTestStdFee ( )
fee2 := types . NewTestStdFee ( )
2018-03-17 13:53:27 -07:00
fee2 . Gas += 100
2019-06-10 02:57:38 -07:00
fee3 := types . NewTestStdFee ( )
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-11-26 03:29:21 -08:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-03-16 17:57:28 -07:00
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-11-26 03:29:21 -08:00
accnum uint64
seq uint64
2018-05-23 22:09:01 -07:00
fee StdFee
2018-06-21 15:05:25 -07:00
msgs [ ] sdk . Msg
2018-03-17 11:54:18 -07:00
code sdk . CodeType
} {
2019-06-10 02:57:38 -07:00
{ chainID2 , 0 , 1 , fee , msgs , codeUnauth } , // test wrong chain_id
{ chainID , 0 , 2 , fee , msgs , codeUnauth } , // test wrong seqs
{ chainID , 1 , 1 , fee , msgs , codeUnauth } , // test wrong accnum
{ chainID , 0 , 1 , fee , [ ] sdk . Msg { types . NewTestMsg ( addr2 ) } , codeUnauth } , // test wrong msg
{ chainID , 0 , 1 , fee2 , msgs , codeUnauth } , // test wrong fee
{ chainID , 0 , 1 , fee3 , msgs , codeUnauth } , // test wrong fee
2018-03-17 11:54:18 -07:00
}
2018-11-26 03:29:21 -08:00
privs , seqs = [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 1 }
2018-03-17 11:54:18 -07:00
for _ , cs := range cases {
2019-06-10 02:57:38 -07:00
tx := types . NewTestTxWithSignBytes (
2018-06-21 15:05:25 -07:00
msgs , privs , accnums , seqs , fee ,
StdSignBytes ( cs . chainID , cs . accnum , cs . seq , cs . fee , cs . msgs , "" ) ,
2018-06-20 12:27:36 -07:00
"" ,
2018-03-17 11:54:18 -07:00
)
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , cs . code )
2018-03-17 11:54:18 -07:00
}
2018-03-16 17:57:28 -07:00
// test wrong signer if public key exist
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv2 } , [ ] uint64 { 0 } , [ ] uint64 { 1 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeUnauthorized )
2018-03-16 17:57:28 -07:00
// test wrong signer if public doesn't exist
2019-06-10 02:57:38 -07:00
msg = types . NewTestMsg ( addr2 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg }
2018-11-26 03:29:21 -08:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 1 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidPubKey )
2018-03-12 17:40:04 -07:00
}
func TestAnteHandlerSetPubKey ( t * testing . T ) {
2018-03-16 17:57:28 -07:00
// setup
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-12-20 11:09:43 -08:00
ctx := input . ctx . WithBlockHeight ( 1 )
2018-03-16 17:57:28 -07:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
_ , _ , addr2 := types . KeyTestPubAddr ( )
2018-03-16 17:57:28 -07:00
// set the accounts
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2019-06-10 02:57:38 -07:00
acc1 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc1 . SetAccountNumber ( 0 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2019-06-10 02:57:38 -07:00
acc2 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc2 . SetAccountNumber ( 1 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc2 )
2018-03-16 17:57:28 -07:00
var tx sdk . Tx
// test good tx and set public key
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 )
2018-06-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg }
2018-11-26 03:29:21 -08:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
fee := types . NewTestStdFee ( )
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-03-16 17:57:28 -07:00
2018-12-20 11:09:43 -08:00
acc1 = input . ak . 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
2019-06-10 02:57:38 -07:00
msg = types . NewTestMsg ( addr2 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , [ ] uint64 { 1 } , seqs , fee )
2019-06-05 16:26:17 -07:00
sigs := tx . ( types . StdTx ) . GetSignatures ( )
2019-06-08 03:04:52 -07:00
sigs [ 0 ] . PubKey = nil
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidPubKey )
2018-03-16 17:57:28 -07:00
2018-12-20 11:09:43 -08:00
acc2 = input . ak . GetAccount ( ctx , addr2 )
2018-06-29 18:10:15 -07:00
require . Nil ( t , acc2 . GetPubKey ( ) )
2018-03-16 17:57:28 -07:00
// test invalid signature and public key
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , [ ] uint64 { 1 } , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidPubKey )
2018-03-16 17:57:28 -07:00
2018-12-20 11:09:43 -08:00
acc2 = input . ak . GetAccount ( ctx , addr2 )
2018-06-29 18:10:15 -07:00
require . Nil ( t , acc2 . GetPubKey ( ) )
2018-03-12 17:40:04 -07:00
}
2018-08-31 10:04:11 -07:00
func TestProcessPubKey ( t * testing . T ) {
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
ctx := input . ctx
2018-08-31 10:04:11 -07:00
// keys
2019-06-10 02:57:38 -07:00
_ , _ , addr1 := types . KeyTestPubAddr ( )
priv2 , _ , addr2 := types . KeyTestPubAddr ( )
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2018-12-18 12:41:54 -08:00
acc2 . SetPubKey ( priv2 . PubKey ( ) )
2018-12-20 11:09:43 -08:00
2018-08-31 10:04:11 -07:00
type args struct {
acc Account
sig StdSignature
simulate bool
}
tests := [ ] struct {
name string
args args
wantErr bool
} {
2019-06-08 03:04:52 -07:00
{ "no sigs, simulate off" , args { acc1 , StdSignature { } , false } , true } ,
{ "no sigs, simulate on" , args { acc1 , StdSignature { } , true } , false } ,
{ "no sigs, account with pub, simulate on" , args { acc2 , StdSignature { } , true } , false } ,
{ "pubkey doesn't match addr, simulate off" , args { acc1 , StdSignature { PubKey : priv2 . PubKey ( ) } , false } , true } ,
{ "pubkey doesn't match addr, simulate on" , args { acc1 , StdSignature { PubKey : priv2 . PubKey ( ) } , true } , false } ,
2018-08-31 10:04:11 -07:00
}
for _ , tt := range tests {
t . Run ( tt . name , func ( t * testing . T ) {
2018-12-17 15:43:16 -08:00
_ , err := ProcessPubKey ( tt . args . acc , tt . args . sig , tt . args . simulate )
2018-08-31 10:04:11 -07:00
require . Equal ( t , tt . wantErr , ! err . IsOK ( ) )
} )
}
}
func TestConsumeSignatureVerificationGas ( t * testing . T ) {
2018-12-20 11:09:43 -08:00
params := DefaultParams ( )
2019-01-16 09:30:57 -08:00
msg := [ ] byte { 1 , 2 , 3 , 4 }
pkSet1 , sigSet1 := generatePubKeysAndSignatures ( 5 , msg , false )
multisigKey1 := multisig . NewPubKeyMultisigThreshold ( 2 , pkSet1 )
multisignature1 := multisig . NewMultisig ( len ( pkSet1 ) )
expectedCost1 := expectedGasCostByKeys ( pkSet1 )
for i := 0 ; i < len ( pkSet1 ) ; i ++ {
multisignature1 . AddSignatureFromPubKey ( sigSet1 [ i ] , pkSet1 [ i ] , pkSet1 )
}
2018-12-20 11:09:43 -08:00
2018-08-31 10:04:11 -07:00
type args struct {
meter sdk . GasMeter
2019-01-16 09:30:57 -08:00
sig [ ] byte
2018-08-31 10:04:11 -07:00
pubkey crypto . PubKey
2018-12-20 11:09:43 -08:00
params Params
2018-08-31 10:04:11 -07:00
}
tests := [ ] struct {
name string
args args
2018-11-19 09:13:45 -08:00
gasConsumed uint64
2019-03-01 09:12:28 -08:00
shouldErr bool
2018-08-31 10:04:11 -07:00
} {
2019-03-01 09:12:28 -08:00
{ "PubKeyEd25519" , args { sdk . NewInfiniteGasMeter ( ) , nil , ed25519 . GenPrivKey ( ) . PubKey ( ) , params } , DefaultSigVerifyCostED25519 , true } ,
2019-01-16 09:30:57 -08:00
{ "PubKeySecp256k1" , args { sdk . NewInfiniteGasMeter ( ) , nil , secp256k1 . GenPrivKey ( ) . PubKey ( ) , params } , DefaultSigVerifyCostSecp256k1 , false } ,
{ "Multisig" , args { sdk . NewInfiniteGasMeter ( ) , multisignature1 . Marshal ( ) , multisigKey1 , params } , expectedCost1 , false } ,
{ "unknown key" , args { sdk . NewInfiniteGasMeter ( ) , nil , nil , params } , 0 , true } ,
2018-08-31 10:04:11 -07:00
}
for _ , tt := range tests {
t . Run ( tt . name , func ( t * testing . T ) {
2019-05-02 12:36:42 -07:00
res := DefaultSigVerificationGasConsumer ( tt . args . meter , tt . args . sig , tt . args . pubkey , tt . args . params )
2019-03-01 09:12:28 -08:00
if tt . shouldErr {
require . False ( t , res . IsOK ( ) )
2018-08-31 10:04:11 -07:00
} else {
2019-03-01 09:12:28 -08:00
require . True ( t , res . IsOK ( ) )
2019-01-16 09:30:57 -08:00
require . Equal ( t , tt . gasConsumed , tt . args . meter . GasConsumed ( ) , fmt . Sprintf ( "%d != %d" , tt . gasConsumed , tt . args . meter . GasConsumed ( ) ) )
2018-08-31 10:04:11 -07:00
}
} )
}
}
2018-09-19 08:25:52 -07:00
2019-01-16 09:30:57 -08:00
func generatePubKeysAndSignatures ( n int , msg [ ] byte , keyTypeed25519 bool ) ( pubkeys [ ] crypto . PubKey , signatures [ ] [ ] byte ) {
pubkeys = make ( [ ] crypto . PubKey , n )
signatures = make ( [ ] [ ] byte , n )
for i := 0 ; i < n ; i ++ {
var privkey crypto . PrivKey
if rand . Int63 ( ) % 2 == 0 {
privkey = ed25519 . GenPrivKey ( )
} else {
privkey = secp256k1 . GenPrivKey ( )
}
pubkeys [ i ] = privkey . PubKey ( )
signatures [ i ] , _ = privkey . Sign ( msg )
}
return
}
func expectedGasCostByKeys ( pubkeys [ ] crypto . PubKey ) uint64 {
cost := uint64 ( 0 )
for _ , pubkey := range pubkeys {
pubkeyType := strings . ToLower ( fmt . Sprintf ( "%T" , pubkey ) )
switch {
case strings . Contains ( pubkeyType , "ed25519" ) :
cost += DefaultParams ( ) . SigVerifyCostED25519
case strings . Contains ( pubkeyType , "secp256k1" ) :
cost += DefaultParams ( ) . SigVerifyCostSecp256k1
default :
panic ( "unexpected key type" )
}
}
return cost
}
2018-11-15 06:30:24 -08:00
func TestCountSubkeys ( t * testing . T ) {
genPubKeys := func ( n int ) [ ] crypto . PubKey {
var ret [ ] crypto . PubKey
for i := 0 ; i < n ; i ++ {
ret = append ( ret , secp256k1 . GenPrivKey ( ) . PubKey ( ) )
}
return ret
}
2019-01-11 09:19:01 -08:00
singleKey := secp256k1 . GenPrivKey ( ) . PubKey ( )
singleLevelMultiKey := multisig . NewPubKeyMultisigThreshold ( 4 , genPubKeys ( 5 ) )
multiLevelSubKey1 := multisig . NewPubKeyMultisigThreshold ( 4 , genPubKeys ( 5 ) )
multiLevelSubKey2 := multisig . NewPubKeyMultisigThreshold ( 4 , genPubKeys ( 5 ) )
multiLevelMultiKey := multisig . NewPubKeyMultisigThreshold ( 2 , [ ] crypto . PubKey {
multiLevelSubKey1 , multiLevelSubKey2 , secp256k1 . GenPrivKey ( ) . PubKey ( ) } )
2018-11-15 06:30:24 -08:00
type args struct {
pub crypto . PubKey
}
tests := [ ] struct {
name string
args args
want int
} {
2019-01-11 09:19:01 -08:00
{ "single key" , args { singleKey } , 1 } ,
{ "single level multikey" , args { singleLevelMultiKey } , 5 } ,
{ "multi level multikey" , args { multiLevelMultiKey } , 11 } ,
2018-11-15 06:30:24 -08:00
}
for _ , tt := range tests {
t . Run ( tt . name , func ( T * testing . T ) {
2019-06-05 16:26:17 -07:00
require . Equal ( t , tt . want , CountSubKeys ( tt . args . pub ) )
2018-11-15 06:30:24 -08:00
} )
}
}
func TestAnteHandlerSigLimitExceeded ( t * testing . T ) {
// setup
2018-12-20 11:09:43 -08:00
input := setupTestInput ( )
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , DefaultSigVerificationGasConsumer )
2018-12-20 11:09:43 -08:00
ctx := input . ctx . WithBlockHeight ( 1 )
2018-11-15 06:30:24 -08:00
// keys and addresses
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
priv2 , _ , addr2 := types . KeyTestPubAddr ( )
priv3 , _ , addr3 := types . KeyTestPubAddr ( )
priv4 , _ , addr4 := types . KeyTestPubAddr ( )
priv5 , _ , addr5 := types . KeyTestPubAddr ( )
priv6 , _ , addr6 := types . KeyTestPubAddr ( )
priv7 , _ , addr7 := types . KeyTestPubAddr ( )
priv8 , _ , addr8 := types . KeyTestPubAddr ( )
2018-11-15 06:30:24 -08:00
// set the accounts
2018-12-20 11:09:43 -08:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
2019-06-10 02:57:38 -07:00
acc1 . SetCoins ( types . NewTestCoins ( ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc1 )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2019-06-10 02:57:38 -07:00
acc2 . SetCoins ( types . NewTestCoins ( ) )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc2 . SetAccountNumber ( 1 ) )
2018-12-20 11:09:43 -08:00
input . ak . SetAccount ( ctx , acc2 )
2018-11-15 06:30:24 -08:00
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 , addr2 , addr3 , addr4 , addr5 , addr6 , addr7 , addr8 )
2018-11-15 06:30:24 -08:00
msgs := [ ] sdk . Msg { msg }
2019-06-10 02:57:38 -07:00
fee := types . NewTestStdFee ( )
2018-11-15 06:30:24 -08:00
// test rejection logic
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 , priv2 , priv3 , priv4 , priv5 , priv6 , priv7 , priv8 } ,
2018-11-26 03:29:21 -08:00
[ ] uint64 { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } , [ ] uint64 { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-11-15 06:30:24 -08:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeTooManySignatures )
}
2019-01-18 08:45:20 -08:00
func TestEnsureSufficientMempoolFees ( t * testing . T ) {
// setup
input := setupTestInput ( )
ctx := input . ctx . WithMinGasPrices (
sdk . DecCoins {
2019-02-07 18:14:54 -08:00
sdk . NewDecCoinFromDec ( "photino" , sdk . NewDecWithPrec ( 50000000000000 , sdk . Precision ) ) , // 0.0001photino
sdk . NewDecCoinFromDec ( "stake" , sdk . NewDecWithPrec ( 10000000000000 , sdk . Precision ) ) , // 0.000001stake
2019-01-18 08:45:20 -08:00
} ,
)
testCases := [ ] struct {
input StdFee
expectedOK bool
} {
2019-06-11 03:47:17 -07:00
{ NewStdFee ( 200000 , sdk . Coins { } ) , false } ,
2019-03-07 16:55:08 -08:00
{ NewStdFee ( 200000 , sdk . NewCoins ( sdk . NewInt64Coin ( "photino" , 5 ) ) ) , false } ,
{ NewStdFee ( 200000 , sdk . NewCoins ( sdk . NewInt64Coin ( "stake" , 1 ) ) ) , false } ,
{ NewStdFee ( 200000 , sdk . NewCoins ( sdk . NewInt64Coin ( "stake" , 2 ) ) ) , true } ,
{ NewStdFee ( 200000 , sdk . NewCoins ( sdk . NewInt64Coin ( "photino" , 10 ) ) ) , true } ,
2019-01-18 08:45:20 -08:00
{
NewStdFee (
200000 ,
2019-03-07 16:55:08 -08:00
sdk . NewCoins (
2019-02-07 18:14:54 -08:00
sdk . NewInt64Coin ( "photino" , 10 ) ,
sdk . NewInt64Coin ( "stake" , 2 ) ,
2019-03-07 16:55:08 -08:00
) ,
2019-01-18 08:45:20 -08:00
) ,
true ,
} ,
{
NewStdFee (
200000 ,
2019-03-07 16:55:08 -08:00
sdk . NewCoins (
2019-02-07 18:14:54 -08:00
sdk . NewInt64Coin ( "atom" , 5 ) ,
sdk . NewInt64Coin ( "photino" , 10 ) ,
sdk . NewInt64Coin ( "stake" , 2 ) ,
2019-03-07 16:55:08 -08:00
) ,
2019-01-18 08:45:20 -08:00
) ,
true ,
} ,
}
for i , tc := range testCases {
res := EnsureSufficientMempoolFees ( ctx , tc . input )
require . Equal (
t , tc . expectedOK , res . IsOK ( ) ,
"unexpected result; tc #%d, input: %v, log: %v" , i , tc . input , res . Log ,
)
}
}
2019-05-02 12:36:42 -07:00
// Test custom SignatureVerificationGasConsumer
func TestCustomSignatureVerificationGasConsumer ( t * testing . T ) {
// setup
input := setupTestInput ( )
// setup an ante handler that only accepts PubKeyEd25519
2019-06-28 13:11:27 -07:00
anteHandler := NewAnteHandler ( input . ak , input . sk , func ( meter sdk . GasMeter , sig [ ] byte , pubkey crypto . PubKey , params Params ) sdk . Result {
2019-05-02 12:36:42 -07:00
switch pubkey := pubkey . ( type ) {
case ed25519 . PubKeyEd25519 :
meter . ConsumeGas ( params . SigVerifyCostED25519 , "ante verify: ed25519" )
return sdk . Result { }
default :
return sdk . ErrInvalidPubKey ( fmt . Sprintf ( "unrecognized public key type: %T" , pubkey ) ) . Result ( )
}
} )
ctx := input . ctx . WithBlockHeight ( 1 )
// verify that an secp256k1 account gets rejected
2019-06-10 02:57:38 -07:00
priv1 , _ , addr1 := types . KeyTestPubAddr ( )
2019-05-02 12:36:42 -07:00
acc1 := input . ak . NewAccountWithAddress ( ctx , addr1 )
_ = acc1 . SetCoins ( sdk . NewCoins ( sdk . NewInt64Coin ( "atom" , 150 ) ) )
input . ak . SetAccount ( ctx , acc1 )
2019-06-28 13:11:27 -07:00
2019-05-02 12:36:42 -07:00
var tx sdk . Tx
2019-06-10 02:57:38 -07:00
msg := types . NewTestMsg ( addr1 )
2019-05-02 12:36:42 -07:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] uint64 { 0 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
fee := types . NewTestStdFee ( )
2019-05-02 12:36:42 -07:00
msgs := [ ] sdk . Msg { msg }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2019-05-02 12:36:42 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidPubKey )
// verify that an ed25519 account gets accepted
priv2 := ed25519 . GenPrivKey ( )
pub2 := priv2 . PubKey ( )
addr2 := sdk . AccAddress ( pub2 . Address ( ) )
acc2 := input . ak . NewAccountWithAddress ( ctx , addr2 )
2019-06-28 13:11:27 -07:00
require . NoError ( t , acc2 . SetCoins ( sdk . NewCoins ( sdk . NewInt64Coin ( "atom" , 150 ) ) ) )
require . NoError ( t , acc2 . SetAccountNumber ( 1 ) )
2019-05-02 12:36:42 -07:00
input . ak . SetAccount ( ctx , acc2 )
2019-06-10 02:57:38 -07:00
msg = types . NewTestMsg ( addr2 )
2019-05-02 12:36:42 -07:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv2 } , [ ] uint64 { 1 } , [ ] uint64 { 0 }
2019-06-10 02:57:38 -07:00
fee = types . NewTestStdFee ( )
2019-05-02 12:36:42 -07:00
msgs = [ ] sdk . Msg { msg }
2019-06-10 02:57:38 -07:00
tx = types . NewTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2019-05-02 12:36:42 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
}