2019-08-19 06:29:17 -07:00
|
|
|
package simapp
|
|
|
|
|
|
|
|
import (
|
2020-02-20 07:09:25 -08:00
|
|
|
"bytes"
|
|
|
|
"encoding/hex"
|
2020-02-26 07:05:12 -08:00
|
|
|
"fmt"
|
2020-02-20 07:09:25 -08:00
|
|
|
"strconv"
|
2019-08-19 06:29:17 -07:00
|
|
|
"testing"
|
2020-06-26 09:36:04 -07:00
|
|
|
"time"
|
2019-08-19 06:29:17 -07:00
|
|
|
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
|
|
"github.com/tendermint/tendermint/crypto"
|
2019-08-27 06:19:26 -07:00
|
|
|
"github.com/tendermint/tendermint/crypto/ed25519"
|
2019-08-19 06:29:17 -07:00
|
|
|
"github.com/tendermint/tendermint/libs/log"
|
2020-04-16 08:10:39 -07:00
|
|
|
tmtypes "github.com/tendermint/tendermint/types"
|
2019-08-19 06:29:17 -07:00
|
|
|
dbm "github.com/tendermint/tm-db"
|
|
|
|
|
|
|
|
bam "github.com/cosmos/cosmos-sdk/baseapp"
|
2020-07-14 10:33:31 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/client"
|
2019-08-19 06:29:17 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
2019-10-23 02:14:45 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/simapp/helpers"
|
2019-08-19 06:29:17 -07:00
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
2020-06-17 11:42:27 -07:00
|
|
|
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
|
2020-06-14 16:06:16 -07:00
|
|
|
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
|
2020-06-26 09:36:04 -07:00
|
|
|
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
|
2019-08-19 06:29:17 -07:00
|
|
|
)
|
|
|
|
|
2020-04-16 08:10:39 -07:00
|
|
|
// DefaultConsensusParams defines the default Tendermint consensus params used in
|
|
|
|
// SimApp testing.
|
|
|
|
var DefaultConsensusParams = &abci.ConsensusParams{
|
|
|
|
Block: &abci.BlockParams{
|
|
|
|
MaxBytes: 200000,
|
|
|
|
MaxGas: 2000000,
|
|
|
|
},
|
|
|
|
Evidence: &abci.EvidenceParams{
|
|
|
|
MaxAgeNumBlocks: 302400,
|
|
|
|
MaxAgeDuration: 1814400,
|
|
|
|
},
|
|
|
|
Validator: &abci.ValidatorParams{
|
|
|
|
PubKeyTypes: []string{
|
|
|
|
tmtypes.ABCIPubKeyTypeEd25519,
|
|
|
|
tmtypes.ABCIPubKeyTypeSecp256k1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2019-08-19 06:29:17 -07:00
|
|
|
// Setup initializes a new SimApp. A Nop logger is set in SimApp.
|
|
|
|
func Setup(isCheckTx bool) *SimApp {
|
|
|
|
db := dbm.NewMemDB()
|
2020-04-16 08:10:39 -07:00
|
|
|
app := NewSimApp(log.NewNopLogger(), db, nil, true, map[int64]bool{}, DefaultNodeHome, 5)
|
2019-08-19 06:29:17 -07:00
|
|
|
if !isCheckTx {
|
|
|
|
// init chain must be called to stop deliverState from being nil
|
|
|
|
genesisState := NewDefaultGenesisState()
|
2019-12-17 10:28:52 -08:00
|
|
|
stateBytes, err := codec.MarshalJSONIndent(app.Codec(), genesisState)
|
2019-08-19 06:29:17 -07:00
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the chain
|
|
|
|
app.InitChain(
|
|
|
|
abci.RequestInitChain{
|
2020-04-16 08:10:39 -07:00
|
|
|
Validators: []abci.ValidatorUpdate{},
|
|
|
|
ConsensusParams: DefaultConsensusParams,
|
|
|
|
AppStateBytes: stateBytes,
|
2019-08-19 06:29:17 -07:00
|
|
|
},
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
return app
|
|
|
|
}
|
|
|
|
|
2020-06-26 09:36:04 -07:00
|
|
|
// SetupWithGenesisValSet initializes a new SimApp with a validator set and genesis accounts
|
|
|
|
// that also act as delegators. For simplicity, each validator is bonded with a delegation
|
|
|
|
// of one consensus engine unit (10^6) in the default token of the simapp from first genesis
|
|
|
|
// account. A Nop logger is set in SimApp.
|
|
|
|
func SetupWithGenesisValSet(t *testing.T, valSet *tmtypes.ValidatorSet, genAccs []authtypes.GenesisAccount, balances ...banktypes.Balance) *SimApp {
|
|
|
|
db := dbm.NewMemDB()
|
|
|
|
app := NewSimApp(log.NewNopLogger(), db, nil, true, map[int64]bool{}, DefaultNodeHome, 5)
|
|
|
|
|
|
|
|
genesisState := NewDefaultGenesisState()
|
|
|
|
|
|
|
|
// set genesis accounts
|
|
|
|
authGenesis := authtypes.NewGenesisState(authtypes.DefaultParams(), genAccs)
|
|
|
|
genesisState[authtypes.ModuleName] = app.Codec().MustMarshalJSON(authGenesis)
|
|
|
|
|
|
|
|
validators := make([]stakingtypes.Validator, 0, len(valSet.Validators))
|
|
|
|
delegations := make([]stakingtypes.Delegation, 0, len(valSet.Validators))
|
|
|
|
|
|
|
|
bondAmt := sdk.NewInt(1000000)
|
|
|
|
|
|
|
|
for _, val := range valSet.Validators {
|
|
|
|
validator := stakingtypes.Validator{
|
|
|
|
OperatorAddress: val.Address.Bytes(),
|
|
|
|
ConsensusPubkey: sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, val.PubKey),
|
|
|
|
Jailed: false,
|
|
|
|
Status: sdk.Bonded,
|
|
|
|
Tokens: bondAmt,
|
|
|
|
DelegatorShares: sdk.OneDec(),
|
|
|
|
Description: stakingtypes.Description{},
|
|
|
|
UnbondingHeight: int64(0),
|
|
|
|
UnbondingTime: time.Unix(0, 0).UTC(),
|
|
|
|
Commission: stakingtypes.NewCommission(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
|
|
|
|
MinSelfDelegation: sdk.ZeroInt(),
|
|
|
|
}
|
|
|
|
validators = append(validators, validator)
|
|
|
|
delegations = append(delegations, stakingtypes.NewDelegation(genAccs[0].GetAddress(), val.Address.Bytes(), sdk.OneDec()))
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// set validators and delegations
|
|
|
|
stakingGenesis := stakingtypes.NewGenesisState(stakingtypes.DefaultParams(), validators, delegations)
|
|
|
|
genesisState[stakingtypes.ModuleName] = app.Codec().MustMarshalJSON(stakingGenesis)
|
|
|
|
|
|
|
|
totalSupply := sdk.NewCoins()
|
|
|
|
for _, b := range balances {
|
|
|
|
// add genesis acc tokens and delegated tokens to total supply
|
|
|
|
totalSupply = totalSupply.Add(b.Coins.Add(sdk.NewCoin(sdk.DefaultBondDenom, bondAmt))...)
|
|
|
|
}
|
|
|
|
|
|
|
|
// update total supply
|
2020-07-08 10:43:08 -07:00
|
|
|
bankGenesis := banktypes.NewGenesisState(banktypes.DefaultGenesisState().Params, balances, totalSupply)
|
2020-06-26 09:36:04 -07:00
|
|
|
genesisState[banktypes.ModuleName] = app.Codec().MustMarshalJSON(bankGenesis)
|
|
|
|
|
|
|
|
stateBytes, err := codec.MarshalJSONIndent(app.Codec(), genesisState)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
// init chain will set the validator set and initialize the genesis accounts
|
|
|
|
app.InitChain(
|
|
|
|
abci.RequestInitChain{
|
|
|
|
Validators: []abci.ValidatorUpdate{},
|
|
|
|
ConsensusParams: DefaultConsensusParams,
|
|
|
|
AppStateBytes: stateBytes,
|
|
|
|
},
|
|
|
|
)
|
|
|
|
|
|
|
|
// commit genesis changes
|
|
|
|
app.Commit()
|
|
|
|
app.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: app.LastBlockHeight() + 1, AppHash: app.LastCommitID().Hash}})
|
|
|
|
|
|
|
|
return app
|
|
|
|
}
|
|
|
|
|
2020-02-14 07:30:51 -08:00
|
|
|
// SetupWithGenesisAccounts initializes a new SimApp with the provided genesis
|
|
|
|
// accounts and possible balances.
|
2020-06-17 11:42:27 -07:00
|
|
|
func SetupWithGenesisAccounts(genAccs []authtypes.GenesisAccount, balances ...banktypes.Balance) *SimApp {
|
2019-08-19 06:29:17 -07:00
|
|
|
db := dbm.NewMemDB()
|
2020-02-27 22:26:04 -08:00
|
|
|
app := NewSimApp(log.NewNopLogger(), db, nil, true, map[int64]bool{}, DefaultNodeHome, 0)
|
2019-08-19 06:29:17 -07:00
|
|
|
|
|
|
|
// initialize the chain with the passed in genesis accounts
|
|
|
|
genesisState := NewDefaultGenesisState()
|
2019-09-12 12:22:25 -07:00
|
|
|
|
2020-06-17 11:42:27 -07:00
|
|
|
authGenesis := authtypes.NewGenesisState(authtypes.DefaultParams(), genAccs)
|
|
|
|
genesisState[authtypes.ModuleName] = app.Codec().MustMarshalJSON(authGenesis)
|
2020-02-14 07:30:51 -08:00
|
|
|
|
2020-04-20 08:22:12 -07:00
|
|
|
totalSupply := sdk.NewCoins()
|
|
|
|
for _, b := range balances {
|
|
|
|
totalSupply = totalSupply.Add(b.Coins...)
|
|
|
|
}
|
|
|
|
|
2020-07-08 10:43:08 -07:00
|
|
|
bankGenesis := banktypes.NewGenesisState(banktypes.DefaultGenesisState().Params, balances, totalSupply)
|
2020-06-14 16:06:16 -07:00
|
|
|
genesisState[banktypes.ModuleName] = app.Codec().MustMarshalJSON(bankGenesis)
|
2019-09-12 12:22:25 -07:00
|
|
|
|
2019-12-17 10:28:52 -08:00
|
|
|
stateBytes, err := codec.MarshalJSONIndent(app.Codec(), genesisState)
|
2019-08-19 06:29:17 -07:00
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
app.InitChain(
|
|
|
|
abci.RequestInitChain{
|
2020-04-16 08:10:39 -07:00
|
|
|
Validators: []abci.ValidatorUpdate{},
|
|
|
|
ConsensusParams: DefaultConsensusParams,
|
|
|
|
AppStateBytes: stateBytes,
|
2019-08-19 06:29:17 -07:00
|
|
|
},
|
|
|
|
)
|
|
|
|
|
|
|
|
app.Commit()
|
|
|
|
app.BeginBlock(abci.RequestBeginBlock{Header: abci.Header{Height: app.LastBlockHeight() + 1}})
|
|
|
|
|
|
|
|
return app
|
|
|
|
}
|
|
|
|
|
2020-02-21 10:34:07 -08:00
|
|
|
type GenerateAccountStrategy func(int) []sdk.AccAddress
|
|
|
|
|
2020-02-27 07:49:53 -08:00
|
|
|
// createRandomAccounts is a strategy used by addTestAddrs() in order to generated addresses in random order.
|
|
|
|
func createRandomAccounts(accNum int) []sdk.AccAddress {
|
2019-08-27 06:19:26 -07:00
|
|
|
testAddrs := make([]sdk.AccAddress, accNum)
|
|
|
|
for i := 0; i < accNum; i++ {
|
|
|
|
pk := ed25519.GenPrivKey().PubKey()
|
|
|
|
testAddrs[i] = sdk.AccAddress(pk.Address())
|
|
|
|
}
|
|
|
|
|
2020-02-21 10:34:07 -08:00
|
|
|
return testAddrs
|
|
|
|
}
|
|
|
|
|
2020-02-27 07:49:53 -08:00
|
|
|
// createIncrementalAccounts is a strategy used by addTestAddrs() in order to generated addresses in ascending order.
|
|
|
|
func createIncrementalAccounts(accNum int) []sdk.AccAddress {
|
2020-02-21 10:34:07 -08:00
|
|
|
var addresses []sdk.AccAddress
|
|
|
|
var buffer bytes.Buffer
|
|
|
|
|
|
|
|
// start at 100 so we can make up to 999 test addresses with valid test addresses
|
|
|
|
for i := 100; i < (accNum + 100); i++ {
|
|
|
|
numString := strconv.Itoa(i)
|
|
|
|
buffer.WriteString("A58856F0FD53BF058B4909A21AEC019107BA6") //base address string
|
|
|
|
|
|
|
|
buffer.WriteString(numString) //adding on final two digits to make addresses unique
|
|
|
|
res, _ := sdk.AccAddressFromHex(buffer.String())
|
|
|
|
bech := res.String()
|
2020-02-26 07:05:12 -08:00
|
|
|
addr, _ := TestAddr(buffer.String(), bech)
|
|
|
|
|
|
|
|
addresses = append(addresses, addr)
|
2020-02-21 10:34:07 -08:00
|
|
|
buffer.Reset()
|
|
|
|
}
|
|
|
|
|
|
|
|
return addresses
|
|
|
|
}
|
|
|
|
|
2020-03-03 02:05:20 -08:00
|
|
|
// AddTestAddrsFromPubKeys adds the addresses into the SimApp providing only the public keys.
|
2020-03-03 01:51:06 -08:00
|
|
|
func AddTestAddrsFromPubKeys(app *SimApp, ctx sdk.Context, pubKeys []crypto.PubKey, accAmt sdk.Int) {
|
|
|
|
initCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), accAmt))
|
2020-03-03 02:05:20 -08:00
|
|
|
|
|
|
|
setTotalSupply(app, ctx, accAmt, len(pubKeys))
|
2020-03-03 01:51:06 -08:00
|
|
|
|
|
|
|
// fill all the addresses with some coins, set the loose pool tokens simultaneously
|
|
|
|
for _, pubKey := range pubKeys {
|
2020-03-03 02:05:20 -08:00
|
|
|
saveAccount(app, ctx, sdk.AccAddress(pubKey.Address()), initCoins)
|
2020-03-03 01:51:06 -08:00
|
|
|
}
|
2020-03-03 02:05:20 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// setTotalSupply provides the total supply based on accAmt * totalAccounts.
|
|
|
|
func setTotalSupply(app *SimApp, ctx sdk.Context, accAmt sdk.Int, totalAccounts int) {
|
|
|
|
totalSupply := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), accAmt.MulRaw(int64(totalAccounts))))
|
2020-04-20 08:22:12 -07:00
|
|
|
prevSupply := app.BankKeeper.GetSupply(ctx)
|
2020-06-14 16:06:16 -07:00
|
|
|
app.BankKeeper.SetSupply(ctx, banktypes.NewSupply(prevSupply.GetTotal().Add(totalSupply...)))
|
2020-03-03 01:51:06 -08:00
|
|
|
}
|
|
|
|
|
2020-02-21 10:34:07 -08:00
|
|
|
// AddTestAddrs constructs and returns accNum amount of accounts with an
|
|
|
|
// initial balance of accAmt in random order
|
|
|
|
func AddTestAddrs(app *SimApp, ctx sdk.Context, accNum int, accAmt sdk.Int) []sdk.AccAddress {
|
2020-02-27 07:49:53 -08:00
|
|
|
return addTestAddrs(app, ctx, accNum, accAmt, createRandomAccounts)
|
2020-02-21 10:34:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// AddTestAddrs constructs and returns accNum amount of accounts with an
|
|
|
|
// initial balance of accAmt in random order
|
|
|
|
func AddTestAddrsIncremental(app *SimApp, ctx sdk.Context, accNum int, accAmt sdk.Int) []sdk.AccAddress {
|
2020-02-27 07:49:53 -08:00
|
|
|
return addTestAddrs(app, ctx, accNum, accAmt, createIncrementalAccounts)
|
2020-02-21 10:34:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func addTestAddrs(app *SimApp, ctx sdk.Context, accNum int, accAmt sdk.Int, strategy GenerateAccountStrategy) []sdk.AccAddress {
|
|
|
|
testAddrs := strategy(accNum)
|
|
|
|
|
2019-08-27 06:19:26 -07:00
|
|
|
initCoins := sdk.NewCoins(sdk.NewCoin(app.StakingKeeper.BondDenom(ctx), accAmt))
|
2020-03-03 02:05:20 -08:00
|
|
|
setTotalSupply(app, ctx, accAmt, accNum)
|
2019-08-27 06:19:26 -07:00
|
|
|
|
|
|
|
// fill all the addresses with some coins, set the loose pool tokens simultaneously
|
|
|
|
for _, addr := range testAddrs {
|
2020-03-03 02:05:20 -08:00
|
|
|
saveAccount(app, ctx, addr, initCoins)
|
2019-08-27 06:19:26 -07:00
|
|
|
}
|
2020-03-03 02:05:20 -08:00
|
|
|
|
2019-08-27 06:19:26 -07:00
|
|
|
return testAddrs
|
|
|
|
}
|
|
|
|
|
2020-03-03 02:05:20 -08:00
|
|
|
// saveAccount saves the provided account into the simapp with balance based on initCoins.
|
|
|
|
func saveAccount(app *SimApp, ctx sdk.Context, addr sdk.AccAddress, initCoins sdk.Coins) {
|
|
|
|
acc := app.AccountKeeper.NewAccountWithAddress(ctx, addr)
|
|
|
|
app.AccountKeeper.SetAccount(ctx, acc)
|
|
|
|
_, err := app.BankKeeper.AddCoins(ctx, addr, initCoins)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-28 09:59:17 -08:00
|
|
|
// ConvertAddrsToValAddrs converts the provided addresses to ValAddress.
|
2020-02-26 07:05:12 -08:00
|
|
|
func ConvertAddrsToValAddrs(addrs []sdk.AccAddress) []sdk.ValAddress {
|
2020-02-26 07:16:56 -08:00
|
|
|
valAddrs := make([]sdk.ValAddress, len(addrs))
|
2020-02-26 07:05:12 -08:00
|
|
|
|
2020-02-26 07:16:56 -08:00
|
|
|
for i, addr := range addrs {
|
|
|
|
valAddrs[i] = sdk.ValAddress(addr)
|
2020-02-21 11:51:11 -08:00
|
|
|
}
|
|
|
|
|
2020-02-26 07:05:12 -08:00
|
|
|
return valAddrs
|
2020-02-21 11:51:11 -08:00
|
|
|
}
|
|
|
|
|
2020-02-26 07:05:12 -08:00
|
|
|
func TestAddr(addr string, bech string) (sdk.AccAddress, error) {
|
2020-02-21 10:34:07 -08:00
|
|
|
res, err := sdk.AccAddressFromHex(addr)
|
|
|
|
if err != nil {
|
2020-02-26 07:05:12 -08:00
|
|
|
return nil, err
|
2020-02-21 10:34:07 -08:00
|
|
|
}
|
|
|
|
bechexpected := res.String()
|
|
|
|
if bech != bechexpected {
|
2020-02-26 07:05:12 -08:00
|
|
|
return nil, fmt.Errorf("bech encoding doesn't match reference")
|
2020-02-21 10:34:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
bechres, err := sdk.AccAddressFromBech32(bech)
|
|
|
|
if err != nil {
|
2020-02-26 07:05:12 -08:00
|
|
|
return nil, err
|
2020-02-21 10:34:07 -08:00
|
|
|
}
|
|
|
|
if !bytes.Equal(bechres, res) {
|
2020-02-26 07:05:12 -08:00
|
|
|
return nil, err
|
2020-02-21 10:34:07 -08:00
|
|
|
}
|
|
|
|
|
2020-02-26 07:05:12 -08:00
|
|
|
return res, nil
|
2020-02-21 10:34:07 -08:00
|
|
|
}
|
|
|
|
|
2019-08-19 06:29:17 -07:00
|
|
|
// CheckBalance checks the balance of an account.
|
2020-01-30 13:31:16 -08:00
|
|
|
func CheckBalance(t *testing.T, app *SimApp, addr sdk.AccAddress, balances sdk.Coins) {
|
2019-08-19 06:29:17 -07:00
|
|
|
ctxCheck := app.BaseApp.NewContext(true, abci.Header{})
|
2020-01-30 13:31:16 -08:00
|
|
|
require.True(t, balances.IsEqual(app.BankKeeper.GetAllBalances(ctxCheck, addr)))
|
2019-08-19 06:29:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// SignCheckDeliver checks a generated signed transaction and simulates a
|
|
|
|
// block commitment with the given transaction. A test assertion is made using
|
|
|
|
// the parameter 'expPass' against the result. A corresponding result is
|
|
|
|
// returned.
|
|
|
|
func SignCheckDeliver(
|
2020-07-14 10:33:31 -07:00
|
|
|
t *testing.T, txGen client.TxGenerator, app *bam.BaseApp, header abci.Header, msgs []sdk.Msg,
|
2019-08-19 06:29:17 -07:00
|
|
|
accNums, seq []uint64, expSimPass, expPass bool, priv ...crypto.PrivKey,
|
2019-12-27 09:57:54 -08:00
|
|
|
) (sdk.GasInfo, *sdk.Result, error) {
|
2019-08-19 06:29:17 -07:00
|
|
|
|
2020-07-14 10:33:31 -07:00
|
|
|
tx, err := helpers.GenTx(
|
|
|
|
txGen,
|
2019-10-23 02:14:45 -07:00
|
|
|
msgs,
|
|
|
|
sdk.Coins{sdk.NewInt64Coin(sdk.DefaultBondDenom, 0)},
|
2019-12-18 06:48:22 -08:00
|
|
|
helpers.DefaultGenTxGas,
|
2019-10-23 02:14:45 -07:00
|
|
|
"",
|
|
|
|
accNums,
|
|
|
|
seq,
|
|
|
|
priv...,
|
|
|
|
)
|
2020-07-14 10:33:31 -07:00
|
|
|
require.NoError(t, err)
|
|
|
|
txBytes, err := txGen.TxEncoder()(tx)
|
2019-08-19 06:29:17 -07:00
|
|
|
require.Nil(t, err)
|
|
|
|
|
|
|
|
// Must simulate now as CheckTx doesn't run Msgs anymore
|
2019-12-27 09:57:54 -08:00
|
|
|
_, res, err := app.Simulate(txBytes, tx)
|
2019-08-19 06:29:17 -07:00
|
|
|
|
|
|
|
if expSimPass {
|
2019-12-27 09:57:54 -08:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.NotNil(t, res)
|
2019-08-19 06:29:17 -07:00
|
|
|
} else {
|
2019-12-27 09:57:54 -08:00
|
|
|
require.Error(t, err)
|
|
|
|
require.Nil(t, res)
|
2019-08-19 06:29:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Simulate a sending a transaction and committing a block
|
|
|
|
app.BeginBlock(abci.RequestBeginBlock{Header: header})
|
2019-12-27 09:57:54 -08:00
|
|
|
gInfo, res, err := app.Deliver(tx)
|
2019-08-19 06:29:17 -07:00
|
|
|
|
|
|
|
if expPass {
|
2019-12-27 09:57:54 -08:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.NotNil(t, res)
|
2019-08-19 06:29:17 -07:00
|
|
|
} else {
|
2019-12-27 09:57:54 -08:00
|
|
|
require.Error(t, err)
|
|
|
|
require.Nil(t, res)
|
2019-08-19 06:29:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
app.EndBlock(abci.RequestEndBlock{})
|
|
|
|
app.Commit()
|
|
|
|
|
2019-12-27 09:57:54 -08:00
|
|
|
return gInfo, res, err
|
2019-08-19 06:29:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// GenSequenceOfTxs generates a set of signed transactions of messages, such
|
|
|
|
// that they differ only by having the sequence numbers incremented between
|
|
|
|
// every transaction.
|
2020-07-14 10:33:31 -07:00
|
|
|
func GenSequenceOfTxs(txGen client.TxGenerator, msgs []sdk.Msg, accNums []uint64, initSeqNums []uint64, numToGenerate int, priv ...crypto.PrivKey) ([]sdk.Tx, error) {
|
|
|
|
txs := make([]sdk.Tx, numToGenerate)
|
|
|
|
var err error
|
2019-08-19 06:29:17 -07:00
|
|
|
for i := 0; i < numToGenerate; i++ {
|
2020-07-14 10:33:31 -07:00
|
|
|
txs[i], err = helpers.GenTx(
|
|
|
|
txGen,
|
2019-10-23 02:14:45 -07:00
|
|
|
msgs,
|
|
|
|
sdk.Coins{sdk.NewInt64Coin(sdk.DefaultBondDenom, 0)},
|
2019-12-18 06:48:22 -08:00
|
|
|
helpers.DefaultGenTxGas,
|
2019-10-23 02:14:45 -07:00
|
|
|
"",
|
|
|
|
accNums,
|
|
|
|
initSeqNums,
|
|
|
|
priv...,
|
|
|
|
)
|
2020-07-14 10:33:31 -07:00
|
|
|
if err != nil {
|
|
|
|
break
|
|
|
|
}
|
2019-08-19 06:29:17 -07:00
|
|
|
incrementAllSequenceNumbers(initSeqNums)
|
|
|
|
}
|
|
|
|
|
2020-07-14 10:33:31 -07:00
|
|
|
return txs, err
|
2019-08-19 06:29:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func incrementAllSequenceNumbers(initSeqNums []uint64) {
|
|
|
|
for i := 0; i < len(initSeqNums); i++ {
|
|
|
|
initSeqNums[i]++
|
|
|
|
}
|
|
|
|
}
|
2020-02-20 07:09:25 -08:00
|
|
|
|
2020-02-28 10:07:10 -08:00
|
|
|
// CreateTestPubKeys returns a total of numPubKeys public keys in ascending order.
|
2020-02-20 07:09:25 -08:00
|
|
|
func CreateTestPubKeys(numPubKeys int) []crypto.PubKey {
|
|
|
|
var publicKeys []crypto.PubKey
|
|
|
|
var buffer bytes.Buffer
|
|
|
|
|
2020-02-28 09:58:55 -08:00
|
|
|
// start at 10 to avoid changing 1 to 01, 2 to 02, etc
|
2020-02-20 07:09:25 -08:00
|
|
|
for i := 100; i < (numPubKeys + 100); i++ {
|
|
|
|
numString := strconv.Itoa(i)
|
2020-02-28 09:59:26 -08:00
|
|
|
buffer.WriteString("0B485CFC0EECC619440448436F8FC9DF40566F2369E72400281454CB552AF") // base pubkey string
|
|
|
|
buffer.WriteString(numString) // adding on final two digits to make pubkeys unique
|
2020-02-26 07:05:12 -08:00
|
|
|
publicKeys = append(publicKeys, NewPubKeyFromHex(buffer.String()))
|
2020-02-20 07:09:25 -08:00
|
|
|
buffer.Reset()
|
|
|
|
}
|
|
|
|
|
|
|
|
return publicKeys
|
|
|
|
}
|
|
|
|
|
2020-02-28 10:06:03 -08:00
|
|
|
// NewPubKeyFromHex returns a PubKey from a hex string.
|
2020-02-26 07:05:12 -08:00
|
|
|
func NewPubKeyFromHex(pk string) (res crypto.PubKey) {
|
2020-02-20 07:09:25 -08:00
|
|
|
pkBytes, err := hex.DecodeString(pk)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
var pkEd ed25519.PubKeyEd25519
|
|
|
|
copy(pkEd[:], pkBytes)
|
|
|
|
return pkEd
|
|
|
|
}
|