certusone
/
wormhole
mirror of https://github.com/certusone/wormhole.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

wormchain: address comments on wormchain allowlisting

This commit is contained in:
Conor Patrick 2023-01-30 19:41:29 +00:00
parent 034358b55f
commit e30e762082
16 changed files with 374 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
wormchain/README.md
View File

@ -31,3 +31,13 @@ See [development.md](./development.md)
- [Cosmos SDK documentation](https://docs.cosmos.network)
- [Cosmos SDK Tutorials](https://tutorials.cosmos.network)
- [Discord](https://discord.gg/cosmosnetwork)
## Allowlists
Accounts on wormchain are allowlisted. To be able to submit a tx on wormchain, you must have an account that is either:
* A validator on wormchain that is part of a current or future guardian set, or
* An account that is allowlisted by a current validator on wormchain.
To create or delete an allowlist entry, you use a validator account. Allowlist entries can become stale,
meaning the owning validators are no longer part of the validator set. Any validator can delete or replace stale entries.
To manage allowlists, use the `wormchaind` client.

56
wormchain/app/app.go
View File

@ -16,7 +16,6 @@ import (
"github.com/cosmos/cosmos-sdk/server/config"
servertypes "github.com/cosmos/cosmos-sdk/server/types"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/types/module"
"github.com/cosmos/cosmos-sdk/version"
"github.com/cosmos/cosmos-sdk/x/auth"
@ -554,7 +553,7 @@ func New(
app.SetInitChainer(app.InitChainer)
app.SetBeginBlocker(app.BeginBlocker)
anteHandler, err := NewAnteHandler(
anteHandlerSdk, err := ante.NewAnteHandler(
ante.HandlerOptions{
AccountKeeper: app.AccountKeeper,
BankKeeper: app.BankKeeper,
@ -562,13 +561,13 @@ func New(
FeegrantKeeper: app.FeeGrantKeeper,
SigGasConsumer: ante.DefaultSigVerificationGasConsumer,
},
app.WormholeKeeper,
)
if err != nil {
panic(err)
}
wrappedAnteHandler := WrapAnteHandler(anteHandlerSdk, app.WormholeKeeper)
app.SetAnteHandler(anteHandler)
app.SetAnteHandler(wrappedAnteHandler)
app.SetEndBlocker(app.EndBlocker)
if loadLatest {
@ -585,45 +584,18 @@ func New(
return app
}
// Copied from https://github.com/wormhole-foundation/cosmos-sdk/blob/main/x/auth/ante/ante.go#L25
// I don't think there is currently a way to extend the list used in x/auth without copying it out.
func NewAnteHandler(options ante.HandlerOptions, wormKeeper wormholemodulekeeper.Keeper) (sdk.AnteHandler, error) {
if options.AccountKeeper == nil {
return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "account keeper is required for ante builder")
// Wrap the standard cosmos-sdk antehandlers with our wormhole allowlist antehandler.
func WrapAnteHandler(originalHandler sdk.AnteHandler, wormKeeper wormholemodulekeeper.Keeper) sdk.AnteHandler {
whHandler := wormholemoduleante.NewWormholeAllowlistDecorator(wormKeeper)
return func(ctx sdk.Context, tx sdk.Tx, simulate bool) (sdk.Context, error) {
newCtx, err := originalHandler(ctx, tx, simulate)
if err != nil {
return newCtx, err
}
return whHandler.AnteHandle(ctx, tx, simulate, func(ctx sdk.Context, tx sdk.Tx, simulate bool) (sdk.Context, error) {
return ctx, nil
})
}
if options.BankKeeper == nil {
return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "bank keeper is required for ante builder")
}
if options.SignModeHandler == nil {
return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder")
}
sigGasConsumer := options.SigGasConsumer
if sigGasConsumer == nil {
sigGasConsumer = ante.DefaultSigVerificationGasConsumer
}
anteDecorators := []sdk.AnteDecorator{
ante.NewSetUpContextDecorator(), // outermost AnteDecorator. SetUpContext must be called first
ante.NewRejectExtensionOptionsDecorator(),
ante.NewMempoolFeeDecorator(),
ante.NewValidateBasicDecorator(),
ante.NewTxTimeoutHeightDecorator(),
ante.NewValidateMemoDecorator(options.AccountKeeper),
ante.NewConsumeGasForTxSizeDecorator(options.AccountKeeper),
ante.NewDeductFeeDecorator(options.AccountKeeper, options.BankKeeper, options.FeegrantKeeper),
ante.NewSetPubKeyDecorator(options.AccountKeeper), // SetPubKeyDecorator must be called before all signature verification decorators
ante.NewValidateSigCountDecorator(options.AccountKeeper),
ante.NewSigGasConsumeDecorator(options.AccountKeeper, sigGasConsumer),
ante.NewSigVerificationDecorator(options.AccountKeeper, options.SignModeHandler),
ante.NewIncrementSequenceDecorator(options.AccountKeeper),
// our ante handler
wormholemoduleante.NewWormholeAllowlistDecorator(wormKeeper),
}
return sdk.ChainAnteDecorators(anteDecorators...), nil
}
// Name returns the name of the App

4
wormchain/proto/wormhole/query.proto
View File

@ -85,7 +85,7 @@ message QueryAllValidatorAllowlist {
// all allowlisted entries by all validators
message QueryAllValidatorAllowlistResponse {
repeated ValidatorAllowedAddress allowed_address = 1;
repeated ValidatorAllowedAddress allowlist = 1;
cosmos.base.query.v1beta1.PageResponse pagination = 2;
}
@ -97,7 +97,7 @@ message QueryValidatorAllowlist {
// all allowlisted entries by a specific validator
message QueryValidatorAllowlistResponse {
string validator_address = 1;
repeated ValidatorAllowedAddress allowed_address = 2;
repeated ValidatorAllowedAddress allowlist = 2;
cosmos.base.query.v1beta1.PageResponse pagination = 3;
}

8
wormchain/proto/wormhole/tx.proto
View File

@ -11,8 +11,8 @@ service Msg {
rpc ExecuteGovernanceVAA(MsgExecuteGovernanceVAA) returns (MsgExecuteGovernanceVAAResponse);
rpc RegisterAccountAsGuardian(MsgRegisterAccountAsGuardian) returns (MsgRegisterAccountAsGuardianResponse);
rpc CreateAllowlist(MsgCreateAllowlistRequest) returns (MsgAllowlistResponse);
rpc DeleteAllowlist(MsgDeleteAllowlistRequest) returns (MsgAllowlistResponse);
rpc CreateAllowlistEntry(MsgCreateAllowlistEntryRequest) returns (MsgAllowlistResponse);
rpc DeleteAllowlistEntry(MsgDeleteAllowlistEntryRequest) returns (MsgAllowlistResponse);
// StoreCode to submit Wasm code to the system
rpc StoreCode(MsgStoreCode) returns (MsgStoreCodeResponse);
@ -22,7 +22,7 @@ service Msg {
// this line is used by starport scaffolding # proto/tx/rpc
}
message MsgCreateAllowlistRequest {
message MsgCreateAllowlistEntryRequest {
// signer should be a guardian validator in a current set or future set.
string signer = 1;
// the address to allowlist
@ -31,7 +31,7 @@ message MsgCreateAllowlistRequest {
string name = 3;
}
message MsgDeleteAllowlistRequest {
message MsgDeleteAllowlistEntryRequest {
// signer should be a guardian validator in a current set or future set.
string signer = 1;
// the address allowlist to remove

4
wormchain/testutil/keeper/wormhole.go
View File

@ -115,7 +115,9 @@ func WormholeKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
supportedFeatures,
)
ctx := sdk.NewContext(stateStore, tmproto.Header{
Time: time.Now(),
Time: time.Now(),
// The height should be at least 1, because the allowlist antehandler
// passes everything at height 0 for gen tx's.
Height: 1,
}, false, log.NewNopLogger())
appapp.MountKVStores(keys)

27
wormchain/x/wormhole/ante/ante.go
View File

@ -26,43 +26,32 @@ func (wh WormholeAllowlistDecorator) AnteHandle(request sdk.Request, tx sdk.Tx,
return next(request, tx, simulate)
}
verified_addresses := make(map[string]bool)
// For every message we should check:
// We permit if there is a message with a signer satisfying either condition:
// 1. There is an allowlist entry for the signer(s), OR
// 2. The signer(s) are validators in current or future guardian set.
// We cache the result for performance, since this is a ante handler that runs for everything.
// 2. The signer is a validators in a current or future guardian set.
// I.e. If one message has an allowed signer, then the transaction has a signature from that address.
for _, msg := range tx.GetMsgs() {
for _, signer := range msg.GetSigners() {
addr := signer.String()
// check for an address we may have already verified
if ok := verified_addresses[addr]; ok {
// ok
continue
}
// check for an allowlist
if wh.k.HasValidatorAllowedAddress(request, addr) {
allowed_entry := wh.k.GetValidatorAllowedAddress(request, addr)
// authenticate that the validator that made the allowlist is still valid
if wh.k.IsAddressValidatorOrFutureValidator(request, allowed_entry.ValidatorAddress) {
// ok
verified_addresses[addr] = true
continue
return next(request, tx, simulate)
}
}
// if allowlist did not pass, check if signer is a current or future validator
if wh.k.IsAddressValidatorOrFutureValidator(request, addr) {
// ok
verified_addresses[addr] = true
continue
return next(request, tx, simulate)
}
// by this point, this signer is not allowlisted or a valid validator.
// not authorized!
return request, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "signer must be current validator or allowlisted by current validator")
}
}
return next(request, tx, simulate)
// By this point, there is no signer that is not allowlisted or is a validator.
// Not authorized!
return request, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "signer must be current validator or allowlisted by current validator")
}

6
wormchain/x/wormhole/client/cli/tx_allowlist.go
View File

@ -27,7 +27,7 @@ func CmdCreateAllowedAddress() *cobra.Command {
address := args[0]
name := args[1]
msg := types.MsgCreateAllowlistRequest{
msg := types.MsgCreateAllowlistEntryRequest{
Signer: clientCtx.GetFromAddress().String(),
Address: address,
Name: name,
@ -48,7 +48,7 @@ func CmdCreateAllowedAddress() *cobra.Command {
func CmdDeleteAllowedAddress() *cobra.Command {
cmd := &cobra.Command{
Use: "delete-allowed-address [wormchain-address]",
Short: "Remove an allowlist. The allowlist must be stale (only valid under old guardian set) or you must be the creator of the allowlist.",
Short: "Remove an allowlist entry. The allowlist must be stale (only valid under old guardian set) or you must be the creator of the allowlist.",
Aliases: []string{"delete-allowlist", "remove-allowlist", "disallow"},
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
@ -58,7 +58,7 @@ func CmdDeleteAllowedAddress() *cobra.Command {
}
address := args[0]
msg := types.MsgDeleteAllowlistRequest{
msg := types.MsgDeleteAllowlistEntryRequest{
Signer: clientCtx.GetFromAddress().String(),
Address: address,
}

8
wormchain/x/wormhole/handler.go
View File

@ -29,11 +29,11 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
case *types.MsgInstantiateContract:
res, err := msgServer.InstantiateContract(sdk.WrapSDKContext(ctx), msg)
return sdk.WrapServiceResult(ctx, res, err)
case *types.MsgCreateAllowlistRequest:
res, err := msgServer.CreateAllowlist(sdk.WrapSDKContext(ctx), msg)
case *types.MsgCreateAllowlistEntryRequest:
res, err := msgServer.CreateAllowlistEntry(sdk.WrapSDKContext(ctx), msg)
return sdk.WrapServiceResult(ctx, res, err)
case *types.MsgDeleteAllowlistRequest:
res, err := msgServer.DeleteAllowlist(sdk.WrapSDKContext(ctx), msg)
case *types.MsgDeleteAllowlistEntryRequest:
res, err := msgServer.DeleteAllowlistEntry(sdk.WrapSDKContext(ctx), msg)
return sdk.WrapServiceResult(ctx, res, err)
// this line is used by starport scaffolding # 1
default:

31
wormchain/x/wormhole/keeper/allowlist.go
View File

@ -54,21 +54,8 @@ func (k Keeper) GetAllAllowedAddresses(ctx sdk.Context) (list []types.ValidatorA
// * Is in a future guardian set
func (k Keeper) IsAddressValidatorOrFutureValidator(ctx sdk.Context, addr string) bool {
currentIndex, _ := k.GetConsensusGuardianSetIndex(ctx)
validators := k.GetAllGuardianValidator(ctx)
addrBz, err := sdk.AccAddressFromBech32(addr)
var matchedValidator *types.GuardianValidator = nil
if err != nil {
return false
}
// look up the guardian validator
for _, val := range validators {
if bytes.Equal(val.ValidatorAddr, addrBz) {
matchedValidator = &val
break
}
}
// if no match, no match
if matchedValidator == nil {
matchedValidator, found := k.GetGuardianValidatorByValidatorAddress(ctx, addr)
if !found {
return false
}
// check that the validator is in a current or future guardian set
@ -84,3 +71,17 @@ func (k Keeper) IsAddressValidatorOrFutureValidator(ctx sdk.Context, addr string
}
return false
}
func (k Keeper) GetGuardianValidatorByValidatorAddress(ctx sdk.Context, addr string) (validator types.GuardianValidator, found bool) {
addrBz, err := sdk.AccAddressFromBech32(addr)
if err != nil {
return
}
validators := k.GetAllGuardianValidator(ctx)
for _, val := range validators {
if bytes.Equal(val.ValidatorAddr, addrBz) {
return val, true
}
}
return
}

32
wormchain/x/wormhole/keeper/grpc_query_allowlist.go
View File

@ -20,9 +20,9 @@ func (k Keeper) AllowlistAll(c context.Context, req *types.QueryAllValidatorAllo
ctx := sdk.UnwrapSDKContext(c)
store := ctx.KVStore(k.storeKey)
sequenceCounterStore := prefix.NewStore(store, types.KeyPrefix(types.ValidatorAllowlistKey))
allowedStore := prefix.NewStore(store, types.KeyPrefix(types.ValidatorAllowlistKey))
pageRes, err := query.Paginate(sequenceCounterStore, req.Pagination, func(key []byte, value []byte) error {
pageRes, err := query.Paginate(allowedStore, req.Pagination, func(key []byte, value []byte) error {
var allowedAddress types.ValidatorAllowedAddress
if err := k.cdc.Unmarshal(value, &allowedAddress); err != nil {
return err
@ -36,7 +36,7 @@ func (k Keeper) AllowlistAll(c context.Context, req *types.QueryAllValidatorAllo
return nil, status.Error(codes.Internal, err.Error())
}
return &types.QueryAllValidatorAllowlistResponse{AllowedAddress: allowedAddresses, Pagination: pageRes}, nil
return &types.QueryAllValidatorAllowlistResponse{Allowlist: allowedAddresses, Pagination: pageRes}, nil
}
func (k Keeper) Allowlist(c context.Context, req *types.QueryValidatorAllowlist) (*types.QueryValidatorAllowlistResponse, error) {
@ -44,29 +44,15 @@ func (k Keeper) Allowlist(c context.Context, req *types.QueryValidatorAllowlist)
return nil, status.Error(codes.InvalidArgument, "invalid request")
}
var allowedAddresses []*types.ValidatorAllowedAddress
ctx := sdk.UnwrapSDKContext(c)
store := ctx.KVStore(k.storeKey)
sequenceCounterStore := prefix.NewStore(store, types.KeyPrefix(types.ValidatorAllowlistKey))
pageRes, err := query.Paginate(sequenceCounterStore, req.Pagination, func(key []byte, value []byte) error {
var allowedAddress types.ValidatorAllowedAddress
if err := k.cdc.Unmarshal(value, &allowedAddress); err != nil {
return err
allowedAddresses := k.GetAllAllowedAddresses(ctx)
allowlist := []*types.ValidatorAllowedAddress{}
for _, allowed := range allowedAddresses {
if allowed.ValidatorAddress == req.ValidatorAddress {
allowlist = append(allowlist, &allowed)
}
// this will cause a less then expected amount to be returned in the pagination,
// but the alternative is to rework how pagination works, which is complex.
// this lists are not expected to be long anyways and won't need pagination.
if allowedAddress.ValidatorAddress == req.ValidatorAddress {
allowedAddresses = append(allowedAddresses, &allowedAddress)
}
return nil
})
if err != nil {
return nil, status.Error(codes.Internal, err.Error())
}
return &types.QueryValidatorAllowlistResponse{AllowedAddress: allowedAddresses, Pagination: pageRes, ValidatorAddress: req.ValidatorAddress}, nil
return &types.QueryValidatorAllowlistResponse{Allowlist: allowlist, ValidatorAddress: req.ValidatorAddress}, nil
}

4
wormchain/x/wormhole/keeper/msg_server_allowlist.go
View File

@ -8,7 +8,7 @@ import (
"github.com/wormhole-foundation/wormchain/x/wormhole/types"
)
func (k msgServer) CreateAllowlist(goCtx context.Context, msg *types.MsgCreateAllowlistRequest) (*types.MsgAllowlistResponse, error) {
func (k msgServer) CreateAllowlistEntry(goCtx context.Context, msg *types.MsgCreateAllowlistEntryRequest) (*types.MsgAllowlistResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
validator_address := msg.Signer
if !k.IsAddressValidatorOrFutureValidator(ctx, validator_address) {
@ -32,7 +32,7 @@ func (k msgServer) CreateAllowlist(goCtx context.Context, msg *types.MsgCreateAl
return &types.MsgAllowlistResponse{}, nil
}
func (k msgServer) DeleteAllowlist(goCtx context.Context, msg *types.MsgDeleteAllowlistRequest) (*types.MsgAllowlistResponse, error) {
func (k msgServer) DeleteAllowlistEntry(goCtx context.Context, msg *types.MsgDeleteAllowlistEntryRequest) (*types.MsgAllowlistResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
validator_address := msg.Signer
if !k.IsAddressValidatorOrFutureValidator(ctx, validator_address) {

101
wormchain/x/wormhole/keeper/msg_server_allowlist_test.go
View File

@ -58,7 +58,7 @@ func getRandomAddress() string {
return sdk.AccAddress(validatorAddr[:]).String()
}
func TestAllowlist(t *testing.T) {
func TestAllowlistEntry(t *testing.T) {
k, ctx := keepertest.WormholeKeeper(t)
guardians, _ := createNGuardianValidator(k, ctx, 10)
k.SetConfig(ctx, types.Config{
@ -76,89 +76,107 @@ func TestAllowlist(t *testing.T) {
context := sdk.WrapSDKContext(ctx)
msgServer := keeper.NewMsgServerImpl(*k)
// Test creating allowlist works using a validator
new_address := getRandomAddress()
_, err := msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
Signer: getSigner(&guardians[0]),
Address: new_address,
})
assert.NoError(t, err)
// Test creating AllowlistEntry works using a validator
new_addresses := []string{
getRandomAddress(),
getRandomAddress(),
getRandomAddress(),
}
for _, addr := range new_addresses {
_, err := msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: addr,
})
assert.NoError(t, err)
}
// Test creating the same address again is rejected
for _, g := range guardians {
_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
Signer: getSigner(&g),
Address: new_address,
})
assert.Error(t, err)
for _, addr := range new_addresses {
_, err := msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getSigner(&g),
Address: addr,
})
assert.Error(t, err)
}
}
// Test address can be Deleted
_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
_, err := msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: new_address,
Address: new_addresses[0],
})
assert.NoError(t, err)
// Can't be deleted again since it doesn't exist
_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
_, err = msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: new_address,
Address: new_addresses[0],
})
assert.Error(t, err)
// Can be added again
_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: new_address,
Address: new_addresses[0],
})
assert.NoError(t, err)
// another guardian cannot delete an allowlist they did not create
// another guardian cannot delete an AllowlistEntry they did not create
for _, g := range guardians[1:] {
_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
_, err = msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
Signer: getSigner(&g),
Address: new_address,
Address: new_addresses[0],
})
assert.Error(t, err)
}
// Cannot make allowlist if not a validator
_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
// Cannot make AllowlistEntry if not a validator
_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getRandomAddress(),
Address: getRandomAddress(),
})
assert.Error(t, err)
// Cannot make allowlist if the guardian set changes
// Cannot make AllowlistEntry if the guardian set changes
oldGuardian := guardians[0]
guardians, _ = createNGuardianValidator(k, ctx, 10)
createNewGuardianSet(k, ctx, guardians)
err = k.TrySwitchToNewConsensusGuardianSet(ctx)
assert.NoError(t, err)
_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getSigner(&oldGuardian),
Address: getRandomAddress(),
})
assert.Error(t, err)
// still works with new guardian set
_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: getRandomAddress(),
})
assert.NoError(t, err)
// Anyone can remove stale allowlists
// Anyone can remove stale AllowlistEntrys
// (new_address list is now stale as it's validator is no longer in validator set)
_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
_, err = msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
Signer: getSigner(&guardians[9]),
Address: new_address,
Address: new_addresses[0],
})
assert.NoError(t, err)
// stale addresses will get overwritten by new validator
_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: new_addresses[1],
})
assert.NoError(t, err)
allowed := k.GetValidatorAllowedAddress(ctx, new_addresses[1])
assert.Equal(t, allowed.ValidatorAddress, getSigner(&guardians[0]))
_ = msgServer
_ = context
}
func TestAllowlistAnteHandler(t *testing.T) {
func TestAllowlistEntryAnteHandler(t *testing.T) {
k, ctx := keepertest.WormholeKeeper(t)
guardians, privateKeys := createNGuardianValidator(k, ctx, 10)
_ = privateKeys
@ -198,7 +216,7 @@ func TestAllowlistAnteHandler(t *testing.T) {
assert.Error(t, err)
// Test ante handler accepts new address when whitelisted
_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: new_address,
})
@ -206,8 +224,8 @@ func TestAllowlistAnteHandler(t *testing.T) {
_, err = anteHandler.AnteHandle(ctx, getTxWithSigner(new_address), false, MockNext)
assert.NoError(t, err)
// Test ante handler rejects when allowlist is removed
_, err = msgServer.DeleteAllowlist(context, &types.MsgDeleteAllowlistRequest{
// Test ante handler rejects when AllowlistEntry is removed
_, err = msgServer.DeleteAllowlistEntry(context, &types.MsgDeleteAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: new_address,
})
@ -216,8 +234,8 @@ func TestAllowlistAnteHandler(t *testing.T) {
_, err = anteHandler.AnteHandle(ctx, getTxWithSigner(new_address), false, MockNext)
assert.Error(t, err)
// (add back the allowlist)
_, err = msgServer.CreateAllowlist(context, &types.MsgCreateAllowlistRequest{
// (add back the AllowlistEntry)
_, err = msgServer.CreateAllowlistEntry(context, &types.MsgCreateAllowlistEntryRequest{
Signer: getSigner(&guardians[0]),
Address: new_address,
})
@ -225,17 +243,6 @@ func TestAllowlistAnteHandler(t *testing.T) {
_, err = anteHandler.AnteHandle(ctx, getTxWithSigner(new_address), false, MockNext)
assert.NoError(t, err)
// test that the ante handler rejects when a 2nd not-allowed msg is snuck in >:)
_, err = anteHandler.AnteHandle(ctx, &MockTx{
Msgs: []sdk.Msg{
// good
getMsgWithSigner(new_address),
// bad
getMsgWithSigner(getRandomAddress()),
},
}, false, MockNext)
assert.Error(t, err)
// test ante handler rejects address that is no longer valid
// due to validator set advancing
// 1. new guardian set

8
wormchain/x/wormhole/types/codec.go
View File

@ -13,8 +13,8 @@ func RegisterCodec(cdc *codec.LegacyAmino) {
cdc.RegisterConcrete(&MsgRegisterAccountAsGuardian{}, "wormhole/RegisterAccountAsGuardian", nil)
cdc.RegisterConcrete(&MsgStoreCode{}, "wormhole/StoreCode", nil)
cdc.RegisterConcrete(&MsgInstantiateContract{}, "wormhole/InstantiateContract", nil)
cdc.RegisterConcrete(&MsgCreateAllowlistRequest{}, "wormhole/CreateAllowlistRequest", nil)
cdc.RegisterConcrete(&MsgDeleteAllowlistRequest{}, "wormhole/DeleteAllowlistRequest", nil)
cdc.RegisterConcrete(&MsgCreateAllowlistEntryRequest{}, "wormhole/CreateAllowlistEntryRequest", nil)
cdc.RegisterConcrete(&MsgDeleteAllowlistEntryRequest{}, "wormhole/DeleteAllowlistEntryRequest", nil)
// this line is used by starport scaffolding # 2
}
@ -23,8 +23,8 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
&MsgExecuteGovernanceVAA{},
&MsgStoreCode{},
&MsgInstantiateContract{},
&MsgCreateAllowlistRequest{},
&MsgDeleteAllowlistRequest{},
&MsgCreateAllowlistEntryRequest{},
&MsgDeleteAllowlistEntryRequest{},
)
registry.RegisterImplementations((*gov.Content)(nil),
&GovernanceWormholeMessageProposal{},

33
wormchain/x/wormhole/types/message_allowlist.go
View File

@ -5,18 +5,18 @@ import (
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)
var _ sdk.Msg = &MsgCreateAllowlistRequest{}
var _ sdk.Msg = &MsgDeleteAllowlistRequest{}
var _ sdk.Msg = &MsgCreateAllowlistEntryRequest{}
var _ sdk.Msg = &MsgDeleteAllowlistEntryRequest{}
func (msg *MsgCreateAllowlistRequest) Route() string {
func (msg *MsgCreateAllowlistEntryRequest) Route() string {
return RouterKey
}
func (msg *MsgCreateAllowlistRequest) Type() string {
return "CreateAllowlistRequest"
func (msg *MsgCreateAllowlistEntryRequest) Type() string {
return "CreateAllowlistEntryRequest"
}
func (msg *MsgCreateAllowlistRequest) GetSigners() []sdk.AccAddress {
func (msg *MsgCreateAllowlistEntryRequest) GetSigners() []sdk.AccAddress {
signer, err := sdk.AccAddressFromBech32(msg.Signer)
if err != nil {
panic(err)
@ -24,12 +24,12 @@ func (msg *MsgCreateAllowlistRequest) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{signer}
}
func (msg *MsgCreateAllowlistRequest) GetSignBytes() []byte {
func (msg *MsgCreateAllowlistEntryRequest) GetSignBytes() []byte {
bz := ModuleCdc.MustMarshalJSON(msg)
return sdk.MustSortJSON(bz)
}
func (msg *MsgCreateAllowlistRequest) ValidateBasic() error {
func (msg *MsgCreateAllowlistEntryRequest) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(msg.Signer)
if err != nil {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid signer address (%s)", err)
@ -43,15 +43,15 @@ func (msg *MsgCreateAllowlistRequest) ValidateBasic() error {
return nil
}
func (msg *MsgDeleteAllowlistRequest) Route() string {
func (msg *MsgDeleteAllowlistEntryRequest) Route() string {
return RouterKey
}
func (msg *MsgDeleteAllowlistRequest) Type() string {
return "DeleteAllowlistRequest"
func (msg *MsgDeleteAllowlistEntryRequest) Type() string {
return "DeleteAllowlistEntryRequest"
}
func (msg *MsgDeleteAllowlistRequest) GetSigners() []sdk.AccAddress {
func (msg *MsgDeleteAllowlistEntryRequest) GetSigners() []sdk.AccAddress {
signer, err := sdk.AccAddressFromBech32(msg.Signer)
if err != nil {
panic(err)
@ -59,15 +59,20 @@ func (msg *MsgDeleteAllowlistRequest) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{signer}
}
func (msg *MsgDeleteAllowlistRequest) GetSignBytes() []byte {
func (msg *MsgDeleteAllowlistEntryRequest) GetSignBytes() []byte {
bz := ModuleCdc.MustMarshalJSON(msg)
return sdk.MustSortJSON(bz)
}
func (msg *MsgDeleteAllowlistRequest) ValidateBasic() error {
func (msg *MsgDeleteAllowlistEntryRequest) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(msg.Signer)
if err != nil {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid signer address (%s)", err)
}
_, err = sdk.AccAddressFromBech32(msg.Address)
if err != nil {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid allowlist address (%s)", err)
}
return nil
}

210
wormchain/x/wormhole/types/query.pb.go
View File

@ -76,8 +76,8 @@ func (m *QueryAllValidatorAllowlist) GetPagination() *query.PageRequest {
// all allowlisted entries by all validators
type QueryAllValidatorAllowlistResponse struct {
AllowedAddress []*ValidatorAllowedAddress `protobuf:"bytes,1,rep,name=allowed_address,json=allowedAddress,proto3" json:"allowed_address,omitempty"`
Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
Allowlist []*ValidatorAllowedAddress `protobuf:"bytes,1,rep,name=allowlist,proto3" json:"allowlist,omitempty"`
Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}
func (m *QueryAllValidatorAllowlistResponse) Reset() { *m = QueryAllValidatorAllowlistResponse{} }
@ -113,9 +113,9 @@ func (m *QueryAllValidatorAllowlistResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_QueryAllValidatorAllowlistResponse proto.InternalMessageInfo
func (m *QueryAllValidatorAllowlistResponse) GetAllowedAddress() []*ValidatorAllowedAddress {
func (m *QueryAllValidatorAllowlistResponse) GetAllowlist() []*ValidatorAllowedAddress {
if m != nil {
return m.AllowedAddress
return m.Allowlist
}
return nil
}
@ -182,7 +182,7 @@ func (m *QueryValidatorAllowlist) GetPagination() *query.PageRequest {
// all allowlisted entries by a specific validator
type QueryValidatorAllowlistResponse struct {
ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
AllowedAddress []*ValidatorAllowedAddress `protobuf:"bytes,2,rep,name=allowed_address,json=allowedAddress,proto3" json:"allowed_address,omitempty"`
Allowlist []*ValidatorAllowedAddress `protobuf:"bytes,2,rep,name=allowlist,proto3" json:"allowlist,omitempty"`
Pagination *query.PageResponse `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}
@ -226,9 +226,9 @@ func (m *QueryValidatorAllowlistResponse) GetValidatorAddress() string {
return ""
}
func (m *QueryValidatorAllowlistResponse) GetAllowedAddress() []*ValidatorAllowedAddress {
func (m *QueryValidatorAllowlistResponse) GetAllowlist() []*ValidatorAllowedAddress {
if m != nil {
return m.AllowedAddress
return m.Allowlist
}
return nil
}
@ -1254,88 +1254,88 @@ func init() {
func init() { proto.RegisterFile("wormhole/query.proto", fileDescriptor_273185ecc792fa38) }
var fileDescriptor_273185ecc792fa38 = []byte{
// 1285 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x99, 0x4f, 0x6f, 0xdc, 0xc4,
0x1b, 0xc7, 0x33, 0xd9, 0x5f, 0x2b, 0x65, 0xd2, 0x5f, 0x93, 0x0c, 0x69, 0x52, 0x0c, 0xda, 0x2c,
0x06, 0x95, 0xd0, 0x0a, 0x9b, 0x24, 0x22, 0x69, 0x5a, 0x4a, 0xba, 0xd9, 0xb2, 0xbb, 0x49, 0x83,
0x94, 0x6e, 0x24, 0x0e, 0x20, 0xb4, 0x72, 0x76, 0x27, 0x5e, 0x57, 0x8e, 0xbd, 0x5d, 0x7b, 0xdb,
0x86, 0x28, 0x07, 0x90, 0xb8, 0x70, 0x88, 0x10, 0xbc, 0x14, 0x5e, 0x00, 0x07, 0x2e, 0x3d, 0x56,
0xaa, 0xc4, 0x1f, 0x55, 0x42, 0x28, 0xa9, 0x38, 0xc0, 0x81, 0x2b, 0x42, 0x1c, 0x90, 0xc7, 0x8f,
0xbd, 0x5e, 0xaf, 0x6d, 0x6c, 0xaf, 0xcb, 0xcd, 0x99, 0x19, 0x7f, 0xe7, 0xf9, 0x3c, 0xf3, 0xcc,
0xcc, 0x77, 0x1d, 0x3c, 0xfd, 0x40, 0xef, 0xec, 0xb7, 0x74, 0x95, 0x8a, 0xf7, 0xba, 0xb4, 0x73,
0x20, 0xb4, 0x3b, 0xba, 0xa9, 0x93, 0x4b, 0x4e, 0x6b, 0x7d, 0x4f, 0xef, 0x6a, 0x4d, 0xc9, 0x54,
0x74, 0x4d, 0xb0, 0xda, 0x1a, 0x2d, 0x49, 0xb1, 0x9f, 0xac, 0x5e, 0xee, 0x65, 0x59, 0xd7, 0x65,
0x95, 0x8a, 0x52, 0x5b, 0x11, 0x25, 0x4d, 0xd3, 0x4d, 0x36, 0xd2, 0xb0, 0x55, 0xb8, 0xcb, 0x0d,
0xdd, 0xd8, 0xd7, 0x0d, 0x71, 0x57, 0x32, 0x40, 0x5e, 0xbc, 0xbf, 0xb0, 0x4b, 0x4d, 0x69, 0x41,
0x6c, 0x4b, 0xb2, 0xa2, 0xd9, 0xb2, 0xf6, 0xd8, 0x59, 0x37, 0x0e, 0xb9, 0x2b, 0x75, 0x9a, 0x8a,
0xe4, 0x74, 0x5c, 0x70, 0x3b, 0x1a, 0xba, 0xb6, 0xa7, 0xc8, 0xd0, 0x5c, 0x70, 0x9b, 0x3b, 0xb4,
0xad, 0x4a, 0x07, 0x75, 0xab, 0x99, 0x36, 0x3c, 0x8a, 0x73, 0xee, 0x08, 0x83, 0xde, 0xeb, 0x52,
0xad, 0x41, 0xeb, 0x0d, 0xbd, 0xab, 0x99, 0xb4, 0x03, 0x03, 0xae, 0x78, 0x95, 0x0d, 0xaa, 0x19,
0x5d, 0xa3, 0xee, 0x4c, 0x5e, 0x37, 0xa8, 0x59, 0x57, 0xb4, 0x26, 0x7d, 0x08, 0x83, 0xa7, 0x65,
0x5d, 0xd6, 0xd9, 0xa3, 0x68, 0x3d, 0xd9, 0xad, 0x7c, 0x13, 0x73, 0x77, 0x2c, 0xae, 0xa2, 0xaa,
0x7e, 0x20, 0xa9, 0x4a, 0x53, 0x32, 0xf5, 0x4e, 0x51, 0x55, 0xf5, 0x07, 0xaa, 0x62, 0x98, 0xa4,
0x8c, 0x71, 0x8f, 0xf3, 0x22, 0x2a, 0xa0, 0xf9, 0xf1, 0xc5, 0x4b, 0x82, 0x9d, 0x14, 0xc1, 0x4a,
0x8a, 0x60, 0xe7, 0x1c, 0x92, 0x22, 0x6c, 0x4b, 0x32, 0xad, 0x59, 0xb1, 0x1a, 0x66, 0xcd, 0xf3,
0x26, 0xff, 0x03, 0xc2, 0x7c, 0xf8, 0x34, 0x35, 0x6a, 0xb4, 0xad, 0xf8, 0x49, 0x0b, 0x4f, 0x48,
0x56, 0x23, 0x6d, 0xd6, 0xa5, 0x66, 0xb3, 0x43, 0x0d, 0xe3, 0x22, 0x2a, 0xe4, 0xe6, 0xc7, 0x17,
0xd7, 0x84, 0x78, 0xcb, 0x29, 0xf4, 0x8b, 0xd3, 0x66, 0xd1, 0x96, 0xa9, 0x9d, 0x97, 0xfa, 0xfe,
0x26, 0x95, 0x3e, 0xb0, 0x51, 0x06, 0xf6, 0xfa, 0xbf, 0x82, 0xd9, 0x61, 0xf6, 0x91, 0x1d, 0x23,
0x3c, 0xcb, 0xc8, 0x02, 0xb2, 0x77, 0x05, 0x4f, 0xdd, 0x77, 0x5a, 0x3d, 0x40, 0x68, 0x7e, 0xac,
0x36, 0xe9, 0x76, 0x38, 0x11, 0x95, 0x03, 0x22, 0x4a, 0x93, 0xea, 0x4f, 0x47, 0xf1, 0x5c, 0x48,
0x40, 0x6e, 0x9e, 0x13, 0x05, 0x16, 0xb0, 0x28, 0xa3, 0xff, 0xc5, 0xa2, 0xe4, 0xd2, 0x2f, 0xca,
0x22, 0x14, 0x75, 0x85, 0x9a, 0x15, 0xd8, 0x0e, 0x3b, 0xd4, 0x84, 0x6c, 0x91, 0x69, 0x7c, 0x86,
0xed, 0x0b, 0x46, 0xfc, 0xff, 0x9a, 0xfd, 0x07, 0xff, 0x09, 0x7e, 0x29, 0xf0, 0x1d, 0x48, 0xd9,
0x47, 0x78, 0xdc, 0xd3, 0x0c, 0x5b, 0x61, 0x29, 0x6e, 0x06, 0x3c, 0xaf, 0xae, 0xff, 0xef, 0xd1,
0xcf, 0x73, 0x23, 0x35, 0xaf, 0x9a, 0x77, 0x13, 0x06, 0xc4, 0x9b, 0xd5, 0x26, 0xfc, 0x0e, 0x01,
0xa2, 0x7f, 0x9a, 0x30, 0xc4, 0x5c, 0x76, 0x88, 0xd9, 0x6d, 0xb8, 0x59, 0x7c, 0xc1, 0x59, 0xa7,
0x12, 0x3b, 0x4e, 0x01, 0x95, 0xdf, 0xc3, 0x33, 0xfe, 0x0e, 0x00, 0xdb, 0xc2, 0x67, 0xed, 0x16,
0x48, 0x9e, 0x10, 0x97, 0xc9, 0x7e, 0x0b, 0x70, 0x40, 0x83, 0x5f, 0x81, 0xfd, 0x55, 0xb1, 0x52,
0x67, 0x1d, 0xdc, 0xdb, 0xee, 0xb9, 0x1d, 0x58, 0x61, 0x63, 0x4e, 0x85, 0x1d, 0x23, 0x5c, 0x08,
0x7f, 0x13, 0x62, 0xbd, 0x8b, 0x27, 0x3b, 0xbe, 0x3e, 0x88, 0xfa, 0x6a, 0xdc, 0xa8, 0xfd, 0xda,
0x10, 0xff, 0x80, 0x2e, 0xaf, 0x00, 0x49, 0x51, 0x55, 0xc3, 0x48, 0x32, 0xbc, 0x00, 0x0a, 0xe1,
0x73, 0x45, 0xb2, 0xe7, 0x9e, 0x07, 0x7b, 0x76, 0xf5, 0xb8, 0x8c, 0xf3, 0xce, 0xa2, 0xee, 0xc0,
0x2d, 0x5d, 0xb2, 0x2f, 0xe9, 0xe8, 0x6a, 0xf8, 0x02, 0xf5, 0xea, 0x68, 0xe0, 0x45, 0x48, 0x88,
0x8c, 0x27, 0x8c, 0xfe, 0x2e, 0x58, 0x82, 0x95, 0xb8, 0xf9, 0xf0, 0x29, 0x43, 0x3a, 0xfc, 0xaa,
0x7c, 0x0b, 0x20, 0x8a, 0xaa, 0x1a, 0x02, 0x91, 0x55, 0x21, 0x3c, 0x41, 0xbd, 0xa2, 0x4b, 0x84,
0x9d, 0xcb, 0x1e, 0x3b, 0xbb, 0x22, 0xb8, 0x8c, 0xe7, 0x3d, 0x67, 0x8f, 0xed, 0xc4, 0x3c, 0xa7,
0xdf, 0x86, 0xb5, 0xe2, 0xce, 0x39, 0xf5, 0x0d, 0xc2, 0x6f, 0xc4, 0x18, 0x0c, 0xb9, 0xf8, 0x1c,
0xe1, 0x17, 0x43, 0x47, 0xc1, 0x3a, 0x14, 0x13, 0x9c, 0x67, 0xc1, 0x42, 0x90, 0xa0, 0xf0, 0x99,
0xf8, 0x5b, 0xbd, 0xb3, 0xcb, 0xe9, 0x73, 0xaf, 0x75, 0xa7, 0x46, 0x0a, 0x78, 0xdc, 0x71, 0x9f,
0xb7, 0xe9, 0x01, 0x0b, 0xee, 0x5c, 0xcd, 0xdb, 0xc4, 0x7f, 0x85, 0xf0, 0x2b, 0x11, 0x32, 0xc0,
0xbc, 0x8f, 0xa7, 0x64, 0x7f, 0x27, 0xa0, 0xae, 0x26, 0xbd, 0x8e, 0x5c, 0x01, 0x40, 0x1c, 0x54,
0xe6, 0xef, 0xf6, 0x8e, 0xa6, 0x50, 0xb4, 0xac, 0xca, 0xff, 0xa9, 0x93, 0x80, 0xe0, 0xc9, 0xa2,
0x13, 0x90, 0x7b, 0x3e, 0x09, 0xc8, 0x6e, 0x1b, 0xbc, 0x06, 0x2e, 0x7f, 0x4b, 0x32, 0xa9, 0x61,
0x86, 0x6d, 0x80, 0x8f, 0xf1, 0xab, 0x91, 0xa3, 0x20, 0x09, 0xcb, 0x78, 0x46, 0x0d, 0x1c, 0x01,
0xbe, 0x2d, 0xa4, 0x77, 0xf1, 0xcf, 0x59, 0x7c, 0x86, 0xe9, 0x93, 0xa7, 0xa8, 0xcf, 0xd1, 0x90,
0xf5, 0xb8, 0xb9, 0x0b, 0x37, 0x8f, 0x5c, 0x69, 0x28, 0x0d, 0x1b, 0x8d, 0x2f, 0x7d, 0xf6, 0xe4,
0xd9, 0xd7, 0xa3, 0x37, 0xc8, 0x75, 0x31, 0x40, 0x4c, 0x74, 0xc5, 0xc4, 0x81, 0x5f, 0x94, 0x3b,
0xd4, 0x14, 0x0f, 0xd9, 0xfd, 0x71, 0x44, 0xbe, 0x47, 0xf8, 0xbc, 0x47, 0xbc, 0xa8, 0xaa, 0x09,
0x01, 0x03, 0xdd, 0x66, 0x42, 0xc0, 0x60, 0x2b, 0xc9, 0x5f, 0x67, 0x80, 0x6f, 0x93, 0xa5, 0x14,
0x80, 0xe4, 0x5b, 0xe4, 0xf8, 0x35, 0x72, 0x23, 0x69, 0xb6, 0xfb, 0x2c, 0x21, 0xf7, 0x6e, 0xda,
0xd7, 0x01, 0x63, 0x99, 0x61, 0xbc, 0x45, 0x84, 0xb8, 0x18, 0xf6, 0x0f, 0x7c, 0xf2, 0x07, 0xc2,
0x93, 0xb5, 0x01, 0xc7, 0x91, 0x34, 0x98, 0x10, 0x4f, 0xc6, 0x55, 0x87, 0x17, 0x02, 0xbe, 0x2a,
0xe3, 0x5b, 0x27, 0x37, 0xe3, 0xf2, 0xf9, 0x6d, 0x94, 0x5b, 0x8c, 0xbf, 0x21, 0xfc, 0x82, 0x7f,
0x1a, 0xab, 0x22, 0x2b, 0x49, 0xab, 0x29, 0x1b, 0xe8, 0x08, 0x97, 0xc9, 0xdf, 0x64, 0xd0, 0xd7,
0xc8, 0xd5, 0xb4, 0xd0, 0xe4, 0x77, 0x84, 0x27, 0x7c, 0x0e, 0x83, 0x94, 0x93, 0x2e, 0x4a, 0xb0,
0xcf, 0xe2, 0x2a, 0x43, 0xeb, 0x00, 0x66, 0x85, 0x61, 0x16, 0xc9, 0x5a, 0x5c, 0x4c, 0x9f, 0x39,
0x72, 0x97, 0xf6, 0x57, 0x84, 0x89, 0x6f, 0x12, 0x6b, 0x65, 0xcb, 0x49, 0x17, 0x24, 0x13, 0xe0,
0x70, 0xd7, 0xc8, 0xaf, 0x31, 0xe0, 0x55, 0xb2, 0x92, 0x12, 0x98, 0x1c, 0x8f, 0x46, 0x58, 0x2d,
0xb2, 0x9d, 0xe2, 0x2c, 0x89, 0x34, 0x82, 0xdc, 0x9d, 0x0c, 0x15, 0x21, 0x07, 0x5b, 0x2c, 0x07,
0x65, 0x72, 0x2b, 0xc1, 0x81, 0x15, 0xfa, 0xdd, 0x90, 0xfc, 0x85, 0xf0, 0xd4, 0x80, 0x8d, 0x20,
0xd5, 0xb4, 0x37, 0xa0, 0xdf, 0x54, 0x71, 0x1b, 0x19, 0x28, 0x01, 0xf8, 0x36, 0x03, 0xdf, 0x24,
0xd5, 0xa4, 0x17, 0x4e, 0xdd, 0xfd, 0xde, 0x25, 0x1e, 0x7a, 0x9c, 0xea, 0x91, 0x75, 0x86, 0x4f,
0x0f, 0xcc, 0x67, 0x15, 0x7e, 0x35, 0xed, 0x05, 0x39, 0x24, 0x7f, 0x94, 0x63, 0xe4, 0xd7, 0x19,
0xff, 0x3b, 0xe4, 0x5a, 0x7a, 0x7e, 0xf2, 0x37, 0xc2, 0x33, 0xc1, 0x9e, 0x8c, 0x6c, 0x26, 0x8a,
0x34, 0xd2, 0xfe, 0x71, 0xb7, 0x33, 0xd1, 0x02, 0xee, 0x0d, 0xc6, 0x5d, 0x22, 0xc5, 0xb8, 0xdc,
0xb6, 0x69, 0x0c, 0xaa, 0xf6, 0x9f, 0x10, 0x3e, 0xe7, 0x7e, 0x2a, 0x4d, 0xe5, 0xa6, 0x06, 0xbf,
0xb8, 0x72, 0x9b, 0xc3, 0x6b, 0xb8, 0xac, 0xab, 0x8c, 0x75, 0x89, 0x2c, 0xc4, 0x65, 0x95, 0xdc,
0x2f, 0xd1, 0xcf, 0x10, 0x1e, 0xeb, 0x7d, 0x97, 0x5e, 0x4b, 0x14, 0x54, 0x00, 0x55, 0x65, 0x48,
0x01, 0x17, 0xe9, 0x7d, 0x86, 0x54, 0x21, 0xef, 0x25, 0x46, 0x12, 0x0f, 0x07, 0xbe, 0x60, 0x1f,
0xad, 0xef, 0x3c, 0x3a, 0xc9, 0xa3, 0xc7, 0x27, 0x79, 0xf4, 0xcb, 0x49, 0x1e, 0x7d, 0x79, 0x9a,
0x1f, 0x79, 0x7c, 0x9a, 0x1f, 0xf9, 0xf1, 0x34, 0x3f, 0xf2, 0xe1, 0xaa, 0xac, 0x98, 0xad, 0xee,
0xae, 0xd0, 0xd0, 0xf7, 0x5d, 0xb1, 0x37, 0x03, 0xa7, 0x7a, 0xd8, 0x9b, 0xcc, 0x3c, 0x68, 0x53,
0x63, 0xf7, 0x2c, 0xfb, 0x47, 0xc9, 0xd2, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6a, 0x1e, 0x0a,
0x3b, 0x68, 0x1a, 0x00, 0x00,
// 1281 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x99, 0x4f, 0x6f, 0xdc, 0xc4,
0x1b, 0xc7, 0x33, 0xbb, 0xbf, 0x56, 0xca, 0xa4, 0x3f, 0x9a, 0x0c, 0x69, 0x52, 0x0c, 0xda, 0x2c,
0x06, 0x95, 0xd0, 0x0a, 0x9b, 0x24, 0x22, 0x69, 0x5a, 0x4a, 0xba, 0xbb, 0x25, 0xbb, 0x49, 0x83,
0x94, 0x6e, 0x24, 0x0e, 0xa0, 0x6a, 0xe5, 0xec, 0x4e, 0x1c, 0x57, 0x8e, 0xbd, 0x5d, 0x7b, 0xdb,
0x86, 0x28, 0x17, 0x24, 0x2e, 0x1c, 0x22, 0x04, 0x2f, 0x85, 0x17, 0xc0, 0x81, 0x4b, 0x0f, 0x1c,
0x2a, 0x55, 0xe2, 0x8f, 0x2a, 0x21, 0x94, 0x54, 0x1c, 0xe0, 0xc0, 0x0d, 0x21, 0xc4, 0x01, 0x79,
0xfc, 0xd8, 0xeb, 0xf5, 0xda, 0xc6, 0xf6, 0x3a, 0xb7, 0xed, 0xcc, 0xf8, 0x3b, 0xcf, 0xe7, 0x99,
0x67, 0x66, 0xbe, 0x99, 0xe2, 0xc9, 0x87, 0x7a, 0x67, 0x6f, 0x57, 0x57, 0xa9, 0x78, 0xbf, 0x4b,
0x3b, 0xfb, 0x42, 0xbb, 0xa3, 0x9b, 0x3a, 0xb9, 0xe4, 0xb4, 0x36, 0x76, 0xf4, 0xae, 0xd6, 0x92,
0x4c, 0x45, 0xd7, 0x04, 0xab, 0xad, 0xb9, 0x2b, 0x29, 0xf6, 0x2f, 0xab, 0x97, 0x7b, 0x45, 0xd6,
0x75, 0x59, 0xa5, 0xa2, 0xd4, 0x56, 0x44, 0x49, 0xd3, 0x74, 0x93, 0x8d, 0x34, 0x6c, 0x15, 0xee,
0x72, 0x53, 0x37, 0xf6, 0x74, 0x43, 0xdc, 0x96, 0x0c, 0x90, 0x17, 0x1f, 0xcc, 0x6d, 0x53, 0x53,
0x9a, 0x13, 0xdb, 0x92, 0xac, 0x68, 0xb6, 0xac, 0x3d, 0x76, 0xda, 0x8d, 0x43, 0xee, 0x4a, 0x9d,
0x96, 0x22, 0x39, 0x1d, 0x17, 0xdc, 0x8e, 0xa6, 0xae, 0xed, 0x28, 0x32, 0x34, 0x17, 0xdd, 0xe6,
0x0e, 0x6d, 0xab, 0xd2, 0x7e, 0xc3, 0x6a, 0xa6, 0x4d, 0x8f, 0xe2, 0x8c, 0x3b, 0xc2, 0xa0, 0xf7,
0xbb, 0x54, 0x6b, 0xd2, 0x46, 0x53, 0xef, 0x6a, 0x26, 0xed, 0xc0, 0x80, 0x2b, 0x5e, 0x65, 0x83,
0x6a, 0x46, 0xd7, 0x68, 0x38, 0x93, 0x37, 0x0c, 0x6a, 0x36, 0x14, 0xad, 0x45, 0x1f, 0xc1, 0xe0,
0x49, 0x59, 0x97, 0x75, 0xf6, 0x53, 0xb4, 0x7e, 0xd9, 0xad, 0x7c, 0x0b, 0x73, 0x77, 0x2c, 0xae,
0x92, 0xaa, 0x7e, 0x28, 0xa9, 0x4a, 0x4b, 0x32, 0xf5, 0x4e, 0x49, 0x55, 0xf5, 0x87, 0xaa, 0x62,
0x98, 0x64, 0x15, 0xe3, 0x1e, 0xe7, 0x45, 0x54, 0x44, 0xb3, 0x63, 0xf3, 0x97, 0x04, 0x3b, 0x29,
0x82, 0x95, 0x14, 0xc1, 0xce, 0x39, 0x24, 0x45, 0xd8, 0x94, 0x64, 0x5a, 0xb7, 0x62, 0x35, 0xcc,
0xba, 0xe7, 0x4b, 0xfe, 0x3b, 0x84, 0xf9, 0xf0, 0x69, 0xea, 0xd4, 0x68, 0x5b, 0xf1, 0x93, 0xbb,
0x78, 0x54, 0x72, 0x1a, 0x2f, 0xa2, 0x62, 0x7e, 0x76, 0x6c, 0x7e, 0x45, 0x88, 0xb7, 0x90, 0x42,
0xbf, 0x2c, 0x6d, 0x95, 0x5a, 0xad, 0x0e, 0x35, 0x8c, 0x7a, 0x4f, 0x91, 0x54, 0xfb, 0x68, 0x72,
0x8c, 0xe6, 0x8d, 0xff, 0xa4, 0xb1, 0x63, 0xeb, 0xc3, 0x39, 0x42, 0x78, 0x9a, 0xe1, 0x04, 0xa4,
0xec, 0x0a, 0x9e, 0x78, 0xe0, 0xb4, 0x36, 0x24, 0x3b, 0x08, 0x96, 0xb9, 0xd1, 0xfa, 0xb8, 0xdb,
0x01, 0xc1, 0xf9, 0xf2, 0x9b, 0x4b, 0x9d, 0xdf, 0x3f, 0x11, 0x9e, 0x09, 0x09, 0xc8, 0x4d, 0x6e,
0xa2, 0xc0, 0xfa, 0x56, 0x22, 0x77, 0xca, 0x2b, 0x91, 0x4f, 0xbf, 0x12, 0xf3, 0x50, 0xbe, 0x55,
0x6a, 0x56, 0xa1, 0xf0, 0xb7, 0xa8, 0x09, 0x29, 0x22, 0x93, 0xf8, 0x0c, 0xdb, 0x01, 0x0c, 0xf3,
0xff, 0x75, 0xfb, 0x1f, 0xfc, 0x27, 0xf8, 0xe5, 0xc0, 0x6f, 0x20, 0x4f, 0x1f, 0xe3, 0x31, 0x4f,
0x33, 0x14, 0xfd, 0x42, 0x5c, 0x78, 0xcf, 0xa7, 0xe5, 0xff, 0x3d, 0xfe, 0x79, 0x66, 0xa4, 0xee,
0x55, 0xf3, 0x6e, 0xb7, 0x80, 0x78, 0xb3, 0xda, 0x6e, 0xdf, 0x22, 0x40, 0xf4, 0x4f, 0x13, 0x86,
0x98, 0xcf, 0x0e, 0x31, 0xbb, 0x5d, 0x36, 0x8d, 0x2f, 0x38, 0xeb, 0x54, 0x61, 0x07, 0x27, 0xa0,
0xf2, 0x3b, 0x78, 0xca, 0xdf, 0x01, 0x60, 0x1b, 0xf8, 0xac, 0xdd, 0x02, 0xc9, 0x13, 0xe2, 0x32,
0xd9, 0x5f, 0x01, 0x0e, 0x68, 0xf0, 0x4b, 0xb0, 0xa9, 0xaa, 0x56, 0xea, 0xac, 0x23, 0x7a, 0xd3,
0x3d, 0xa1, 0x03, 0x2b, 0x6c, 0xd4, 0xa9, 0xb0, 0x23, 0x84, 0x8b, 0xe1, 0x5f, 0x42, 0xac, 0xf7,
0xf0, 0x78, 0xc7, 0xd7, 0x07, 0x51, 0x5f, 0x8d, 0x1b, 0xb5, 0x5f, 0x1b, 0xe2, 0x1f, 0xd0, 0xe5,
0x15, 0x20, 0x29, 0xa9, 0x6a, 0x18, 0x49, 0x56, 0xb5, 0xf7, 0x83, 0xc3, 0x1e, 0x38, 0x57, 0x24,
0x7b, 0xfe, 0x34, 0xd8, 0xb3, 0xab, 0xc7, 0x45, 0x5c, 0x70, 0x16, 0x75, 0x0b, 0xee, 0xe3, 0x8a,
0x7d, 0x1d, 0x47, 0x57, 0xc3, 0xe7, 0xa8, 0x57, 0x47, 0x03, 0x1f, 0x42, 0x42, 0x64, 0x7c, 0xde,
0xe8, 0xef, 0x82, 0x25, 0x58, 0x8a, 0x9b, 0x0f, 0x9f, 0x32, 0xa4, 0xc3, 0xaf, 0xca, 0xef, 0x02,
0x44, 0x49, 0x55, 0x43, 0x20, 0xb2, 0x2a, 0x84, 0xa7, 0xa8, 0x57, 0x74, 0x89, 0xb0, 0xf3, 0xd9,
0x63, 0x67, 0x57, 0x04, 0x97, 0xf1, 0xac, 0xe7, 0xec, 0xb1, 0x3d, 0x97, 0xe7, 0xf4, 0x5b, 0xb3,
0x56, 0xdc, 0x39, 0xa7, 0xbe, 0x46, 0xf8, 0xcd, 0x18, 0x83, 0x21, 0x17, 0x9f, 0x21, 0xfc, 0x52,
0xe8, 0x28, 0x58, 0x87, 0x52, 0x82, 0xf3, 0x2c, 0x58, 0x08, 0x12, 0x14, 0x3e, 0x13, 0x7f, 0xab,
0x77, 0x76, 0x39, 0x7d, 0xee, 0x8d, 0xee, 0xd4, 0x48, 0x11, 0x8f, 0x39, 0x3e, 0xf3, 0x36, 0xdd,
0x67, 0xc1, 0x9d, 0xab, 0x7b, 0x9b, 0xf8, 0x2f, 0x11, 0x7e, 0x35, 0x42, 0x06, 0x98, 0xf7, 0xf0,
0x84, 0xec, 0xef, 0x04, 0xd4, 0xe5, 0xa4, 0xd7, 0x91, 0x2b, 0x00, 0x88, 0x83, 0xca, 0xfc, 0xbd,
0xde, 0xd1, 0x14, 0x8a, 0x96, 0x55, 0xf9, 0x3f, 0x73, 0x12, 0x10, 0x3c, 0x59, 0x74, 0x02, 0xf2,
0xa7, 0x93, 0x80, 0xec, 0xb6, 0xc1, 0xeb, 0xe0, 0xe7, 0x37, 0x24, 0x93, 0x1a, 0x66, 0xd8, 0x06,
0xb8, 0x8b, 0x5f, 0x8b, 0x1c, 0x05, 0x49, 0x58, 0xc4, 0x53, 0x6a, 0xe0, 0x08, 0xf0, 0x6d, 0x21,
0xbd, 0xf3, 0x7f, 0x4d, 0xe3, 0x33, 0x4c, 0x9f, 0x3c, 0x43, 0x7d, 0x8e, 0x86, 0x94, 0xe3, 0xe6,
0x2e, 0xdc, 0x3c, 0x72, 0x95, 0xa1, 0x34, 0x6c, 0x34, 0xbe, 0xf2, 0xe9, 0xd3, 0xe7, 0x5f, 0xe5,
0x6e, 0x90, 0xeb, 0x62, 0x80, 0x98, 0xe8, 0x8a, 0x89, 0x03, 0x7f, 0x3b, 0x6e, 0x51, 0x53, 0x3c,
0x60, 0xf7, 0xc7, 0x21, 0xf9, 0x1e, 0xe1, 0x17, 0x3c, 0xe2, 0x25, 0x55, 0x4d, 0x08, 0x18, 0xe8,
0x36, 0x13, 0x02, 0x06, 0x5b, 0x49, 0xfe, 0x3a, 0x03, 0x7c, 0x87, 0x2c, 0xa4, 0x00, 0x24, 0xdf,
0x20, 0xc7, 0xaf, 0x91, 0x1b, 0x49, 0xb3, 0xdd, 0x67, 0x09, 0xb9, 0xf7, 0xd2, 0x7e, 0x0e, 0x18,
0x8b, 0x0c, 0xe3, 0x6d, 0x22, 0xc4, 0xc5, 0xb0, 0xff, 0x94, 0x27, 0x7f, 0x20, 0x3c, 0x5e, 0x1f,
0x70, 0x1c, 0x49, 0x83, 0x09, 0xf1, 0x64, 0x5c, 0x6d, 0x78, 0x21, 0xe0, 0xab, 0x31, 0xbe, 0x32,
0xb9, 0x19, 0x97, 0xcf, 0x6f, 0xa3, 0xdc, 0x62, 0xfc, 0x0d, 0xe1, 0x17, 0xfd, 0xd3, 0x58, 0x15,
0x59, 0x4d, 0x5a, 0x4d, 0xd9, 0x40, 0x47, 0xb8, 0x4c, 0xfe, 0x26, 0x83, 0xbe, 0x46, 0xae, 0xa6,
0x85, 0x26, 0xbf, 0x23, 0x7c, 0xde, 0xe7, 0x30, 0xc8, 0x6a, 0xd2, 0x45, 0x09, 0xf6, 0x59, 0x5c,
0x75, 0x68, 0x1d, 0xc0, 0xac, 0x32, 0xcc, 0x12, 0x59, 0x89, 0x8b, 0xe9, 0x33, 0x47, 0xee, 0xd2,
0xfe, 0x8a, 0x30, 0xf1, 0x4d, 0x62, 0xad, 0xec, 0x6a, 0xd2, 0x05, 0xc9, 0x04, 0x38, 0xdc, 0x35,
0xf2, 0x2b, 0x0c, 0x78, 0x99, 0x2c, 0xa5, 0x04, 0x26, 0x47, 0xb9, 0x08, 0xab, 0x45, 0x36, 0x53,
0x9c, 0x25, 0x91, 0x46, 0x90, 0xbb, 0x93, 0xa1, 0x22, 0xe4, 0x60, 0x83, 0xe5, 0x60, 0x95, 0xdc,
0x4a, 0x70, 0x60, 0x85, 0xbe, 0x10, 0x92, 0xbf, 0x11, 0x9e, 0x18, 0xb0, 0x11, 0xa4, 0x96, 0xf6,
0x06, 0xf4, 0x9b, 0x2a, 0x6e, 0x2d, 0x03, 0x25, 0x00, 0xdf, 0x64, 0xe0, 0xeb, 0xa4, 0x96, 0xf4,
0xc2, 0x69, 0xb8, 0x8f, 0x5c, 0xe2, 0x81, 0xc7, 0xa9, 0x1e, 0x5a, 0x67, 0xf8, 0xe4, 0xc0, 0x7c,
0x56, 0xe1, 0xd7, 0xd2, 0x5e, 0x90, 0x43, 0xf2, 0x47, 0x39, 0x46, 0xbe, 0xcc, 0xf8, 0xdf, 0x25,
0xd7, 0xd2, 0xf3, 0x93, 0x7f, 0x10, 0x9e, 0x0a, 0xf6, 0x64, 0x64, 0x3d, 0x51, 0xa4, 0x91, 0xf6,
0x8f, 0xbb, 0x9d, 0x89, 0x16, 0x70, 0xaf, 0x31, 0xee, 0x0a, 0x29, 0xc5, 0xe5, 0xb6, 0x4d, 0x63,
0x50, 0xb5, 0xff, 0x84, 0xf0, 0x39, 0xf7, 0x7d, 0x34, 0x95, 0x9b, 0x1a, 0x7c, 0x66, 0xe5, 0xd6,
0x87, 0xd7, 0x70, 0x59, 0x97, 0x19, 0xeb, 0x02, 0x99, 0x8b, 0xcb, 0xda, 0x7b, 0x59, 0x7d, 0x8e,
0xf0, 0x68, 0xef, 0x31, 0x7a, 0x25, 0x51, 0x50, 0x01, 0x54, 0xd5, 0x21, 0x05, 0x5c, 0xa4, 0x0f,
0x18, 0x52, 0x95, 0xbc, 0x9f, 0x18, 0x49, 0x3c, 0x18, 0x78, 0xb6, 0x3e, 0x2c, 0x6f, 0x3d, 0x3e,
0x2e, 0xa0, 0x27, 0xc7, 0x05, 0xf4, 0xcb, 0x71, 0x01, 0x7d, 0x71, 0x52, 0x18, 0x79, 0x72, 0x52,
0x18, 0xf9, 0xf1, 0xa4, 0x30, 0xf2, 0xd1, 0xb2, 0xac, 0x98, 0xbb, 0xdd, 0x6d, 0xa1, 0xa9, 0xef,
0xb9, 0x62, 0x6f, 0x05, 0x4e, 0xf5, 0xa8, 0x37, 0x99, 0xb9, 0xdf, 0xa6, 0xc6, 0xf6, 0x59, 0xf6,
0x5f, 0x22, 0x0b, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xcf, 0xe7, 0x74, 0x41, 0x52, 0x1a, 0x00,
0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -1939,10 +1939,10 @@ func (m *QueryAllValidatorAllowlistResponse) MarshalToSizedBuffer(dAtA []byte) (
i--
dAtA[i] = 0x12
}
if len(m.AllowedAddress) > 0 {
for iNdEx := len(m.AllowedAddress) - 1; iNdEx >= 0; iNdEx-- {
if len(m.Allowlist) > 0 {
for iNdEx := len(m.Allowlist) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.AllowedAddress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
size, err := m.Allowlist[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@ -2030,10 +2030,10 @@ func (m *QueryValidatorAllowlistResponse) MarshalToSizedBuffer(dAtA []byte) (int
i--
dAtA[i] = 0x1a
}
if len(m.AllowedAddress) > 0 {
for iNdEx := len(m.AllowedAddress) - 1; iNdEx >= 0; iNdEx-- {
if len(m.Allowlist) > 0 {
for iNdEx := len(m.Allowlist) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.AllowedAddress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
size, err := m.Allowlist[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@ -2833,8 +2833,8 @@ func (m *QueryAllValidatorAllowlistResponse) Size() (n int) {
}
var l int
_ = l
if len(m.AllowedAddress) > 0 {
for _, e := range m.AllowedAddress {
if len(m.Allowlist) > 0 {
for _, e := range m.Allowlist {
l = e.Size()
n += 1 + l + sovQuery(uint64(l))
}
@ -2873,8 +2873,8 @@ func (m *QueryValidatorAllowlistResponse) Size() (n int) {
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
if len(m.AllowedAddress) > 0 {
for _, e := range m.AllowedAddress {
if len(m.Allowlist) > 0 {
for _, e := range m.Allowlist {
l = e.Size()
n += 1 + l + sovQuery(uint64(l))
}
@ -3293,7 +3293,7 @@ func (m *QueryAllValidatorAllowlistResponse) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AllowedAddress", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Allowlist", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@ -3320,8 +3320,8 @@ func (m *QueryAllValidatorAllowlistResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AllowedAddress = append(m.AllowedAddress, &ValidatorAllowedAddress{})
if err := m.AllowedAddress[len(m.AllowedAddress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
m.Allowlist = append(m.Allowlist, &ValidatorAllowedAddress{})
if err := m.Allowlist[len(m.Allowlist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@ -3563,7 +3563,7 @@ func (m *QueryValidatorAllowlistResponse) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AllowedAddress", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Allowlist", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@ -3590,8 +3590,8 @@ func (m *QueryValidatorAllowlistResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AllowedAddress = append(m.AllowedAddress, &ValidatorAllowedAddress{})
if err := m.AllowedAddress[len(m.AllowedAddress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
m.Allowlist = append(m.Allowlist, &ValidatorAllowedAddress{})
if err := m.Allowlist[len(m.Allowlist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex

233
wormchain/x/wormhole/types/tx.pb.go
View File

@ -28,7 +28,7 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type MsgCreateAllowlistRequest struct {
type MsgCreateAllowlistEntryRequest struct {
// signer should be a guardian validator in a current set or future set.
Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
// the address to allowlist
@ -37,18 +37,18 @@ type MsgCreateAllowlistRequest struct {
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}
func (m *MsgCreateAllowlistRequest) Reset() { *m = MsgCreateAllowlistRequest{} }
func (m *MsgCreateAllowlistRequest) String() string { return proto.CompactTextString(m) }
func (*MsgCreateAllowlistRequest) ProtoMessage() {}
func (*MsgCreateAllowlistRequest) Descriptor() ([]byte, []int) {
func (m *MsgCreateAllowlistEntryRequest) Reset() { *m = MsgCreateAllowlistEntryRequest{} }
func (m *MsgCreateAllowlistEntryRequest) String() string { return proto.CompactTextString(m) }
func (*MsgCreateAllowlistEntryRequest) ProtoMessage() {}
func (*MsgCreateAllowlistEntryRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_55f7aa067b0c517b, []int{0}
}
func (m *MsgCreateAllowlistRequest) XXX_Unmarshal(b []byte) error {
func (m *MsgCreateAllowlistEntryRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgCreateAllowlistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *MsgCreateAllowlistEntryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgCreateAllowlistRequest.Marshal(b, m, deterministic)
return xxx_messageInfo_MsgCreateAllowlistEntryRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@ -58,58 +58,58 @@ func (m *MsgCreateAllowlistRequest) XXX_Marshal(b []byte, deterministic bool) ([
return b[:n], nil
}
}
func (m *MsgCreateAllowlistRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgCreateAllowlistRequest.Merge(m, src)
func (m *MsgCreateAllowlistEntryRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgCreateAllowlistEntryRequest.Merge(m, src)
}
func (m *MsgCreateAllowlistRequest) XXX_Size() int {
func (m *MsgCreateAllowlistEntryRequest) XXX_Size() int {
return m.Size()
}
func (m *MsgCreateAllowlistRequest) XXX_DiscardUnknown() {
xxx_messageInfo_MsgCreateAllowlistRequest.DiscardUnknown(m)
func (m *MsgCreateAllowlistEntryRequest) XXX_DiscardUnknown() {
xxx_messageInfo_MsgCreateAllowlistEntryRequest.DiscardUnknown(m)
}
var xxx_messageInfo_MsgCreateAllowlistRequest proto.InternalMessageInfo
var xxx_messageInfo_MsgCreateAllowlistEntryRequest proto.InternalMessageInfo
func (m *MsgCreateAllowlistRequest) GetSigner() string {
func (m *MsgCreateAllowlistEntryRequest) GetSigner() string {
if m != nil {
return m.Signer
}
return ""
}
func (m *MsgCreateAllowlistRequest) GetAddress() string {
func (m *MsgCreateAllowlistEntryRequest) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *MsgCreateAllowlistRequest) GetName() string {
func (m *MsgCreateAllowlistEntryRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
type MsgDeleteAllowlistRequest struct {
type MsgDeleteAllowlistEntryRequest struct {
// signer should be a guardian validator in a current set or future set.
Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
// the address allowlist to remove
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}
func (m *MsgDeleteAllowlistRequest) Reset() { *m = MsgDeleteAllowlistRequest{} }
func (m *MsgDeleteAllowlistRequest) String() string { return proto.CompactTextString(m) }
func (*MsgDeleteAllowlistRequest) ProtoMessage() {}
func (*MsgDeleteAllowlistRequest) Descriptor() ([]byte, []int) {
func (m *MsgDeleteAllowlistEntryRequest) Reset() { *m = MsgDeleteAllowlistEntryRequest{} }
func (m *MsgDeleteAllowlistEntryRequest) String() string { return proto.CompactTextString(m) }
func (*MsgDeleteAllowlistEntryRequest) ProtoMessage() {}
func (*MsgDeleteAllowlistEntryRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_55f7aa067b0c517b, []int{1}
}
func (m *MsgDeleteAllowlistRequest) XXX_Unmarshal(b []byte) error {
func (m *MsgDeleteAllowlistEntryRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgDeleteAllowlistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *MsgDeleteAllowlistEntryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgDeleteAllowlistRequest.Marshal(b, m, deterministic)
return xxx_messageInfo_MsgDeleteAllowlistEntryRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@ -119,26 +119,26 @@ func (m *MsgDeleteAllowlistRequest) XXX_Marshal(b []byte, deterministic bool) ([
return b[:n], nil
}
}
func (m *MsgDeleteAllowlistRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgDeleteAllowlistRequest.Merge(m, src)
func (m *MsgDeleteAllowlistEntryRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgDeleteAllowlistEntryRequest.Merge(m, src)
}
func (m *MsgDeleteAllowlistRequest) XXX_Size() int {
func (m *MsgDeleteAllowlistEntryRequest) XXX_Size() int {
return m.Size()
}
func (m *MsgDeleteAllowlistRequest) XXX_DiscardUnknown() {
xxx_messageInfo_MsgDeleteAllowlistRequest.DiscardUnknown(m)
func (m *MsgDeleteAllowlistEntryRequest) XXX_DiscardUnknown() {
xxx_messageInfo_MsgDeleteAllowlistEntryRequest.DiscardUnknown(m)
}
var xxx_messageInfo_MsgDeleteAllowlistRequest proto.InternalMessageInfo
var xxx_messageInfo_MsgDeleteAllowlistEntryRequest proto.InternalMessageInfo
func (m *MsgDeleteAllowlistRequest) GetSigner() string {
func (m *MsgDeleteAllowlistEntryRequest) GetSigner() string {
if m != nil {
return m.Signer
}
return ""
}
func (m *MsgDeleteAllowlistRequest) GetAddress() string {
func (m *MsgDeleteAllowlistEntryRequest) GetAddress() string {
if m != nil {
return m.Address
}
@ -603,8 +603,8 @@ func (m *MsgInstantiateContractResponse) GetData() []byte {
}
func init() {
proto.RegisterType((*MsgCreateAllowlistRequest)(nil), "wormhole_foundation.wormchain.wormhole.MsgCreateAllowlistRequest")
proto.RegisterType((*MsgDeleteAllowlistRequest)(nil), "wormhole_foundation.wormchain.wormhole.MsgDeleteAllowlistRequest")
proto.RegisterType((*MsgCreateAllowlistEntryRequest)(nil), "wormhole_foundation.wormchain.wormhole.MsgCreateAllowlistEntryRequest")
proto.RegisterType((*MsgDeleteAllowlistEntryRequest)(nil), "wormhole_foundation.wormchain.wormhole.MsgDeleteAllowlistEntryRequest")
proto.RegisterType((*MsgAllowlistResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgAllowlistResponse")
proto.RegisterType((*MsgExecuteGovernanceVAA)(nil), "wormhole_foundation.wormchain.wormhole.MsgExecuteGovernanceVAA")
proto.RegisterType((*MsgExecuteGovernanceVAAResponse)(nil), "wormhole_foundation.wormchain.wormhole.MsgExecuteGovernanceVAAResponse")
@ -619,47 +619,48 @@ func init() {
func init() { proto.RegisterFile("wormhole/tx.proto", fileDescriptor_55f7aa067b0c517b) }
var fileDescriptor_55f7aa067b0c517b = []byte{
// 635 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x41, 0x6b, 0xd4, 0x4e,
0x14, 0x6f, 0xba, 0xed, 0x96, 0x3e, 0xc2, 0xff, 0x5f, 0xe3, 0x52, 0xd3, 0xa5, 0xa4, 0x1a, 0xa5,
0x78, 0x71, 0x03, 0x2a, 0x82, 0x28, 0x4a, 0xb6, 0xd5, 0x52, 0x30, 0x1e, 0x52, 0x51, 0xf0, 0xb2,
0xcc, 0x26, 0xe3, 0x34, 0x90, 0xcc, 0xac, 0x99, 0x49, 0xbb, 0x7b, 0xf2, 0x23, 0x28, 0xde, 0x05,
0x2f, 0x9e, 0xfd, 0x1a, 0x1e, 0x7b, 0xf4, 0x54, 0x64, 0xf7, 0x8b, 0x48, 0x26, 0x26, 0xbb, 0x74,
0x13, 0x31, 0x6c, 0x6f, 0xef, 0xbd, 0xc9, 0xfb, 0xfd, 0x7e, 0xef, 0xe5, 0xcd, 0x1b, 0xb8, 0x72,
0xca, 0xe2, 0xe8, 0x98, 0x85, 0xd8, 0x12, 0xc3, 0xce, 0x20, 0x66, 0x82, 0x69, 0xbb, 0x79, 0xa8,
0xf7, 0x8e, 0x25, 0xd4, 0x47, 0x22, 0x60, 0xb4, 0x93, 0xc6, 0xbc, 0x63, 0x14, 0x64, 0x56, 0x7a,
0xda, 0x6e, 0x11, 0x46, 0x98, 0x4c, 0xb1, 0x52, 0x2b, 0xcb, 0x36, 0x11, 0x6c, 0x39, 0x9c, 0xec,
0xc5, 0x18, 0x09, 0x6c, 0x87, 0x21, 0x3b, 0x0d, 0x03, 0x2e, 0x5c, 0xfc, 0x3e, 0xc1, 0x5c, 0x68,
0x9b, 0xd0, 0xe4, 0x01, 0xa1, 0x38, 0xd6, 0x95, 0xeb, 0xca, 0xed, 0x75, 0xf7, 0x8f, 0xa7, 0xe9,
0xb0, 0x86, 0x7c, 0x3f, 0xc6, 0x9c, 0xeb, 0xcb, 0xf2, 0x20, 0x77, 0x35, 0x0d, 0x56, 0x28, 0x8a,
0xb0, 0xde, 0x90, 0x61, 0x69, 0x9b, 0x8e, 0xa4, 0xd8, 0xc7, 0x21, 0xbe, 0x0c, 0x0a, 0x73, 0x13,
0x5a, 0x0e, 0x27, 0x33, 0x40, 0x7c, 0xc0, 0x28, 0xc7, 0xe6, 0x1e, 0x5c, 0x73, 0x38, 0x79, 0x36,
0xc4, 0x5e, 0x22, 0xf0, 0x01, 0x3b, 0xc1, 0x31, 0x45, 0xd4, 0xc3, 0xaf, 0x6d, 0x5b, 0xdb, 0x80,
0xc6, 0x09, 0x42, 0x92, 0x41, 0x75, 0x53, 0x73, 0x86, 0x76, 0x79, 0x96, 0xd6, 0xbc, 0x01, 0x3b,
0x15, 0x20, 0x05, 0xcf, 0x2b, 0xd8, 0x76, 0x38, 0x71, 0x31, 0x09, 0xb8, 0xc0, 0xb1, 0xed, 0x79,
0x2c, 0xa1, 0xc2, 0xe6, 0x07, 0x09, 0x8a, 0xfd, 0x00, 0xd1, 0xca, 0x8a, 0xb6, 0x61, 0x3d, 0xb5,
0x90, 0x48, 0xe2, 0xac, 0x3f, 0xaa, 0x3b, 0x0d, 0x98, 0xbb, 0x70, 0xeb, 0x6f, 0xa8, 0x05, 0xfb,
0x00, 0x54, 0x87, 0x93, 0x23, 0xc1, 0x62, 0xbc, 0xc7, 0x7c, 0x5c, 0xc9, 0xf6, 0x00, 0xfe, 0x3b,
0x45, 0x3c, 0xea, 0xf5, 0x47, 0x02, 0xf7, 0x3c, 0xe6, 0x63, 0x59, 0xa8, 0xda, 0xdd, 0x18, 0x9f,
0xef, 0xa8, 0x6f, 0xec, 0x23, 0xa7, 0x3b, 0x12, 0x12, 0xc1, 0x55, 0xd3, 0xef, 0x72, 0x2f, 0x6f,
0x55, 0xa3, 0x68, 0x95, 0xf9, 0x48, 0xf6, 0xbb, 0x60, 0xcc, 0x95, 0x68, 0x37, 0x61, 0x2d, 0xc5,
0xed, 0x05, 0xbe, 0xa4, 0x5e, 0xe9, 0xc2, 0xf8, 0x7c, 0xa7, 0x99, 0x7e, 0x72, 0xb8, 0xef, 0x36,
0xd3, 0xa3, 0x43, 0xdf, 0xfc, 0xa8, 0xc0, 0xa6, 0xc3, 0xc9, 0x21, 0xe5, 0x02, 0x51, 0x11, 0xa0,
0x94, 0x85, 0x8a, 0x18, 0x79, 0xd5, 0x7f, 0x7e, 0x06, 0xb7, 0x51, 0x85, 0xab, 0xb5, 0x60, 0x35,
0x44, 0x7d, 0x1c, 0xea, 0x2b, 0x32, 0x37, 0x73, 0x52, 0xf1, 0x11, 0x27, 0xfa, 0x6a, 0x26, 0x3e,
0xe2, 0x24, 0x2f, 0xa7, 0x39, 0x2d, 0xe7, 0x25, 0x18, 0xe5, 0x82, 0x8a, 0xc2, 0x66, 0x46, 0x4f,
0x99, 0x9b, 0x6e, 0x1f, 0x09, 0x94, 0xb5, 0xd2, 0x95, 0xf6, 0xdd, 0x6f, 0x6b, 0xd0, 0x70, 0x38,
0xd1, 0xbe, 0x2a, 0xd0, 0x2a, 0x1d, 0xbe, 0xa7, 0x9d, 0x7f, 0xbb, 0xa0, 0x9d, 0x8a, 0xc1, 0x6b,
0x1f, 0x2c, 0x08, 0x50, 0x14, 0xf6, 0x5d, 0x81, 0xad, 0xea, 0xb9, 0xdd, 0xaf, 0x41, 0x53, 0x89,
0xd2, 0x7e, 0x71, 0x19, 0x28, 0x85, 0xe2, 0xcf, 0x0a, 0xfc, 0x7f, 0x61, 0x37, 0x69, 0x76, 0x0d,
0x86, 0xf2, 0xbd, 0xd6, 0x7e, 0x5c, 0x03, 0x62, 0x6e, 0xd1, 0x48, 0x51, 0x17, 0xb6, 0x59, 0x2d,
0x51, 0xe5, 0x9b, 0x70, 0x41, 0x51, 0x1f, 0x60, 0x7d, 0xba, 0x14, 0xee, 0xd7, 0x80, 0x2a, 0xb2,
0x6a, 0x09, 0x98, 0x5f, 0x07, 0x5f, 0x14, 0xb8, 0x5a, 0x76, 0xcd, 0x9f, 0xd4, 0x40, 0x2d, 0xc9,
0x6f, 0x3f, 0x5f, 0x2c, 0x3f, 0xd7, 0xd7, 0x3d, 0xfa, 0x31, 0x36, 0x94, 0xb3, 0xb1, 0xa1, 0xfc,
0x1a, 0x1b, 0xca, 0xa7, 0x89, 0xb1, 0x74, 0x36, 0x31, 0x96, 0x7e, 0x4e, 0x8c, 0xa5, 0xb7, 0x0f,
0x49, 0x20, 0x8e, 0x93, 0x7e, 0xc7, 0x63, 0x91, 0x95, 0xa3, 0xdd, 0x99, 0x72, 0x59, 0x05, 0x97,
0x35, 0xb4, 0xa6, 0xcf, 0xef, 0x68, 0x80, 0x79, 0xbf, 0x29, 0x1f, 0xd1, 0x7b, 0xbf, 0x03, 0x00,
0x00, 0xff, 0xff, 0x6a, 0x6d, 0xca, 0x8f, 0x97, 0x07, 0x00, 0x00,
// 642 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcf, 0x6e, 0xd3, 0x4e,
0x10, 0xae, 0x9b, 0x36, 0x55, 0x47, 0xd1, 0x4f, 0xfd, 0x99, 0xa8, 0x84, 0xa8, 0x72, 0xc1, 0xa0,
0x8a, 0x0b, 0x89, 0x04, 0x08, 0x09, 0x81, 0x40, 0x49, 0xff, 0xa9, 0x12, 0xe6, 0xe0, 0x22, 0x90,
0xb8, 0x44, 0x1b, 0x7b, 0xba, 0xb5, 0x64, 0xef, 0x86, 0xdd, 0x75, 0xdb, 0x9c, 0x78, 0x04, 0x78,
0x00, 0x90, 0x78, 0x03, 0xce, 0xbc, 0x01, 0xc7, 0x1e, 0x39, 0x55, 0x28, 0x7d, 0x11, 0xe4, 0x35,
0x76, 0x22, 0xd5, 0xae, 0xb0, 0xda, 0xdb, 0xcc, 0xac, 0xe7, 0xfb, 0xbe, 0x19, 0xcf, 0xce, 0xc2,
0xff, 0xc7, 0x5c, 0x44, 0x87, 0x3c, 0xc4, 0xae, 0x3a, 0xe9, 0x8c, 0x04, 0x57, 0xdc, 0xdc, 0xc8,
0x42, 0x83, 0x03, 0x1e, 0x33, 0x9f, 0xa8, 0x80, 0xb3, 0x4e, 0x12, 0xf3, 0x0e, 0x49, 0x90, 0x5a,
0xc9, 0x69, 0xbb, 0x49, 0x39, 0xe5, 0x3a, 0xa5, 0x9b, 0x58, 0x69, 0xb6, 0x7d, 0x00, 0x96, 0x23,
0xe9, 0xa6, 0x40, 0xa2, 0xb0, 0x17, 0x86, 0xfc, 0x38, 0x0c, 0xa4, 0xda, 0x66, 0x4a, 0x8c, 0x5d,
0xfc, 0x10, 0xa3, 0x54, 0xe6, 0x2a, 0xd4, 0x65, 0x40, 0x19, 0x8a, 0x96, 0x71, 0xdb, 0xb8, 0xbf,
0xec, 0xfe, 0xf5, 0xcc, 0x16, 0x2c, 0x11, 0xdf, 0x17, 0x28, 0x65, 0x6b, 0x5e, 0x1f, 0x64, 0xae,
0x69, 0xc2, 0x02, 0x23, 0x11, 0xb6, 0x6a, 0x3a, 0xac, 0x6d, 0xdb, 0xd5, 0x3c, 0x5b, 0x18, 0xe2,
0xb5, 0xf1, 0xd8, 0xab, 0xd0, 0x74, 0x24, 0xcd, 0xd1, 0x5c, 0x94, 0x23, 0xce, 0x24, 0xda, 0x9b,
0x70, 0xd3, 0x91, 0x74, 0xfb, 0x04, 0xbd, 0x58, 0xe1, 0x2e, 0x3f, 0x42, 0xc1, 0x08, 0xf3, 0xf0,
0x6d, 0xaf, 0x67, 0xae, 0x40, 0xed, 0x88, 0x10, 0xcd, 0xd0, 0x70, 0x13, 0x73, 0x86, 0x76, 0x7e,
0x96, 0xd6, 0xbe, 0x03, 0xeb, 0x25, 0x20, 0x39, 0xcf, 0x1b, 0x58, 0x73, 0x24, 0x75, 0x91, 0x06,
0x52, 0xa1, 0xe8, 0x79, 0x1e, 0x8f, 0x99, 0xea, 0xc9, 0xdd, 0x98, 0x08, 0x3f, 0x20, 0xac, 0xb4,
0xa2, 0x35, 0x58, 0x4e, 0x2c, 0xa2, 0x62, 0x91, 0x36, 0xa9, 0xe1, 0x4e, 0x03, 0xf6, 0x06, 0xdc,
0xbb, 0x0c, 0x35, 0x67, 0x1f, 0x41, 0xc3, 0x91, 0x74, 0x5f, 0x71, 0x81, 0x9b, 0xdc, 0xc7, 0x52,
0xb6, 0x27, 0xf0, 0xdf, 0x31, 0x91, 0xd1, 0x60, 0x38, 0x56, 0x38, 0xf0, 0xb8, 0x8f, 0xba, 0xd0,
0x46, 0x7f, 0x65, 0x72, 0xb6, 0xde, 0x78, 0xd7, 0xdb, 0x77, 0xfa, 0x63, 0xa5, 0x11, 0xdc, 0x46,
0xf2, 0x5d, 0xe6, 0x65, 0xad, 0xaa, 0xe5, 0xad, 0xb2, 0x9f, 0xe9, 0x7e, 0xe7, 0x8c, 0x99, 0x12,
0xf3, 0x2e, 0x2c, 0x25, 0xb8, 0x83, 0xc0, 0xd7, 0xd4, 0x0b, 0x7d, 0x98, 0x9c, 0xad, 0xd7, 0x93,
0x4f, 0xf6, 0xb6, 0xdc, 0x7a, 0x72, 0xb4, 0xe7, 0xdb, 0x9f, 0x0c, 0x58, 0x75, 0x24, 0xdd, 0x63,
0x52, 0x11, 0xa6, 0x02, 0x92, 0xb0, 0x30, 0x25, 0x88, 0x57, 0xfe, 0xe7, 0x67, 0x70, 0x6b, 0x65,
0xb8, 0x66, 0x13, 0x16, 0x43, 0x32, 0xc4, 0xb0, 0xb5, 0xa0, 0x73, 0x53, 0x27, 0x11, 0x1f, 0x49,
0xda, 0x5a, 0x4c, 0xc5, 0x47, 0x92, 0x66, 0xe5, 0xd4, 0xa7, 0xe5, 0xbc, 0xd6, 0x23, 0x59, 0x20,
0x28, 0x2f, 0x6c, 0x66, 0xf4, 0x8c, 0x0b, 0x23, 0xee, 0x13, 0x45, 0xd2, 0x56, 0xba, 0xda, 0x7e,
0xf8, 0x63, 0x09, 0x6a, 0x8e, 0xa4, 0xe6, 0x37, 0x03, 0x9a, 0x85, 0xc3, 0xf7, 0xb2, 0xf3, 0x6f,
0x57, 0xb5, 0x53, 0x32, 0x78, 0xed, 0xdd, 0x2b, 0x02, 0xe4, 0x85, 0x7d, 0x37, 0xe0, 0x56, 0xf9,
0xdc, 0x6e, 0x55, 0xa0, 0x29, 0x45, 0x69, 0xbf, 0xba, 0x0e, 0x94, 0x5c, 0xf1, 0x17, 0x03, 0x9a,
0x45, 0x5b, 0xca, 0xdc, 0xa9, 0x40, 0x73, 0xc9, 0x9a, 0x6b, 0x3f, 0xaf, 0x80, 0x73, 0x61, 0xe5,
0x68, 0x79, 0x45, 0xcb, 0xad, 0x92, 0xbc, 0x4b, 0xb6, 0xe3, 0x15, 0xe5, 0x7d, 0x84, 0xe5, 0xe9,
0xa2, 0x78, 0x5c, 0x01, 0x2a, 0xcf, 0xaa, 0x24, 0xe0, 0xe2, 0x8a, 0xf8, 0x6a, 0xc0, 0x8d, 0xa2,
0xab, 0xff, 0xa2, 0x02, 0x6a, 0x41, 0x7e, 0x7b, 0xe7, 0x6a, 0xf9, 0x99, 0xbe, 0xfe, 0xfe, 0xcf,
0x89, 0x65, 0x9c, 0x4e, 0x2c, 0xe3, 0xf7, 0xc4, 0x32, 0x3e, 0x9f, 0x5b, 0x73, 0xa7, 0xe7, 0xd6,
0xdc, 0xaf, 0x73, 0x6b, 0xee, 0xfd, 0x53, 0x1a, 0xa8, 0xc3, 0x78, 0xd8, 0xf1, 0x78, 0xd4, 0xcd,
0xd0, 0x1e, 0x4c, 0xb9, 0xba, 0x39, 0x57, 0xf7, 0xa4, 0x3b, 0x7d, 0x9c, 0xc7, 0x23, 0x94, 0xc3,
0xba, 0x7e, 0x62, 0x1f, 0xfd, 0x09, 0x00, 0x00, 0xff, 0xff, 0x86, 0x0b, 0xf1, 0x5c, 0xb5, 0x07,
0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -676,8 +677,8 @@ const _ = grpc.SupportPackageIsVersion4
type MsgClient interface {
ExecuteGovernanceVAA(ctx context.Context, in *MsgExecuteGovernanceVAA, opts ...grpc.CallOption) (*MsgExecuteGovernanceVAAResponse, error)
RegisterAccountAsGuardian(ctx context.Context, in *MsgRegisterAccountAsGuardian, opts ...grpc.CallOption) (*MsgRegisterAccountAsGuardianResponse, error)
CreateAllowlist(ctx context.Context, in *MsgCreateAllowlistRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error)
DeleteAllowlist(ctx context.Context, in *MsgDeleteAllowlistRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error)
CreateAllowlistEntry(ctx context.Context, in *MsgCreateAllowlistEntryRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error)
DeleteAllowlistEntry(ctx context.Context, in *MsgDeleteAllowlistEntryRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error)
// StoreCode to submit Wasm code to the system
StoreCode(ctx context.Context, in *MsgStoreCode, opts ...grpc.CallOption) (*MsgStoreCodeResponse, error)
// Instantiate creates a new smart contract instance for the given code id.
@ -710,18 +711,18 @@ func (c *msgClient) RegisterAccountAsGuardian(ctx context.Context, in *MsgRegist
return out, nil
}
func (c *msgClient) CreateAllowlist(ctx context.Context, in *MsgCreateAllowlistRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error) {
func (c *msgClient) CreateAllowlistEntry(ctx context.Context, in *MsgCreateAllowlistEntryRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error) {
out := new(MsgAllowlistResponse)
err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/CreateAllowlist", in, out, opts...)
err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/CreateAllowlistEntry", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *msgClient) DeleteAllowlist(ctx context.Context, in *MsgDeleteAllowlistRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error) {
func (c *msgClient) DeleteAllowlistEntry(ctx context.Context, in *MsgDeleteAllowlistEntryRequest, opts ...grpc.CallOption) (*MsgAllowlistResponse, error) {
out := new(MsgAllowlistResponse)
err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/DeleteAllowlist", in, out, opts...)
err := c.cc.Invoke(ctx, "/wormhole_foundation.wormchain.wormhole.Msg/DeleteAllowlistEntry", in, out, opts...)
if err != nil {
return nil, err
}
@ -750,8 +751,8 @@ func (c *msgClient) InstantiateContract(ctx context.Context, in *MsgInstantiateC
type MsgServer interface {
ExecuteGovernanceVAA(context.Context, *MsgExecuteGovernanceVAA) (*MsgExecuteGovernanceVAAResponse, error)
RegisterAccountAsGuardian(context.Context, *MsgRegisterAccountAsGuardian) (*MsgRegisterAccountAsGuardianResponse, error)
CreateAllowlist(context.Context, *MsgCreateAllowlistRequest) (*MsgAllowlistResponse, error)
DeleteAllowlist(context.Context, *MsgDeleteAllowlistRequest) (*MsgAllowlistResponse, error)
CreateAllowlistEntry(context.Context, *MsgCreateAllowlistEntryRequest) (*MsgAllowlistResponse, error)
DeleteAllowlistEntry(context.Context, *MsgDeleteAllowlistEntryRequest) (*MsgAllowlistResponse, error)
// StoreCode to submit Wasm code to the system
StoreCode(context.Context, *MsgStoreCode) (*MsgStoreCodeResponse, error)
// Instantiate creates a new smart contract instance for the given code id.
@ -768,11 +769,11 @@ func (*UnimplementedMsgServer) ExecuteGovernanceVAA(ctx context.Context, req *Ms
func (*UnimplementedMsgServer) RegisterAccountAsGuardian(ctx context.Context, req *MsgRegisterAccountAsGuardian) (*MsgRegisterAccountAsGuardianResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method RegisterAccountAsGuardian not implemented")
}
func (*UnimplementedMsgServer) CreateAllowlist(ctx context.Context, req *MsgCreateAllowlistRequest) (*MsgAllowlistResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CreateAllowlist not implemented")
func (*UnimplementedMsgServer) CreateAllowlistEntry(ctx context.Context, req *MsgCreateAllowlistEntryRequest) (*MsgAllowlistResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CreateAllowlistEntry not implemented")
}
func (*UnimplementedMsgServer) DeleteAllowlist(ctx context.Context, req *MsgDeleteAllowlistRequest) (*MsgAllowlistResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DeleteAllowlist not implemented")
func (*UnimplementedMsgServer) DeleteAllowlistEntry(ctx context.Context, req *MsgDeleteAllowlistEntryRequest) (*MsgAllowlistResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DeleteAllowlistEntry not implemented")
}
func (*UnimplementedMsgServer) StoreCode(ctx context.Context, req *MsgStoreCode) (*MsgStoreCodeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method StoreCode not implemented")
@ -821,38 +822,38 @@ func _Msg_RegisterAccountAsGuardian_Handler(srv interface{}, ctx context.Context
return interceptor(ctx, in, info, handler)
}
func _Msg_CreateAllowlist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgCreateAllowlistRequest)
func _Msg_CreateAllowlistEntry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgCreateAllowlistEntryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MsgServer).CreateAllowlist(ctx, in)
return srv.(MsgServer).CreateAllowlistEntry(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/CreateAllowlist",
FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/CreateAllowlistEntry",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MsgServer).CreateAllowlist(ctx, req.(*MsgCreateAllowlistRequest))
return srv.(MsgServer).CreateAllowlistEntry(ctx, req.(*MsgCreateAllowlistEntryRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Msg_DeleteAllowlist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgDeleteAllowlistRequest)
func _Msg_DeleteAllowlistEntry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgDeleteAllowlistEntryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MsgServer).DeleteAllowlist(ctx, in)
return srv.(MsgServer).DeleteAllowlistEntry(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/DeleteAllowlist",
FullMethod: "/wormhole_foundation.wormchain.wormhole.Msg/DeleteAllowlistEntry",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MsgServer).DeleteAllowlist(ctx, req.(*MsgDeleteAllowlistRequest))
return srv.(MsgServer).DeleteAllowlistEntry(ctx, req.(*MsgDeleteAllowlistEntryRequest))
}
return interceptor(ctx, in, info, handler)
}
@ -906,12 +907,12 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
Handler: _Msg_RegisterAccountAsGuardian_Handler,
},
{
MethodName: "CreateAllowlist",
Handler: _Msg_CreateAllowlist_Handler,
MethodName: "CreateAllowlistEntry",
Handler: _Msg_CreateAllowlistEntry_Handler,
},
{
MethodName: "DeleteAllowlist",
Handler: _Msg_DeleteAllowlist_Handler,
MethodName: "DeleteAllowlistEntry",
Handler: _Msg_DeleteAllowlistEntry_Handler,
},
{
MethodName: "StoreCode",
@ -926,7 +927,7 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
Metadata: "wormhole/tx.proto",
}
func (m *MsgCreateAllowlistRequest) Marshal() (dAtA []byte, err error) {
func (m *MsgCreateAllowlistEntryRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -936,12 +937,12 @@ func (m *MsgCreateAllowlistRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *MsgCreateAllowlistRequest) MarshalTo(dAtA []byte) (int, error) {
func (m *MsgCreateAllowlistEntryRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgCreateAllowlistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
func (m *MsgCreateAllowlistEntryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
@ -970,7 +971,7 @@ func (m *MsgCreateAllowlistRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
return len(dAtA) - i, nil
}
func (m *MsgDeleteAllowlistRequest) Marshal() (dAtA []byte, err error) {
func (m *MsgDeleteAllowlistEntryRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -980,12 +981,12 @@ func (m *MsgDeleteAllowlistRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *MsgDeleteAllowlistRequest) MarshalTo(dAtA []byte) (int, error) {
func (m *MsgDeleteAllowlistEntryRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgDeleteAllowlistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
func (m *MsgDeleteAllowlistEntryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
@ -1326,7 +1327,7 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func (m *MsgCreateAllowlistRequest) Size() (n int) {
func (m *MsgCreateAllowlistEntryRequest) Size() (n int) {
if m == nil {
return 0
}
@ -1347,7 +1348,7 @@ func (m *MsgCreateAllowlistRequest) Size() (n int) {
return n
}
func (m *MsgDeleteAllowlistRequest) Size() (n int) {
func (m *MsgDeleteAllowlistEntryRequest) Size() (n int) {
if m == nil {
return 0
}
@ -1509,7 +1510,7 @@ func sovTx(x uint64) (n int) {
func sozTx(x uint64) (n int) {
return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgCreateAllowlistRequest) Unmarshal(dAtA []byte) error {
func (m *MsgCreateAllowlistEntryRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -1532,10 +1533,10 @@ func (m *MsgCreateAllowlistRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MsgCreateAllowlistRequest: wiretype end group for non-group")
return fmt.Errorf("proto: MsgCreateAllowlistEntryRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgCreateAllowlistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: MsgCreateAllowlistEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@ -1655,7 +1656,7 @@ func (m *MsgCreateAllowlistRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *MsgDeleteAllowlistRequest) Unmarshal(dAtA []byte) error {
func (m *MsgDeleteAllowlistEntryRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@ -1678,10 +1679,10 @@ func (m *MsgDeleteAllowlistRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MsgDeleteAllowlistRequest: wiretype end group for non-group")
return fmt.Errorf("proto: MsgDeleteAllowlistEntryRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgDeleteAllowlistRequest: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: MsgDeleteAllowlistEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1: