LaconicNetwork/cosmos-sdk
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

refactor(types,client,simapp): remove some address String() calls (#21455)

Browse Source
This commit is contained in:
Julián Toledano 2024-09-02 12:28:12 +02:00 committed by GitHub
parent f79b3802ac
commit a51b432b76
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
23 changed files with 243 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
client/grpc/cmtservice/service.go
View File

@ -15,7 +15,6 @@ import (
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
sdk "github.com/cosmos/cosmos-sdk/types"
qtypes "github.com/cosmos/cosmos-sdk/types/query"
"github.com/cosmos/cosmos-sdk/version"
)
@ -73,10 +72,15 @@ func (s queryServer) GetLatestBlock(ctx context.Context, _ *GetLatestBlockReques
return nil, err
}
sdkBlock, err := convertBlock(protoBlock, s.clientCtx.ConsensusAddressCodec)
if err != nil {
return nil, err
}
return &GetLatestBlockResponse{
BlockId: &protoBlockID,
Block: protoBlock,
SdkBlock: convertBlock(protoBlock),
SdkBlock: sdkBlock,
}, nil
}
@ -96,10 +100,15 @@ func (s queryServer) GetBlockByHeight(ctx context.Context, req *GetBlockByHeight
return nil, err
}
sdkBlock, err := convertBlock(protoBlock, s.clientCtx.ConsensusAddressCodec)
if err != nil {
return nil, err
}
return &GetBlockByHeightResponse{
BlockId: &protoBlockID,
Block: protoBlock,
SdkBlock: convertBlock(protoBlock),
SdkBlock: sdkBlock,
}, nil
}
@ -177,8 +186,13 @@ func ValidatorsOutput(ctx context.Context, clientCtx client.Context, height *int
return nil, err
}
addr, err := clientCtx.ConsensusAddressCodec.BytesToString(v.Address)
if err != nil {
return nil, err
}
resp.Validators[i] = &Validator{
Address: sdk.ConsAddress(v.Address).String(),
Address: addr,
ProposerPriority: v.ProposerPriority,
PubKey: anyPub,
VotingPower: v.VotingPower,

24
client/grpc/cmtservice/util.go
View File

@ -3,11 +3,16 @@ package cmtservice
import (
cmtprototypes "github.com/cometbft/cometbft/api/cometbft/types/v1"
sdk "github.com/cosmos/cosmos-sdk/types"
"cosmossdk.io/core/address"
)
// convertHeader converts CometBFT header to sdk header
func convertHeader(h cmtprototypes.Header) Header {
func convertHeader(h cmtprototypes.Header, ac address.Codec) (Header, error) {
proposerAddr, err := ac.BytesToString(h.ProposerAddress)
if err != nil {
return Header{}, err
}
return Header{
Version: h.Version,
ChainID: h.ChainID,
@ -22,18 +27,21 @@ func convertHeader(h cmtprototypes.Header) Header {
EvidenceHash: h.EvidenceHash,
LastResultsHash: h.LastResultsHash,
LastCommitHash: h.LastCommitHash,
ProposerAddress: sdk.ConsAddress(h.ProposerAddress).String(),
}
ProposerAddress: proposerAddr,
}, nil
}
// convertBlock converts CometBFT block to sdk block
func convertBlock(cmtblock *cmtprototypes.Block) *Block {
func convertBlock(cmtblock *cmtprototypes.Block, ac address.Codec) (*Block, error) {
b := new(Block)
b.Header = convertHeader(cmtblock.Header)
var err error
b.Header, err = convertHeader(cmtblock.Header, ac)
if err != nil {
return nil, err
}
b.LastCommit = cmtblock.LastCommit
b.Data = cmtblock.Data
b.Evidence = cmtblock.Evidence
return b
return b, nil
}

4
client/keys/show_test.go
View File

@ -116,8 +116,10 @@ func Test_runShowCmd(t *testing.T) {
require.NoError(t, err)
addr, err := k.GetAddress()
require.NoError(t, err)
addrStr, err := clientCtx.AddressCodec.BytesToString(addr)
require.NoError(t, err)
cmd.SetArgs([]string{
addr.String(),
addrStr,
fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),

28
client/test_helpers.go
View File

@ -45,8 +45,13 @@ type TestAccountRetriever struct {
}
// GetAccount implements AccountRetriever.GetAccount
func (t TestAccountRetriever) GetAccount(_ Context, addr sdk.AccAddress) (Account, error) {
acc, ok := t.Accounts[addr.String()]
func (t TestAccountRetriever) GetAccount(clientCtx Context, addr sdk.AccAddress) (Account, error) {
addrStr, err := clientCtx.AddressCodec.BytesToString(addr)
if err != nil {
return nil, err
}
acc, ok := t.Accounts[addrStr]
if !ok {
return nil, fmt.Errorf("account: account %s not found", addr)
}
@ -65,19 +70,16 @@ func (t TestAccountRetriever) GetAccountWithHeight(clientCtx Context, addr sdk.A
}
// EnsureExists implements AccountRetriever.EnsureExists
func (t TestAccountRetriever) EnsureExists(_ Context, addr sdk.AccAddress) error {
_, ok := t.Accounts[addr.String()]
if !ok {
return fmt.Errorf("ensureExists: account %s not found", addr)
}
return nil
func (t TestAccountRetriever) EnsureExists(clientCtx Context, addr sdk.AccAddress) error {
_, err := t.GetAccount(clientCtx, addr)
return err
}
// GetAccountNumberSequence implements AccountRetriever.GetAccountNumberSequence
func (t TestAccountRetriever) GetAccountNumberSequence(_ Context, addr sdk.AccAddress) (accNum, accSeq uint64, err error) {
acc, ok := t.Accounts[addr.String()]
if !ok {
return 0, 0, fmt.Errorf("accountNumberSequence: account %s not found", addr)
func (t TestAccountRetriever) GetAccountNumberSequence(clientCtx Context, addr sdk.AccAddress) (accNum, accSeq uint64, err error) {
acc, err := t.GetAccount(clientCtx, addr)
if err != nil {
return 0, 0, err
}
return acc.Num, acc.Seq, nil
return acc.GetAccountNumber(), acc.GetSequence(), nil
}

11
client/tx/aux_builder_test.go
View File

@ -26,8 +26,9 @@ const (
var (
_, pub1, addr1 = testdata.KeyTestPubAddr()
addr1Str, _ = testutil.CodecOptions{}.GetAddressCodec().BytesToString(addr1)
rawSig = []byte("dummy")
msg1 = &countertypes.MsgIncreaseCounter{Signer: addr1.String(), Count: 1}
msg1 = &countertypes.MsgIncreaseCounter{Signer: addr1Str, Count: 1}
chainID = "test-chain"
)
@ -131,7 +132,7 @@ func TestAuxTxBuilder(t *testing.T) {
func() error {
require.NoError(t, b.SetMsgs(msg1))
require.NoError(t, b.SetPubKey(pub1))
b.SetAddress(addr1.String())
b.SetAddress(addr1Str)
require.NoError(t, b.SetSignMode(signing.SignMode_SIGN_MODE_DIRECT_AUX))
_, err := b.GetSignBytes()
@ -152,7 +153,7 @@ func TestAuxTxBuilder(t *testing.T) {
b.SetChainID(chainID)
require.NoError(t, b.SetMsgs(msg1))
require.NoError(t, b.SetPubKey(pub1))
b.SetAddress(addr1.String())
b.SetAddress(addr1Str)
err := b.SetSignMode(signing.SignMode_SIGN_MODE_DIRECT_AUX)
require.NoError(t, err)
@ -174,7 +175,7 @@ func TestAuxTxBuilder(t *testing.T) {
func() error {
require.NoError(t, b.SetMsgs(msg1))
require.NoError(t, b.SetPubKey(pub1))
b.SetAddress(addr1.String())
b.SetAddress(addr1Str)
err := b.SetSignMode(signing.SignMode_SIGN_MODE_LEGACY_AMINO_JSON)
require.NoError(t, err)
@ -193,7 +194,7 @@ func TestAuxTxBuilder(t *testing.T) {
b.SetChainID(chainID)
require.NoError(t, b.SetMsgs(msg1))
require.NoError(t, b.SetPubKey(pub1))
b.SetAddress(addr1.String())
b.SetAddress(addr1Str)
err := b.SetSignMode(signing.SignMode_SIGN_MODE_LEGACY_AMINO_JSON)
require.NoError(t, err)

7
client/tx/tx.go
View File

@ -382,7 +382,12 @@ func makeAuxSignerData(clientCtx client.Context, f Factory, msgs ...sdk.Msg) (tx
return tx.AuxSignerData{}, err
}
b.SetAddress(fromAddress.String())
fromAddrStr, err := clientCtx.AddressCodec.BytesToString(fromAddress)
if err != nil {
return tx.AuxSignerData{}, err
}
b.SetAddress(fromAddrStr)
if clientCtx.Offline {
b.SetAccountNumber(f.accountNumber)
b.SetSequence(f.sequence)

36
client/tx/tx_test.go
View File

@ -30,6 +30,8 @@ import (
signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing"
)
var ac = testutil.CodecOptions{}.GetAddressCodec()
func newTestTxConfig() (client.TxConfig, codec.Codec) {
encodingConfig := moduletestutil.MakeTestEncodingConfig(testutil.CodecOptions{})
cdc := codec.NewProtoCodec(encodingConfig.InterfaceRegistry)
@ -130,8 +132,11 @@ func TestBuildSimTx(t *testing.T) {
_, _, err = kb.NewMnemonic("test_key1", keyring.English, path, keyring.DefaultBIP39Passphrase, hd.Secp256k1)
require.NoError(t, err)
fromAddr, err := ac.BytesToString(sdk.AccAddress("from"))
require.NoError(t, err)
txf := mockTxFactory(txCfg).WithSignMode(defaultSignMode).WithKeybase(kb)
msg := &countertypes.MsgIncreaseCounter{Signer: sdk.AccAddress("from").String(), Count: 1}
msg := &countertypes.MsgIncreaseCounter{Signer: fromAddr, Count: 1}
bz, err := txf.BuildSimTx(msg)
require.NoError(t, err)
require.NotNil(t, bz)
@ -146,8 +151,10 @@ func TestBuildUnsignedTx(t *testing.T) {
_, _, err = kb.NewMnemonic("test_key1", keyring.English, path, keyring.DefaultBIP39Passphrase, hd.Secp256k1)
require.NoError(t, err)
fromAddr, err := ac.BytesToString(sdk.AccAddress("from"))
require.NoError(t, err)
txf := mockTxFactory(txConfig).WithKeybase(kb)
msg := &countertypes.MsgIncreaseCounter{Signer: sdk.AccAddress("from").String(), Count: 1}
msg := &countertypes.MsgIncreaseCounter{Signer: fromAddr, Count: 1}
tx, err := txf.BuildUnsignedTx(msg)
require.NoError(t, err)
require.NotNil(t, tx)
@ -165,8 +172,11 @@ func TestBuildUnsignedTxWithWithExtensionOptions(t *testing.T) {
Value: []byte("test"),
},
}
fromAddr, err := ac.BytesToString(sdk.AccAddress("from"))
require.NoError(t, err)
txf := mockTxFactory(txCfg).WithExtensionOptions(extOpts...)
msg := &countertypes.MsgIncreaseCounter{Signer: sdk.AccAddress("from").String(), Count: 1}
msg := &countertypes.MsgIncreaseCounter{Signer: fromAddr, Count: 1}
tx, err := txf.BuildUnsignedTx(msg)
require.NoError(t, err)
require.NotNil(t, tx)
@ -209,7 +219,9 @@ func TestMnemonicInMemo(t *testing.T) {
WithChainID("test-chain").
WithKeybase(kb)
msg := &countertypes.MsgIncreaseCounter{Signer: sdk.AccAddress("from").String(), Count: 1}
fromAddr, err := ac.BytesToString(sdk.AccAddress("from"))
require.NoError(t, err)
msg := &countertypes.MsgIncreaseCounter{Signer: fromAddr, Count: 1}
tx, err := txf.BuildUnsignedTx(msg)
if tc.error {
require.Error(t, err)
@ -260,8 +272,12 @@ func TestSign(t *testing.T) {
requireT.NoError(err)
addr2, err := k2.GetAddress()
requireT.NoError(err)
msg1 := &countertypes.MsgIncreaseCounter{Signer: addr1.String(), Count: 1}
msg2 := &countertypes.MsgIncreaseCounter{Signer: addr2.String(), Count: 1}
addr1Str, err := ac.BytesToString(addr1)
require.NoError(t, err)
addr2Str, err := ac.BytesToString(addr2)
require.NoError(t, err)
msg1 := &countertypes.MsgIncreaseCounter{Signer: addr1Str, Count: 1}
msg2 := &countertypes.MsgIncreaseCounter{Signer: addr2Str, Count: 1}
txb, err := txfNoKeybase.BuildUnsignedTx(msg1, msg2)
requireT.NoError(err)
txb2, err := txfNoKeybase.BuildUnsignedTx(msg1, msg2)
@ -414,8 +430,12 @@ func TestPreprocessHook(t *testing.T) {
addr1, err := kr.GetAddress()
requireT.NoError(err)
msg1 := &countertypes.MsgIncreaseCounter{Signer: addr1.String(), Count: 1}
msg2 := &countertypes.MsgIncreaseCounter{Signer: addr2.String(), Count: 1}
addr1Str, err := ac.BytesToString(addr1)
require.NoError(t, err)
addr2Str, err := ac.BytesToString(addr2)
require.NoError(t, err)
msg1 := &countertypes.MsgIncreaseCounter{Signer: addr1Str, Count: 1}
msg2 := &countertypes.MsgIncreaseCounter{Signer: addr2Str, Count: 1}
txb, err := txfDirect.BuildUnsignedTx(msg1, msg2)
requireT.NoError(err)

24
codec/bench_test.go
View File

@ -8,6 +8,7 @@ import (
"google.golang.org/protobuf/types/dynamicpb"
counterv1 "cosmossdk.io/api/cosmos/counter/v1"
"cosmossdk.io/core/address"
codectestutil "github.com/cosmos/cosmos-sdk/codec/testutil"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
@ -16,21 +17,26 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
)
var ac = codectestutil.CodecOptions{}.GetAddressCodec()
type msgCounterWrapper struct {
*countertypes.MsgIncreaseCounter
ac address.Codec
}
func (msg msgCounterWrapper) GetSigners() []sdk.AccAddress {
fromAddress, _ := sdk.AccAddressFromBech32(msg.Signer)
fromAddress, _ := msg.ac.StringToBytes(msg.Signer)
return []sdk.AccAddress{fromAddress}
}
func BenchmarkLegacyGetSigners(b *testing.B) {
_, _, addr := testdata.KeyTestPubAddr()
addrStr, err := ac.BytesToString(addr)
require.NoError(b, err)
msg := msgCounterWrapper{&countertypes.MsgIncreaseCounter{
Signer: addr.String(),
Signer: addrStr,
Count: 2,
}}
}, ac}
b.ResetTimer()
for i := 0; i < b.N; i++ {
@ -42,9 +48,11 @@ func BenchmarkProtoreflectGetSigners(b *testing.B) {
cdc := codectestutil.CodecOptions{}.NewCodec()
signingCtx := cdc.InterfaceRegistry().SigningContext()
_, _, addr := testdata.KeyTestPubAddr()
addrStr, err := ac.BytesToString(addr)
require.NoError(b, err)
// use a pulsar message
msg := &counterv1.MsgIncreaseCounter{
Signer: addr.String(),
Signer: addrStr,
Count: 1,
}
@ -60,9 +68,11 @@ func BenchmarkProtoreflectGetSigners(b *testing.B) {
func BenchmarkProtoreflectGetSignersWithUnmarshal(b *testing.B) {
cdc := codectestutil.CodecOptions{}.NewCodec()
_, _, addr := testdata.KeyTestPubAddr()
addrStr, err := ac.BytesToString(addr)
require.NoError(b, err)
// start with a protoreflect message
msg := &countertypes.MsgIncreaseCounter{
Signer: addr.String(),
Signer: addrStr,
Count: 1,
}
// marshal to an any first because this is what we get from the wire
@ -82,8 +92,10 @@ func BenchmarkProtoreflectGetSignersDynamicpb(b *testing.B) {
cdc := codectestutil.CodecOptions{}.NewCodec()
signingCtx := cdc.InterfaceRegistry().SigningContext()
_, _, addr := testdata.KeyTestPubAddr()
addrStr, err := ac.BytesToString(addr)
require.NoError(b, err)
msg := &counterv1.MsgIncreaseCounter{
Signer: addr.String(),
Signer: addrStr,
Count: 1,
}
bz, err := protov2.Marshal(msg)

19
codec/proto_codec_test.go
View File

@ -17,6 +17,7 @@ import (
"cosmossdk.io/x/tx/signing"
"github.com/cosmos/cosmos-sdk/codec"
codectestutil "github.com/cosmos/cosmos-sdk/codec/testutil"
"github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
countertypes "github.com/cosmos/cosmos-sdk/testutil/x/counter/types"
@ -176,17 +177,19 @@ func BenchmarkProtoCodecMarshalLengthPrefixed(b *testing.B) {
}
func TestGetSigners(t *testing.T) {
cdcOpts := codectestutil.CodecOptions{}
interfaceRegistry, err := types.NewInterfaceRegistryWithOptions(types.InterfaceRegistryOptions{
SigningOptions: signing.Options{
AddressCodec: testAddressCodec{},
ValidatorAddressCodec: testAddressCodec{},
AddressCodec: cdcOpts.GetAddressCodec(),
ValidatorAddressCodec: cdcOpts.GetValidatorCodec(),
},
ProtoFiles: protoregistry.GlobalFiles,
})
require.NoError(t, err)
cdc := codec.NewProtoCodec(interfaceRegistry)
testAddr := sdk.AccAddress("test")
testAddrStr := testAddr.String()
testAddrStr, err := cdcOpts.GetAddressCodec().BytesToString(testAddr)
require.NoError(t, err)
msgSendV1 := &countertypes.MsgIncreaseCounter{Signer: testAddrStr, Count: 1}
msgSendV2 := &counterv1.MsgIncreaseCounter{Signer: testAddrStr, Count: 1}
@ -207,13 +210,3 @@ func TestGetSigners(t *testing.T) {
require.Equal(t, [][]byte{testAddr}, signers)
require.True(t, protov2.Equal(msgSendV2, msgSendV2Copy.Interface()))
}
type testAddressCodec struct{}
func (t testAddressCodec) StringToBytes(text string) ([]byte, error) {
return sdk.AccAddressFromBech32(text)
}
func (t testAddressCodec) BytesToString(bz []byte) (string, error) {
return sdk.AccAddress(bz).String(), nil
}

3
crypto/keyring/keyring_test.go
View File

@ -17,6 +17,7 @@ import (
"golang.org/x/crypto/bcrypt"
"github.com/cosmos/cosmos-sdk/codec"
codectestutil "github.com/cosmos/cosmos-sdk/codec/testutil"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/crypto"
cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
@ -223,7 +224,7 @@ func TestNewKey(t *testing.T) {
_, err = kb.KeyByAddress(addr)
require.NoError(t, err)
addr, err = sdk.AccAddressFromBech32("cosmos1yq8lgssgxlx9smjhes6ryjasmqmd3ts2559g0t")
addr, err = codectestutil.CodecOptions{}.GetAddressCodec().StringToBytes("cosmos1yq8lgssgxlx9smjhes6ryjasmqmd3ts2559g0t")
require.NoError(t, err)
_, err = kb.KeyByAddress(addr)
require.NotNil(t, err)

8
crypto/ledger/ledger_mock.go
View File

@ -12,10 +12,10 @@ import (
secp "github.com/decred/dcrd/dcrec/secp256k1/v4"
"github.com/decred/dcrd/dcrec/secp256k1/v4/ecdsa"
codectestutil "github.com/cosmos/cosmos-sdk/codec/testutil"
"github.com/cosmos/cosmos-sdk/crypto/hd"
csecp256k1 "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// If ledger support (build tag) has been enabled, which implies a CGO dependency,
@ -78,7 +78,11 @@ func (mock LedgerSECP256K1Mock) GetAddressPubKeySECP256K1(derivationPath []uint3
// Generate the bech32 addr using existing cmtcrypto/etc.
pub := &csecp256k1.PubKey{Key: compressedPublicKey}
addr := sdk.AccAddress(pub.Address()).String()
addr, err := codectestutil.CodecOptions{}.GetAddressCodec().BytesToString(pub.Address())
if err != nil {
return nil, "", err
}
return pk, addr, err
}

13
crypto/ledger/ledger_test.go
View File

@ -10,12 +10,15 @@ import (
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/codec/legacy"
codectestutil "github.com/cosmos/cosmos-sdk/codec/testutil"
"github.com/cosmos/cosmos-sdk/crypto/hd"
"github.com/cosmos/cosmos-sdk/crypto/types"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
sdk "github.com/cosmos/cosmos-sdk/types"
)
var ac = codectestutil.CodecOptions{}.GetAddressCodec()
func TestPublicKeyUnsafe(t *testing.T) {
path := *hd.NewFundraiserParams(0, sdk.CoinType, 0)
priv, err := NewPrivKeySecp256k1Unsafe(path)
@ -31,7 +34,8 @@ func checkDefaultPubKey(t *testing.T, priv types.LedgerPrivKey) {
fmt.Sprintf("%x", cdc.Amino.MustMarshalBinaryBare(priv.PubKey())),
"Is your device using test mnemonic: %s ?", testdata.TestMnemonic)
require.Equal(t, expectedPkStr, priv.PubKey().String())
addr := sdk.AccAddress(priv.PubKey().Address()).String()
addr, err := ac.BytesToString(priv.PubKey().Address())
require.NoError(t, err)
require.Equal(t, "cosmos1w34k53py5v5xyluazqpq65agyajavep2rflq6h",
addr, "Is your device using test mnemonic: %s ?", testdata.TestMnemonic)
}
@ -98,7 +102,8 @@ func TestPublicKeySafe(t *testing.T) {
require.Nil(t, ShowAddress(path, priv.PubKey(), "cosmos"))
checkDefaultPubKey(t, priv)
addr2 := sdk.AccAddress(priv.PubKey().Address()).String()
addr2, err := ac.BytesToString(priv.PubKey().Address())
require.NoError(t, err)
require.Equal(t, addr, addr2)
}
@ -143,7 +148,9 @@ func TestPublicKeyHDPath(t *testing.T) {
require.NotNil(t, addr)
require.NotNil(t, priv)
addr2 := sdk.AccAddress(priv.PubKey().Address()).String()
addr2, err := ac.BytesToString(priv.PubKey().Address())
require.NoError(t, err)
require.Equal(t, addr2, addr)
require.Equal(t,
expectedAddrs[i], addr,

50
simapp/app.go
View File

@ -18,6 +18,7 @@ import (
reflectionv1 "cosmossdk.io/api/cosmos/reflection/v1"
"cosmossdk.io/client/v2/autocli"
clienthelpers "cosmossdk.io/client/v2/helpers"
coreaddress "cosmossdk.io/core/address"
corestore "cosmossdk.io/core/store"
"cosmossdk.io/log"
storetypes "cosmossdk.io/store/types"
@ -214,6 +215,11 @@ func NewSimApp(
signingCtx := interfaceRegistry.SigningContext()
txConfig := authtx.NewTxConfig(appCodec, signingCtx.AddressCodec(), signingCtx.ValidatorAddressCodec(), authtx.DefaultSignModes)
govModuleAddr, err := signingCtx.AddressCodec().BytesToString(authtypes.NewModuleAddress(govtypes.ModuleName))
if err != nil {
panic(err)
}
if err := signingCtx.Validate(); err != nil {
panic(err)
}
@ -287,7 +293,7 @@ func NewSimApp(
cometService := runtime.NewContextAwareCometInfoService()
// set the BaseApp's parameter store
app.ConsensusParamsKeeper = consensusparamkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[consensustypes.StoreKey]), logger.With(log.ModuleKey, "x/consensus")), authtypes.NewModuleAddress(govtypes.ModuleName).String())
app.ConsensusParamsKeeper = consensusparamkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[consensustypes.StoreKey]), logger.With(log.ModuleKey, "x/consensus")), govModuleAddr)
bApp.SetParamStore(app.ConsensusParamsKeeper.ParamsStore)
// add keepers
@ -312,14 +318,18 @@ func NewSimApp(
}
app.AccountsKeeper = accountsKeeper
app.AuthKeeper = authkeeper.NewAccountKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[authtypes.StoreKey]), logger.With(log.ModuleKey, "x/auth")), appCodec, authtypes.ProtoBaseAccount, accountsKeeper, maccPerms, signingCtx.AddressCodec(), sdk.Bech32MainPrefix, authtypes.NewModuleAddress(govtypes.ModuleName).String())
app.AuthKeeper = authkeeper.NewAccountKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[authtypes.StoreKey]), logger.With(log.ModuleKey, "x/auth")), appCodec, authtypes.ProtoBaseAccount, accountsKeeper, maccPerms, signingCtx.AddressCodec(), sdk.Bech32MainPrefix, govModuleAddr)
blockedAddrs, err := BlockedAddresses(signingCtx.AddressCodec())
if err != nil {
panic(err)
}
app.BankKeeper = bankkeeper.NewBaseKeeper(
runtime.NewEnvironment(runtime.NewKVStoreService(keys[banktypes.StoreKey]), logger.With(log.ModuleKey, "x/bank")),
appCodec,
app.AuthKeeper,
BlockedAddresses(),
authtypes.NewModuleAddress(govtypes.ModuleName).String(),
blockedAddrs,
govModuleAddr,
)
// optional: enable sign mode textual by overwriting the default tx config (after setting the bank keeper)
@ -350,20 +360,20 @@ func NewSimApp(
runtime.EnvWithQueryRouterService(app.GRPCQueryRouter())),
app.AuthKeeper,
app.BankKeeper,
authtypes.NewModuleAddress(govtypes.ModuleName).String(),
govModuleAddr,
signingCtx.ValidatorAddressCodec(),
authcodec.NewBech32Codec(sdk.Bech32PrefixConsAddr),
cometService,
)
app.MintKeeper = mintkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[minttypes.StoreKey]), logger.With(log.ModuleKey, "x/mint")), app.StakingKeeper, app.AuthKeeper, app.BankKeeper, authtypes.FeeCollectorName, authtypes.NewModuleAddress(govtypes.ModuleName).String())
app.MintKeeper = mintkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[minttypes.StoreKey]), logger.With(log.ModuleKey, "x/mint")), app.StakingKeeper, app.AuthKeeper, app.BankKeeper, authtypes.FeeCollectorName, govModuleAddr)
app.PoolKeeper = poolkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[pooltypes.StoreKey]), logger.With(log.ModuleKey, "x/protocolpool")), app.AuthKeeper, app.BankKeeper, app.StakingKeeper, authtypes.NewModuleAddress(govtypes.ModuleName).String())
app.PoolKeeper = poolkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[pooltypes.StoreKey]), logger.With(log.ModuleKey, "x/protocolpool")), app.AuthKeeper, app.BankKeeper, app.StakingKeeper, govModuleAddr)
app.DistrKeeper = distrkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[distrtypes.StoreKey]), logger.With(log.ModuleKey, "x/distribution")), app.AuthKeeper, app.BankKeeper, app.StakingKeeper, cometService, authtypes.FeeCollectorName, authtypes.NewModuleAddress(govtypes.ModuleName).String())
app.DistrKeeper = distrkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[distrtypes.StoreKey]), logger.With(log.ModuleKey, "x/distribution")), app.AuthKeeper, app.BankKeeper, app.StakingKeeper, cometService, authtypes.FeeCollectorName, govModuleAddr)
app.SlashingKeeper = slashingkeeper.NewKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[slashingtypes.StoreKey]), logger.With(log.ModuleKey, "x/slashing")),
appCodec, legacyAmino, app.StakingKeeper, authtypes.NewModuleAddress(govtypes.ModuleName).String(),
appCodec, legacyAmino, app.StakingKeeper, govModuleAddr,
)
app.FeeGrantKeeper = feegrantkeeper.NewKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[feegrant.StoreKey]), logger.With(log.ModuleKey, "x/feegrant")), appCodec, app.AuthKeeper)
@ -374,7 +384,7 @@ func NewSimApp(
stakingtypes.NewMultiStakingHooks(app.DistrKeeper.Hooks(), app.SlashingKeeper.Hooks()),
)
app.CircuitKeeper = circuitkeeper.NewKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[circuittypes.StoreKey]), logger.With(log.ModuleKey, "x/circuit")), appCodec, authtypes.NewModuleAddress(govtypes.ModuleName).String(), app.AuthKeeper.AddressCodec())
app.CircuitKeeper = circuitkeeper.NewKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[circuittypes.StoreKey]), logger.With(log.ModuleKey, "x/circuit")), appCodec, govModuleAddr, app.AuthKeeper.AddressCodec())
app.BaseApp.SetCircuitBreaker(&app.CircuitKeeper)
app.AuthzKeeper = authzkeeper.NewKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[authzkeeper.StoreKey]), logger.With(log.ModuleKey, "x/authz"), runtime.EnvWithMsgRouterService(app.MsgServiceRouter()), runtime.EnvWithQueryRouterService(app.GRPCQueryRouter())), appCodec, app.AuthKeeper)
@ -396,7 +406,7 @@ func NewSimApp(
}
homePath := cast.ToString(appOpts.Get(flags.FlagHome))
// set the governance module account as the authority for conducting upgrades
app.UpgradeKeeper = upgradekeeper.NewKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[upgradetypes.StoreKey]), logger.With(log.ModuleKey, "x/upgrade"), runtime.EnvWithMsgRouterService(app.MsgServiceRouter()), runtime.EnvWithQueryRouterService(app.GRPCQueryRouter())), skipUpgradeHeights, appCodec, homePath, app.BaseApp, authtypes.NewModuleAddress(govtypes.ModuleName).String())
app.UpgradeKeeper = upgradekeeper.NewKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[upgradetypes.StoreKey]), logger.With(log.ModuleKey, "x/upgrade"), runtime.EnvWithMsgRouterService(app.MsgServiceRouter()), runtime.EnvWithQueryRouterService(app.GRPCQueryRouter())), skipUpgradeHeights, appCodec, homePath, app.BaseApp, govModuleAddr)
// Register the proposal types
// Deprecated: Avoid adding new handlers, instead use the new proposal flow
@ -408,7 +418,7 @@ func NewSimApp(
Example of setting gov params:
govConfig.MaxMetadataLen = 10000
*/
govKeeper := govkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[govtypes.StoreKey]), logger.With(log.ModuleKey, "x/gov"), runtime.EnvWithMsgRouterService(app.MsgServiceRouter()), runtime.EnvWithQueryRouterService(app.GRPCQueryRouter())), app.AuthKeeper, app.BankKeeper, app.StakingKeeper, app.PoolKeeper, govConfig, authtypes.NewModuleAddress(govtypes.ModuleName).String())
govKeeper := govkeeper.NewKeeper(appCodec, runtime.NewEnvironment(runtime.NewKVStoreService(keys[govtypes.StoreKey]), logger.With(log.ModuleKey, "x/gov"), runtime.EnvWithMsgRouterService(app.MsgServiceRouter()), runtime.EnvWithQueryRouterService(app.GRPCQueryRouter())), app.AuthKeeper, app.BankKeeper, app.StakingKeeper, app.PoolKeeper, govConfig, govModuleAddr)
// Set legacy router for backwards compatibility with gov v1beta1
govKeeper.SetLegacyRouter(govRouter)
@ -823,14 +833,22 @@ func GetMaccPerms() map[string][]string {
}
// BlockedAddresses returns all the app's blocked account addresses.
func BlockedAddresses() map[string]bool {
func BlockedAddresses(ac coreaddress.Codec) (map[string]bool, error) {
modAccAddrs := make(map[string]bool)
for acc := range GetMaccPerms() {
modAccAddrs[authtypes.NewModuleAddress(acc).String()] = true
addr, err := ac.BytesToString(authtypes.NewModuleAddress(acc))
if err != nil {
return nil, err
}
modAccAddrs[addr] = true
}
// allow the following addresses to receive funds
delete(modAccAddrs, authtypes.NewModuleAddress(govtypes.ModuleName).String())
addr, err := ac.BytesToString(authtypes.NewModuleAddress(govtypes.ModuleName))
if err != nil {
return nil, err
}
delete(modAccAddrs, addr)
return modAccAddrs
return modAccAddrs, nil
}

7
simapp/app_di.go
View File

@ -8,6 +8,7 @@ import (
"io"
clienthelpers "cosmossdk.io/client/v2/helpers"
"cosmossdk.io/core/address"
"cosmossdk.io/core/appmodule"
"cosmossdk.io/core/legacy"
corestore "cosmossdk.io/core/store"
@ -370,7 +371,9 @@ func GetMaccPerms() map[string][]string {
}
// BlockedAddresses returns all the app's blocked account addresses.
func BlockedAddresses() map[string]bool {
// This function takes an address.Codec parameter to maintain compatibility
// with the signature of the same function in appV1.
func BlockedAddresses(_ address.Codec) (map[string]bool, error) {
result := make(map[string]bool)
if len(blockAccAddrs) > 0 {
@ -383,5 +386,5 @@ func BlockedAddresses() map[string]bool {
}
}
return result
return result, nil
}

10
simapp/app_test.go
View File

@ -51,10 +51,12 @@ func TestSimAppExportAndBlockedAddrs(t *testing.T) {
AppOpts: simtestutil.NewAppOptionsWithFlagHome(t.TempDir()),
})
// BlockedAddresses returns a map of addresses in app v1 and a map of modules name in app di.
for acc := range BlockedAddresses() {
// BlockedAddresses returns a map of addresses in app v1 and a map of modules names in app di.
blockedAddrs, err := BlockedAddresses(app.interfaceRegistry.SigningContext().AddressCodec())
require.NoError(t, err)
for acc := range blockedAddrs {
var addr sdk.AccAddress
if modAddr, err := sdk.AccAddressFromBech32(acc); err == nil {
if modAddr, err := app.InterfaceRegistry().SigningContext().AddressCodec().StringToBytes(acc); err == nil {
addr = modAddr
} else {
addr = app.AuthKeeper.GetModuleAddress(acc)
@ -68,7 +70,7 @@ func TestSimAppExportAndBlockedAddrs(t *testing.T) {
}
// finalize block so we have CheckTx state set
_, err := app.FinalizeBlock(&abci.FinalizeBlockRequest{
_, err = app.FinalizeBlock(&abci.FinalizeBlockRequest{
Height: 1,
})
require.NoError(t, err)

30
simapp/export.go
View File

@ -64,7 +64,7 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
allowedAddrsMap := make(map[string]bool)
for _, addr := range jailAllowedAddrs {
_, err := sdk.ValAddressFromBech32(addr)
_, err := app.InterfaceRegistry().SigningContext().ValidatorAddressCodec().StringToBytes(addr)
if err != nil {
panic(err)
}
@ -93,8 +93,15 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
}
for _, delegation := range dels {
valAddr:= sdk.MustValAddressFromBech32(delegation.ValidatorAddress)
delAddr := sdk.MustAccAddressFromBech32(delegation.DelegatorAddress)
valAddr, err := app.InterfaceRegistry().SigningContext().ValidatorAddressCodec().StringToBytes(delegation.ValidatorAddress)
if err != nil {
panic(err)
}
delAddr, err := app.InterfaceRegistry().SigningContext().AddressCodec().StringToBytes(delegation.DelegatorAddress)
if err != nil {
panic(err)
}
_, _ = app.DistrKeeper.WithdrawDelegationRewards(ctx, delAddr, valAddr)
}
@ -146,8 +153,14 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
// reinitialize all delegations
for _, del := range dels {
valAddr := sdk.MustValAddressFromBech32(del.ValidatorAddress)
delAddr := sdk.MustAccAddressFromBech32(del.DelegatorAddress)
valAddr, err := app.InterfaceRegistry().SigningContext().ValidatorAddressCodec().StringToBytes(del.ValidatorAddress)
if err != nil {
panic(err)
}
delAddr, err := app.InterfaceRegistry().SigningContext().AddressCodec().StringToBytes(del.DelegatorAddress)
if err != nil {
panic(err)
}
if err := app.DistrKeeper.Hooks().BeforeDelegationCreated(ctx, delAddr, valAddr); err != nil {
// never called as BeforeDelegationCreated always returns nil
@ -211,8 +224,13 @@ func (app *SimApp) prepForZeroHeightGenesis(ctx sdk.Context, jailAllowedAddrs []
panic("expected validator, not found")
}
valAddr, err := app.StakingKeeper.ValidatorAddressCodec().BytesToString(addr)
if err != nil {
panic(err)
}
validator.UnbondingHeight = 0
if applyAllowedAddrs && !allowedAddrsMap[addr.String()] {
if applyAllowedAddrs && !allowedAddrsMap[valAddr] {
validator.Jailed = true
}

5
simapp/sim_bench_test.go
View File

@ -58,6 +58,9 @@ func BenchmarkFullAppSimulation(b *testing.B) {
app := NewSimApp(logger, db, nil, true, appOptions, interBlockCacheOpt(), baseapp.SetChainID(sims.SimAppChainID))
blockedAddrs, err := BlockedAddresses(app.InterfaceRegistry().SigningContext().AddressCodec())
require.NoError(b, err)
// run randomized simulation
simParams, simErr := simulation.SimulateFromSeedX(
b,
@ -67,7 +70,7 @@ func BenchmarkFullAppSimulation(b *testing.B) {
simtestutil.AppStateFn(app.AppCodec(), app.AuthKeeper.AddressCodec(), app.StakingKeeper.ValidatorAddressCodec(), app.SimulationManager(), app.DefaultGenesis()),
simtypes.RandomAccounts,
simtestutil.SimulationOperations(app, app.AppCodec(), config, app.txConfig),
BlockedAddresses(),
blockedAddrs,
config,
app.AppCodec(),
app.txConfig.SigningContext().AddressCodec(),

3
simapp/sim_test.go
View File

@ -55,10 +55,11 @@ func TestFullAppSimulation(t *testing.T) {
}
func setupStateFactory(app *SimApp) sims.SimStateFactory {
blockedAddre, _ := BlockedAddresses(app.interfaceRegistry.SigningContext().AddressCodec())
return sims.SimStateFactory{
Codec: app.AppCodec(),
AppStateFn: simtestutil.AppStateFn(app.AppCodec(), app.AuthKeeper.AddressCodec(), app.StakingKeeper.ValidatorAddressCodec(), app.SimulationManager(), app.DefaultGenesis()),
BlockedAddr: BlockedAddresses(),
BlockedAddr: blockedAddre,
}
}

7
simapp/simd/cmd/testnet.go
View File

@ -336,7 +336,12 @@ func initTestnetFiles(
sdk.NewCoin(args.bondTokenDenom, accStakingTokens),
}
genBalances = append(genBalances, banktypes.Balance{Address: addr.String(), Coins: coins.Sort()})
addrStr, err := clientCtx.AddressCodec.BytesToString(addr)
if err != nil {
return err
}
genBalances = append(genBalances, banktypes.Balance{Address: addrStr, Coins: coins.Sort()})
genAccounts = append(genAccounts, authtypes.NewBaseAccount(addr, nil, 0, 0))
valStr, err := clientCtx.ValidatorAddressCodec.BytesToString(addr)

17
simapp/test_helpers.go
View File

@ -64,15 +64,19 @@ func NewSimappWithCustomOptions(t *testing.T, isCheckTx bool, options SetupOptio
validator := cmttypes.NewValidator(pubKey, 1)
valSet := cmttypes.NewValidatorSet([]*cmttypes.Validator{validator})
app := NewSimApp(options.Logger, options.DB, nil, true, options.AppOpts)
// generate genesis account
senderPrivKey := secp256k1.GenPrivKey()
acc := authtypes.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), 0, 0)
accAddr, err := app.InterfaceRegistry().SigningContext().AddressCodec().BytesToString(acc.GetAddress())
require.NoError(t, err)
balance := banktypes.Balance{
Address: acc.GetAddress().String(),
Address: accAddr,
Coins: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(100000000000000))),
}
app := NewSimApp(options.Logger, options.DB, nil, true, options.AppOpts)
genesisState := app.DefaultGenesis()
genesisState, err = simtestutil.GenesisStateWithValSet(app.AppCodec(), genesisState, valSet, []authtypes.GenesisAccount{acc}, balance)
require.NoError(t, err)
@ -106,11 +110,14 @@ func Setup(t *testing.T, isCheckTx bool) *SimApp {
validator := cmttypes.NewValidator(pubKey, 1)
valSet := cmttypes.NewValidatorSet([]*cmttypes.Validator{validator})
sApp, _ := setup(true, 0)
// generate genesis account
senderPrivKey := secp256k1.GenPrivKey()
acc := authtypes.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), 0, 0)
accAddr, err := sApp.interfaceRegistry.SigningContext().AddressCodec().BytesToString(acc.GetAddress())
require.NoError(t, err)
balance := banktypes.Balance{
Address: acc.GetAddress().String(),
Address: accAddr,
Coins: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(100000000000000))),
}
@ -169,9 +176,11 @@ func GenesisStateWithSingleValidator(t *testing.T, app *SimApp) GenesisState {
// generate genesis account
senderPrivKey := secp256k1.GenPrivKey()
acc := authtypes.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), 0, 0)
accAddr, err := app.interfaceRegistry.SigningContext().AddressCodec().BytesToString(acc.GetAddress())
require.NoError(t, err)
balances := []banktypes.Balance{
{
Address: acc.GetAddress().String(),
Address: accAddr,
Coins: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(100000000000000))),
},
}

4
simapp/v2/app_test.go
View File

@ -53,8 +53,10 @@ func NewTestApp(t *testing.T) (*SimApp[transaction.Tx], context.Context) {
// generate genesis account
senderPrivKey := secp256k1.GenPrivKey()
acc := authtypes.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), 0, 0)
accAddr, err := app.txConfig.SigningContext().AddressCodec().BytesToString(acc.GetAddress())
require.NoError(t, err)
balance := banktypes.Balance{
Address: acc.GetAddress().String(),
Address: accAddr,
Coins: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(100000000000000))),
}

6
simapp/v2/simdv2/cmd/testnet.go
View File

@ -279,7 +279,11 @@ func initTestnetFiles[T transaction.Tx](
sdk.NewCoin(args.bondTokenDenom, accStakingTokens),
}
genBalances = append(genBalances, banktypes.Balance{Address: addr.String(), Coins: coins.Sort()})
addrStr, err := clientCtx.AddressCodec.BytesToString(addr)
if err != nil {
return err
}
genBalances = append(genBalances, banktypes.Balance{Address: addrStr, Coins: coins.Sort()})
genAccounts = append(genAccounts, authtypes.NewBaseAccount(addr, nil, 0, 0))
valStr, err := clientCtx.ValidatorAddressCodec.BytesToString(addr)

8
x/authz/keeper/keeper.go
View File

@ -290,8 +290,14 @@ func (k Keeper) DeleteAllGrants(ctx context.Context, granter sdk.AccAddress) err
return err
}
}
grantAddr, err := k.authKeeper.AddressCodec().BytesToString(granter)
if err != nil {
return err
}
return k.EventService.EventManager(ctx).Emit(&authz.EventRevokeAll{
Granter: granter.String(),
Granter: grantAddr,
})
}