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"
2018-09-13 11:17:32 -07:00
codec "github.com/cosmos/cosmos-sdk/codec"
2018-08-31 10:04:11 -07:00
sdk "github.com/cosmos/cosmos-sdk/types"
2018-03-17 11:54:18 -07:00
"github.com/stretchr/testify/require"
2018-06-28 17:54:47 -07:00
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto"
2018-07-25 13:43:37 -07:00
"github.com/tendermint/tendermint/crypto/ed25519"
2018-08-31 10:04:11 -07:00
"github.com/tendermint/tendermint/crypto/secp256k1"
2018-07-02 13:34:06 -07:00
"github.com/tendermint/tendermint/libs/log"
2018-03-12 17:40:04 -07:00
)
2018-07-06 00:06:53 -07:00
func newTestMsg ( addrs ... sdk . AccAddress ) * sdk . TestMsg {
2018-03-17 13:53:27 -07:00
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-07-30 17:09:50 -07:00
sdk . NewInt64Coin ( "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-07-30 17:09:50 -07:00
sdk . NewInt64Coin ( "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
2018-07-06 00:06:53 -07:00
func privAndAddr ( ) ( crypto . PrivKey , sdk . AccAddress ) {
2018-07-25 13:43:37 -07:00
priv := ed25519 . GenPrivKey ( )
2018-07-06 00:06:53 -07:00
addr := sdk . AccAddress ( 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
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 )
2018-06-29 18:10:15 -07:00
require . False ( t , abort )
require . Equal ( t , sdk . ABCICodeOK , result . Code )
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 )
require . Equal ( t , sdk . ToABCICode ( sdk . CodespaceRoot , code ) , result . Code ,
2018-06-20 12:27:36 -07:00
fmt . Sprintf ( "Expected %v, got %v" , sdk . ToABCICode ( sdk . CodespaceRoot , code ) , result ) )
2018-07-13 10:53:12 -07:00
if code == sdk . CodeOutOfGas {
stdTx , ok := tx . ( StdTx )
require . True ( t , ok , "tx must be in form auth.StdTx" )
// 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
}
2018-06-21 15:05:25 -07:00
func newTestTx ( ctx sdk . Context , msgs [ ] sdk . Msg , privs [ ] crypto . PrivKey , accNums [ ] int64 , seqs [ ] int64 , fee StdFee ) sdk . Tx {
sigs := make ( [ ] StdSignature , len ( privs ) )
for i , priv := range privs {
signBytes := StdSignBytes ( ctx . ChainID ( ) , accNums [ i ] , seqs [ i ] , fee , msgs , "" )
2018-06-28 17:54:47 -07:00
sig , err := priv . Sign ( signBytes )
if err != nil {
panic ( err )
}
sigs [ i ] = StdSignature { PubKey : priv . PubKey ( ) , Signature : sig , AccountNumber : accNums [ i ] , Sequence : seqs [ i ] }
2018-06-21 15:05:25 -07:00
}
tx := NewStdTx ( msgs , fee , sigs , "" )
return tx
2018-03-16 17:57:28 -07:00
}
2018-06-21 15:05:25 -07:00
func newTestTxWithMemo ( ctx sdk . Context , msgs [ ] sdk . Msg , privs [ ] crypto . PrivKey , accNums [ ] int64 , seqs [ ] int64 , fee StdFee , memo string ) sdk . Tx {
sigs := make ( [ ] StdSignature , len ( privs ) )
for i , priv := range privs {
signBytes := StdSignBytes ( ctx . ChainID ( ) , accNums [ i ] , seqs [ i ] , fee , msgs , memo )
2018-06-28 17:54:47 -07:00
sig , err := priv . Sign ( signBytes )
if err != nil {
panic ( err )
}
sigs [ i ] = StdSignature { PubKey : priv . PubKey ( ) , Signature : sig , AccountNumber : accNums [ i ] , Sequence : seqs [ i ] }
2018-06-21 15:05:25 -07:00
}
tx := NewStdTx ( msgs , fee , sigs , memo )
return tx
2018-06-20 12:27:36 -07:00
}
2018-06-21 15:05:25 -07:00
// All signers sign over the same StdSignDoc. Should always create invalid signatures
func newTestTxWithSignBytes ( msgs [ ] 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-28 17:54:47 -07:00
sig , err := priv . Sign ( signBytes )
if err != nil {
panic ( err )
}
sigs [ i ] = StdSignature { PubKey : priv . PubKey ( ) , Signature : sig , AccountNumber : accNums [ i ] , Sequence : seqs [ i ] }
2018-03-12 17:40:04 -07:00
}
2018-06-21 15:05:25 -07:00
tx := NewStdTx ( msgs , 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-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-04-07 00:02:00 -07:00
RegisterBaseAccount ( cdc )
2018-06-25 19:05:47 -07:00
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
2018-05-25 20:29:40 -07:00
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
2018-06-21 18:03:05 -07:00
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
2018-03-12 17:40:04 -07:00
// keys and addresses
priv1 , addr1 := privAndAddr ( )
priv2 , addr2 := privAndAddr ( )
2018-06-21 15:05:25 -07:00
priv3 , addr3 := privAndAddr ( )
2018-03-12 17:40:04 -07:00
// msg and signatures
var tx sdk . Tx
2018-06-21 15:05:25 -07:00
msg1 := newTestMsg ( addr1 , addr2 )
msg2 := newTestMsg ( addr1 , addr3 )
2018-03-17 11:54:18 -07:00
fee := newStdFee ( )
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-06-11 19:30:54 -07:00
privs , accNums , seqs := [ ] crypto . PrivKey { } , [ ] int64 { } , [ ] int64 { }
2018-06-21 15:05:25 -07:00
tx = newTestTx ( ctx , msgs , privs , accNums , seqs , fee )
// tx.GetSigners returns addresses in correct order: addr1, addr2, addr3
2018-07-06 00:06:53 -07:00
expectedSigners := [ ] sdk . AccAddress { addr1 , addr2 , addr3 }
2018-06-21 15:05:25 -07:00
stdTx := tx . ( 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
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 num sigs dont match GetSigners
2018-06-11 19:30:54 -07:00
privs , accNums , seqs = [ ] crypto . PrivKey { priv1 } , [ ] int64 { 0 } , [ ] int64 { 0 }
2018-06-21 15:05:25 -07:00
tx = 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-06-21 15:05:25 -07:00
privs , accNums , seqs = [ ] crypto . PrivKey { priv1 , priv2 , priv3 } , [ ] int64 { 0 , 1 , 2 } , [ ] int64 { 0 , 0 , 0 }
tx = 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
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-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
ms , capKey , capKey2 := setupMultiStore ( )
2018-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-06-11 19:30:54 -07:00
RegisterBaseAccount ( cdc )
2018-06-25 19:05:47 -07:00
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
2018-06-11 19:30:54 -07:00
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
2018-06-21 18:03:05 -07:00
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
2018-10-19 11:00:27 -07:00
ctx = ctx . WithBlockHeight ( 1 )
2018-06-11 19:30:54 -07:00
// 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 ( )
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
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] int64 { 0 } , [ ] int64 { 0 }
2018-06-21 15:05:25 -07:00
tx = 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
seqs = [ ] int64 { 1 }
2018-06-21 15:05:25 -07:00
tx = newTestTx ( ctx , msgs , privs , [ ] int64 { 1 } , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidSequence )
2018-06-11 19:30:54 -07:00
// from correct account number
seqs = [ ] int64 { 1 }
2018-06-21 15:05:25 -07:00
tx = newTestTx ( ctx , msgs , privs , [ ] int64 { 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
2018-06-21 15:05:25 -07:00
msg1 := newTestMsg ( addr1 , addr2 )
msg2 := newTestMsg ( addr2 , addr1 )
msgs = [ ] sdk . Msg { msg1 , msg2 }
2018-06-11 19:30:54 -07:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] int64 { 1 , 0 } , [ ] int64 { 2 , 0 }
2018-06-21 15:05:25 -07:00
tx = newTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidSequence )
2018-06-11 19:30:54 -07:00
// correct account numbers
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] int64 { 0 , 1 } , [ ] int64 { 2 , 0 }
2018-06-21 15:05:25 -07:00
tx = 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
ms , capKey , capKey2 := setupMultiStore ( )
cdc := codec . New ( )
RegisterBaseAccount ( cdc )
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
ctx = ctx . WithBlockHeight ( 0 )
// 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 ( )
msgs := [ ] sdk . Msg { msg }
// test good tx from one signer
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] int64 { 0 } , [ ] int64 { 0 }
tx = newTestTx ( ctx , msgs , privs , accnums , seqs , fee )
checkValidTx ( t , anteHandler , ctx , tx , false )
// new tx from wrong account number
seqs = [ ] int64 { 1 }
tx = newTestTx ( ctx , msgs , privs , [ ] int64 { 1 } , seqs , fee )
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidSequence )
// from correct account number
seqs = [ ] int64 { 1 }
tx = newTestTx ( ctx , msgs , privs , [ ] int64 { 0 } , seqs , fee )
checkValidTx ( t , anteHandler , ctx , tx , false )
// new tx with another signer and incorrect account numbers
msg1 := newTestMsg ( addr1 , addr2 )
msg2 := newTestMsg ( addr2 , addr1 )
msgs = [ ] sdk . Msg { msg1 , msg2 }
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] int64 { 1 , 0 } , [ ] int64 { 2 , 0 }
tx = newTestTx ( ctx , msgs , privs , accnums , seqs , fee )
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidSequence )
// correct account numbers
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] int64 { 0 , 0 } , [ ] int64 { 2 , 0 }
tx = newTestTx ( ctx , msgs , privs , accnums , seqs , fee )
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-05-25 20:29:40 -07:00
ms , capKey , capKey2 := setupMultiStore ( )
2018-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-04-07 00:02:00 -07:00
RegisterBaseAccount ( cdc )
2018-06-25 19:05:47 -07:00
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
2018-05-25 20:29:40 -07:00
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
2018-06-21 18:03:05 -07:00
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
2018-10-19 11:00:27 -07:00
ctx = ctx . WithBlockHeight ( 1 )
2018-03-12 17:40:04 -07:00
// keys and addresses
priv1 , addr1 := privAndAddr ( )
priv2 , addr2 := privAndAddr ( )
2018-06-21 15:05:25 -07:00
priv3 , addr3 := privAndAddr ( )
2018-03-12 17:40:04 -07:00
// 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 )
2018-06-21 15:05:25 -07:00
acc3 := mapper . NewAccountWithAddress ( ctx , addr3 )
acc3 . SetCoins ( newCoins ( ) )
mapper . SetAccount ( ctx , acc3 )
2018-03-12 17:40:04 -07:00
// 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
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-06-11 19:30:54 -07:00
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] int64 { 0 } , [ ] int64 { 0 }
2018-06-21 15:05:25 -07:00
tx = 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-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidSequence )
2018-03-12 17:40:04 -07:00
// fix sequence, should pass
2018-03-17 11:54:18 -07:00
seqs = [ ] int64 { 1 }
2018-06-21 15:05:25 -07:00
tx = 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
2018-06-21 15:05:25 -07:00
msg1 := newTestMsg ( addr1 , addr2 )
msg2 := newTestMsg ( addr3 , addr1 )
msgs = [ ] sdk . Msg { msg1 , msg2 }
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 , priv3 } , [ ] int64 { 0 , 1 , 2 } , [ ] int64 { 2 , 0 , 0 }
tx = 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-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidSequence )
2018-03-12 17:40:04 -07:00
// tx from just second signer with incorrect sequence fails
msg = newTestMsg ( addr2 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg }
2018-06-11 19:30:54 -07:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv2 } , [ ] int64 { 1 } , [ ] int64 { 0 }
2018-06-21 15:05:25 -07:00
tx = newTestTx ( ctx , msgs , privs , accnums , seqs , fee )
2018-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidSequence )
2018-03-12 17:40:04 -07:00
// fix the sequence and it passes
2018-06-21 15:05:25 -07:00
tx = newTestTx ( ctx , msgs , [ ] crypto . PrivKey { priv2 } , [ ] int64 { 1 } , [ ] int64 { 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
msg = newTestMsg ( addr1 , addr2 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg }
2018-06-11 19:30:54 -07:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 , priv2 } , [ ] int64 { 0 , 1 } , [ ] int64 { 3 , 2 }
2018-06-21 15:05:25 -07:00
tx = 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-05-25 20:29:40 -07:00
ms , capKey , capKey2 := setupMultiStore ( )
2018-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-04-07 00:02:00 -07:00
RegisterBaseAccount ( cdc )
2018-06-25 19:05:47 -07:00
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
2018-05-25 20:29:40 -07:00
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
2018-06-21 18:03:05 -07:00
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , 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-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
2018-06-21 15:05:25 -07:00
tx = 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
2018-07-30 17:09:50 -07:00
acc1 . SetCoins ( sdk . Coins { sdk . NewInt64Coin ( "atom" , 149 ) } )
2018-03-17 13:20:24 -07:00
mapper . 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
2018-06-29 18:10:15 -07:00
require . True ( t , feeCollector . GetCollectedFees ( ctx ) . IsEqual ( emptyCoins ) )
2018-05-25 21:10:09 -07:00
2018-07-30 17:09:50 -07:00
acc1 . SetCoins ( sdk . Coins { sdk . NewInt64Coin ( "atom" , 150 ) } )
2018-03-17 13:20:24 -07:00
mapper . 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
2018-07-30 17:09:50 -07:00
require . True ( t , feeCollector . GetCollectedFees ( ctx ) . IsEqual ( sdk . Coins { sdk . NewInt64Coin ( "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 ( )
2018-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-06-20 12:27:36 -07:00
RegisterBaseAccount ( cdc )
2018-06-25 19:05:47 -07:00
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
2018-06-20 12:27:36 -07:00
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
2018-06-21 18:03:05 -07:00
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
2018-10-19 11:00:27 -07:00
ctx = ctx . WithBlockHeight ( 1 )
2018-06-20 12:27:36 -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 )
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 } , [ ] int64 { 0 } , [ ] int64 { 0 }
2018-08-25 12:12:14 -07:00
fee := NewStdFee ( 0 , sdk . NewInt64Coin ( "atom" , 0 ) )
2018-06-20 12:27:36 -07:00
// tx does not have enough gas
2018-06-21 15:05:25 -07:00
tx = 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
2018-07-30 17:09:50 -07:00
fee = NewStdFee ( 801 , sdk . NewInt64Coin ( "atom" , 0 ) )
2018-06-21 15:05:25 -07:00
tx = 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
2018-07-30 17:09:50 -07:00
fee = NewStdFee ( 2001 , sdk . NewInt64Coin ( "atom" , 0 ) )
2018-06-21 15:05:25 -07:00
tx = newTestTxWithMemo ( ctx , [ ] sdk . Msg { msg } , privs , accnums , seqs , fee , "abcininasidniandsinasindiansdiansdinaisndiasndiadninsdabcininasidniandsinasindiansdiansdinaisndiasndiadninsdabcininasidniandsinasindiansdiansdinaisndiasndiadninsd" )
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
2018-07-30 17:09:50 -07:00
fee = NewStdFee ( 1100 , sdk . NewInt64Coin ( "atom" , 0 ) )
2018-06-21 15:05:25 -07:00
tx = newTestTxWithMemo ( ctx , [ ] sdk . Msg { msg } , privs , accnums , seqs , fee , "abcininasidniandsinasindiansdiansdinaisndiasndiadninsd" )
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
ms , capKey , capKey2 := setupMultiStore ( )
2018-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-06-21 15:05:25 -07:00
RegisterBaseAccount ( cdc )
2018-06-25 19:05:47 -07:00
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
2018-06-21 15:05:25 -07:00
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
2018-06-21 18:03:05 -07:00
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
2018-10-19 11:00:27 -07:00
ctx = ctx . WithBlockHeight ( 1 )
2018-06-21 15:05:25 -07:00
// keys and addresses
priv1 , addr1 := privAndAddr ( )
priv2 , addr2 := privAndAddr ( )
priv3 , addr3 := 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 )
acc3 := mapper . NewAccountWithAddress ( ctx , addr3 )
acc3 . SetCoins ( newCoins ( ) )
mapper . SetAccount ( ctx , acc3 )
// set up msgs and fee
var tx sdk . Tx
msg1 := newTestMsg ( addr1 , addr2 )
msg2 := newTestMsg ( addr3 , addr1 )
msg3 := newTestMsg ( addr2 , addr3 )
msgs := [ ] sdk . Msg { msg1 , msg2 , msg3 }
fee := newStdFee ( )
// signers in order
privs , accnums , seqs := [ ] crypto . PrivKey { priv1 , priv2 , priv3 } , [ ] int64 { 0 , 1 , 2 } , [ ] int64 { 0 , 0 , 0 }
tx = newTestTxWithMemo ( ctx , msgs , privs , accnums , seqs , fee , "Check signers are in expected order and different account numbers works" )
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
tx = newTestTx ( ctx , [ ] sdk . Msg { msg1 } , [ ] crypto . PrivKey { priv1 , priv2 } , [ ] int64 { 0 , 1 } , [ ] int64 { 1 , 1 } , fee )
2018-08-25 12:12:14 -07:00
checkValidTx ( t , anteHandler , ctx , tx , false )
2018-06-21 15:05:25 -07:00
tx = newTestTx ( ctx , [ ] sdk . Msg { msg2 } , [ ] crypto . PrivKey { priv3 , priv1 } , [ ] int64 { 2 , 0 } , [ ] int64 { 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]
tx = newTestTxWithMemo ( ctx , msgs , privs , accnums , [ ] int64 { 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-05-25 20:29:40 -07:00
ms , capKey , capKey2 := setupMultiStore ( )
2018-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-04-07 00:02:00 -07:00
RegisterBaseAccount ( cdc )
2018-06-25 19:05:47 -07:00
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
2018-05-25 20:29:40 -07:00
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
2018-06-21 18:03:05 -07:00
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
2018-10-19 11:00:27 -07:00
ctx = ctx . WithBlockHeight ( 1 )
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 )
2018-06-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg }
2018-03-17 11:54:18 -07:00
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 }
2018-06-21 15:05:25 -07:00
tx = 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-06-21 15:05:25 -07:00
accnum int64
seq int64
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
} {
2018-06-21 15:05:25 -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 { 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
}
privs , seqs = [ ] crypto . PrivKey { priv1 } , [ ] int64 { 1 }
for _ , cs := range cases {
tx := 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-06-11 19:30:54 -07:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv2 } , [ ] int64 { 0 } , [ ] int64 { 1 }
2018-06-21 15:05:25 -07:00
tx = 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
msg = newTestMsg ( addr2 )
2018-06-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg }
2018-06-11 19:30:54 -07:00
privs , accnums , seqs = [ ] crypto . PrivKey { priv1 } , [ ] int64 { 1 } , [ ] int64 { 0 }
2018-06-21 15:05:25 -07:00
tx = 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-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-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-04-07 00:02:00 -07:00
RegisterBaseAccount ( cdc )
2018-06-25 19:05:47 -07:00
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
2018-05-25 20:29:40 -07:00
feeCollector := NewFeeCollectionKeeper ( cdc , capKey2 )
anteHandler := NewAnteHandler ( mapper , feeCollector )
2018-06-21 18:03:05 -07:00
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
2018-10-19 11:00:27 -07:00
ctx = ctx . WithBlockHeight ( 1 )
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-21 15:05:25 -07:00
msgs := [ ] sdk . Msg { msg }
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-21 15:05:25 -07:00
tx = 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
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-21 15:05:25 -07:00
msgs = [ ] sdk . Msg { msg }
tx = newTestTx ( ctx , msgs , 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-08-25 12:12:14 -07:00
checkInvalidTx ( t , anteHandler , ctx , tx , false , sdk . CodeInvalidPubKey )
2018-03-16 17:57:28 -07:00
acc2 = mapper . 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
2018-06-21 15:05:25 -07:00
tx = newTestTx ( ctx , msgs , privs , [ ] int64 { 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
acc2 = mapper . 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 ) {
ms , capKey , _ := setupMultiStore ( )
2018-09-13 11:17:32 -07:00
cdc := codec . New ( )
2018-08-31 10:04:11 -07:00
RegisterBaseAccount ( cdc )
mapper := NewAccountMapper ( cdc , capKey , ProtoBaseAccount )
ctx := sdk . NewContext ( ms , abci . Header { ChainID : "mychainid" } , false , log . NewNopLogger ( ) )
// keys
_ , addr1 := privAndAddr ( )
priv2 , _ := privAndAddr ( )
acc1 := mapper . NewAccountWithAddress ( ctx , addr1 )
type args struct {
acc Account
sig StdSignature
simulate bool
}
tests := [ ] struct {
name string
args args
wantErr bool
} {
{ "no sigs, simulate off" , args { acc1 , StdSignature { } , false } , true } ,
{ "no sigs, simulate on" , args { acc1 , 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 } ,
}
for _ , tt := range tests {
t . Run ( tt . name , func ( t * testing . T ) {
_ , err := processPubKey ( tt . args . acc , tt . args . sig , tt . args . simulate )
require . Equal ( t , tt . wantErr , ! err . IsOK ( ) )
} )
}
}
func TestConsumeSignatureVerificationGas ( t * testing . T ) {
type args struct {
meter sdk . GasMeter
pubkey crypto . PubKey
}
tests := [ ] struct {
name string
args args
gasConsumed int64
wantPanic bool
} {
{ "PubKeyEd25519" , args { sdk . NewInfiniteGasMeter ( ) , ed25519 . GenPrivKey ( ) . PubKey ( ) } , ed25519VerifyCost , false } ,
{ "PubKeySecp256k1" , args { sdk . NewInfiniteGasMeter ( ) , secp256k1 . GenPrivKey ( ) . PubKey ( ) } , secp256k1VerifyCost , false } ,
{ "unknown key" , args { sdk . NewInfiniteGasMeter ( ) , nil } , 0 , true } ,
}
for _ , tt := range tests {
t . Run ( tt . name , func ( t * testing . T ) {
if tt . wantPanic {
require . Panics ( t , func ( ) { consumeSignatureVerificationGas ( tt . args . meter , tt . args . pubkey ) } )
} else {
consumeSignatureVerificationGas ( tt . args . meter , tt . args . pubkey )
require . Equal ( t , tt . args . meter . GasConsumed ( ) , tt . gasConsumed )
}
} )
}
}
2018-09-19 08:25:52 -07:00
func TestAdjustFeesByGas ( t * testing . T ) {
type args struct {
fee sdk . Coins
gas int64
}
tests := [ ] struct {
name string
args args
want sdk . Coins
} {
{ "nil coins" , args { sdk . Coins { } , 10000 } , sdk . Coins { } } ,
{ "nil coins" , args { sdk . Coins { sdk . NewInt64Coin ( "A" , 10 ) , sdk . NewInt64Coin ( "B" , 0 ) } , 10000 } , sdk . Coins { sdk . NewInt64Coin ( "A" , 20 ) , sdk . NewInt64Coin ( "B" , 10 ) } } ,
{ "negative coins" , args { sdk . Coins { sdk . NewInt64Coin ( "A" , - 10 ) , sdk . NewInt64Coin ( "B" , 10 ) } , 10000 } , sdk . Coins { sdk . NewInt64Coin ( "B" , 20 ) } } ,
}
for _ , tt := range tests {
t . Run ( tt . name , func ( t * testing . T ) {
require . True ( t , tt . want . IsEqual ( adjustFeesByGas ( tt . args . fee , tt . args . gas ) ) )
} )
}
}