smeb_y/0g-chain
1
0
Fork 0
mirror of https://github.com/0glabs/0g-chain.git synced 2024-11-14 03:55:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: DASigners change params (#67)

Browse Source 
* feat: use gov to manage dasigners params

* feat: evm precompile query func

* test: unit test

* feat: remove epoch and block height hard check

* feat: add params event
This commit is contained in:
MiniFrenchBread 2024-09-24 09:39:16 +08:00 committed by 0g-wh
parent 4409bfc996
commit 0c02c27a9d
24 changed files with 1189 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/app.go
View File

@ -509,7 +509,7 @@ func NewApp(
precompiles,
)
// dasigners keeper
app.dasignersKeeper = dasignerskeeper.NewKeeper(keys[dasignerstypes.StoreKey], appCodec, app.stakingKeeper)
app.dasignersKeeper = dasignerskeeper.NewKeeper(keys[dasignerstypes.StoreKey], appCodec, app.stakingKeeper, govAuthAddrStr)
// precopmiles
precompiles := make(map[common.Address]vm.PrecompiledContract)
daSignersPrecompile, err := dasignersprecompile.NewDASignersPrecompile(app.dasignersKeeper)

40
precompiles/dasigners/IDASigners.abi
View File

@ -268,6 +268,46 @@
"stateMutability": "view",
"type": "function"
},
{
"inputs": [],
"name": "params",
"outputs": [
{
"components": [
{
"internalType": "uint256",
"name": "tokensPerVote",
"type": "uint256"
},
{
"internalType": "uint256",
"name": "maxVotesPerSigner",
"type": "uint256"
},
{
"internalType": "uint256",
"name": "maxQuorums",
"type": "uint256"
},
{
"internalType": "uint256",
"name": "epochBlocks",
"type": "uint256"
},
{
"internalType": "uint256",
"name": "encodedSlices",
"type": "uint256"
}
],
"internalType": "struct IDASigners.Params",
"name": "",
"type": "tuple"
}
],
"stateMutability": "view",
"type": "function"
},
{
"inputs": [
{

33
precompiles/dasigners/contract.go
View File

File diff suppressed because one or more lines are too long

4
precompiles/dasigners/dasigners.go
View File

@ -18,6 +18,7 @@ const (
RequiredGasMax uint64 = 1000_000_000
DASignersFunctionParams = "params"
DASignersFunctionEpochNumber = "epochNumber"
DASignersFunctionQuorumCount = "quorumCount"
DASignersFunctionGetSigner = "getSigner"
@ -32,6 +33,7 @@ const (
)
var RequiredGasBasic = map[string]uint64{
DASignersFunctionParams: 1000,
DASignersFunctionEpochNumber: 1000,
DASignersFunctionQuorumCount: 1000,
DASignersFunctionGetSigner: 100000,
@ -117,6 +119,8 @@ func (d *DASignersPrecompile) Run(evm *vm.EVM, contract *vm.Contract, readonly b
var bz []byte
switch method.Name {
// queries
case DASignersFunctionParams:
bz, err = d.Params(ctx, evm, method, args)
case DASignersFunctionEpochNumber:
bz, err = d.EpochNumber(ctx, evm, method, args)
case DASignersFunctionQuorumCount:

19
precompiles/dasigners/dasigners_test.go
View File

@ -370,6 +370,25 @@ func (suite *DASignersTestSuite) Test_DASigners() {
}
func (suite *DASignersTestSuite) Test_Params() {
input, err := suite.abi.Pack(
"params",
)
suite.Assert().NoError(err)
bz, err := suite.runTx(input, suite.signerOne, 10000000)
suite.Assert().NoError(err)
out, err := suite.abi.Methods["params"].Outputs.Unpack(bz)
suite.Assert().NoError(err)
params := out[0].(dasignersprecompile.IDASignersParams)
expected := types.DefaultGenesisState().Params
suite.Assert().EqualValues(expected.TokensPerVote, params.TokensPerVote.Uint64())
suite.Assert().EqualValues(expected.MaxVotesPerSigner, params.MaxVotesPerSigner.Uint64())
suite.Assert().EqualValues(expected.MaxQuorums, params.MaxQuorums.Uint64())
suite.Assert().EqualValues(expected.EpochBlocks, params.EpochBlocks.Uint64())
suite.Assert().EqualValues(expected.EncodedSlices, params.EncodedSlices.Uint64())
}
func TestKeeperSuite(t *testing.T) {
suite.Run(t, new(DASignersTestSuite))
}

11
precompiles/dasigners/query.go
View File

@ -11,6 +11,17 @@ import (
"github.com/ethereum/go-ethereum/core/vm"
)
func (d *DASignersPrecompile) Params(ctx sdk.Context, _ *vm.EVM, method *abi.Method, _ []interface{}) ([]byte, error) {
params := d.dasignersKeeper.GetParams(ctx)
return method.Outputs.Pack(IDASignersParams{
TokensPerVote: big.NewInt(int64(params.TokensPerVote)),
MaxVotesPerSigner: big.NewInt(int64(params.MaxVotesPerSigner)),
MaxQuorums: big.NewInt(int64(params.MaxQuorums)),
EpochBlocks: big.NewInt(int64(params.EpochBlocks)),
EncodedSlices: big.NewInt(int64(params.EncodedSlices)),
})
}
func (d *DASignersPrecompile) EpochNumber(ctx sdk.Context, _ *vm.EVM, method *abi.Method, _ []interface{}) ([]byte, error) {
epochNumber, err := d.dasignersKeeper.GetEpochNumber(ctx)
if err != nil {

8
precompiles/dasigners/types.go
View File

@ -27,6 +27,14 @@ type IDASignersSignerDetail = struct {
PkG2 BN254G2Point "json:\"pkG2\""
}
type IDASignersParams = struct {
TokensPerVote *big.Int "json:\"tokensPerVote\""
MaxVotesPerSigner *big.Int "json:\"maxVotesPerSigner\""
MaxQuorums *big.Int "json:\"maxQuorums\""
EpochBlocks *big.Int "json:\"epochBlocks\""
EncodedSlices *big.Int "json:\"encodedSlices\""
}
func NewBN254G1Point(b []byte) BN254G1Point {
return BN254G1Point{
X: new(big.Int).SetBytes(b[:32]),

10
proto/zgc/dasigners/v1/query.proto
View File

@ -7,12 +7,16 @@ import "google/api/annotations.proto";
import "google/protobuf/any.proto";
import "google/protobuf/timestamp.proto";
import "zgc/dasigners/v1/dasigners.proto";
import "zgc/dasigners/v1/genesis.proto";
option go_package = "github.com/0glabs/0g-chain/x/dasigners/v1/types";
option (gogoproto.goproto_getters_all) = false;
// Query defines the gRPC querier service for the dasigners module
service Query {
rpc Params(QueryParamsRequest) returns (QueryParamsResponse) {
option (google.api.http).get = "/0g/dasigners/v1/params";
}
rpc EpochNumber(QueryEpochNumberRequest) returns (QueryEpochNumberResponse) {
option (google.api.http).get = "/0g/dasigners/v1/epoch-number";
}
@ -33,6 +37,12 @@ service Query {
}
}
message QueryParamsRequest {}
message QueryParamsResponse {
Params params = 1;
}
message QuerySignerRequest {
repeated string accounts = 1;
}

9
proto/zgc/dasigners/v1/tx.proto
View File

@ -5,17 +5,26 @@ import "cosmos_proto/cosmos.proto";
import "gogoproto/gogo.proto";
import "google/protobuf/any.proto";
import "zgc/dasigners/v1/dasigners.proto";
import "zgc/dasigners/v1/genesis.proto";
option go_package = "github.com/0glabs/0g-chain/x/dasigners/v1/types";
option (gogoproto.goproto_getters_all) = false;
// Msg defines the dasigners Msg service
service Msg {
rpc ChangeParams(MsgChangeParams) returns (MsgChangeParamsResponse);
rpc RegisterSigner(MsgRegisterSigner) returns (MsgRegisterSignerResponse);
rpc UpdateSocket(MsgUpdateSocket) returns (MsgUpdateSocketResponse);
rpc RegisterNextEpoch(MsgRegisterNextEpoch) returns (MsgRegisterNextEpochResponse);
}
message MsgChangeParams {
string authority = 1;
Params params = 2;
}
message MsgChangeParamsResponse {}
message MsgRegisterSigner {
Signer signer = 1;
bytes signature = 2;

26
x/dasigners/v1/keeper/abci.go
View File

@ -17,22 +17,17 @@ type Ballot struct {
content []byte
}
// generateOneEpoch generate one epoch and returns true if there is a new epoch generated
func (k Keeper) generateOneEpoch(ctx sdk.Context) bool {
func (k Keeper) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) {
params := k.GetParams(ctx)
if uint64(ctx.BlockHeight())%params.EpochBlocks != 0 {
return
}
epochNumber, err := k.GetEpochNumber(ctx)
if err != nil {
k.Logger(ctx).Error("[BeginBlock] cannot get epoch number")
panic(err)
}
params := k.GetParams(ctx)
expectedEpoch := uint64(ctx.BlockHeight()) / params.EpochBlocks
if expectedEpoch == epochNumber {
return false
}
if expectedEpoch < epochNumber {
panic("block height is not continuous")
}
expectedEpoch = epochNumber + 1
expectedEpoch := epochNumber + 1
// new epoch
k.Logger(ctx).Info(fmt.Sprintf("[BeginBlock] generating epoch %v", expectedEpoch))
registrations := []Ballot{}
@ -110,11 +105,6 @@ func (k Keeper) generateOneEpoch(ctx sdk.Context) bool {
// save to store
k.SetEpochQuorums(ctx, expectedEpoch, quorums)
k.SetEpochNumber(ctx, expectedEpoch)
k.Logger(ctx).Info(fmt.Sprintf("[BeginBlock] epoch %v generated, with %v quorums", expectedEpoch, len(quorums.Quorums)))
return true
}
func (k Keeper) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) {
for k.generateOneEpoch(ctx) {
}
k.Logger(ctx).Info(fmt.Sprintf("[BeginBlock] epoch %v generated at block height %v, with %v quorums", expectedEpoch, ctx.BlockHeight(), len(quorums.Quorums)))
return
}

6
x/dasigners/v1/keeper/abci_test.go
View File

@ -31,11 +31,7 @@ func (suite *AbciTestSuite) TestBeginBlock_NotContinuous() {
})
epoch, err = suite.Keeper.GetEpochNumber(suite.Ctx)
suite.Require().NoError(err)
suite.Assert().EqualValues(epoch, 10)
suite.Assert().Panics(func() {
suite.Keeper.BeginBlock(suite.Ctx.WithBlockHeight(int64(params.EpochBlocks*9)), abci.RequestBeginBlock{})
}, "block height is not continuous")
suite.Assert().EqualValues(epoch, 1)
}
func (suite *AbciTestSuite) TestBeginBlock_Success() {

11
x/dasigners/v1/keeper/grpc_query.go
View File

@ -11,6 +11,17 @@ import (
var _ types.QueryServer = Keeper{}
func (k Keeper) Params(
c context.Context,
request *types.QueryParamsRequest,
) (*types.QueryParamsResponse, error) {
ctx := sdk.UnwrapSDKContext(c)
params := k.GetParams(ctx)
return &types.QueryParamsResponse{
Params: &params,
}, nil
}
func (k Keeper) Signer(
c context.Context,
request *types.QuerySignerRequest,

19
x/dasigners/v1/keeper/keeper.go
View File

@ -2,18 +2,21 @@ package keeper
import (
"encoding/hex"
"fmt"
"math/big"
"cosmossdk.io/math"
"github.com/cometbft/cometbft/libs/log"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/store/prefix"
storetypes "github.com/cosmos/cosmos-sdk/store/types"
sdk "github.com/cosmos/cosmos-sdk/types"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/x/dasigners/v1/types"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
)
var BondedConversionRate = math.NewIntFromBigInt(big.NewInt(0).Exp(big.NewInt(10), big.NewInt(chaincfg.GasDenomUnit), nil))
@ -22,6 +25,7 @@ type Keeper struct {
storeKey storetypes.StoreKey
cdc codec.BinaryCodec
stakingKeeper types.StakingKeeper
authority string // the address capable of changing signers params. Should be the gov module account
}
// NewKeeper creates a new das Keeper instance
@ -29,11 +33,13 @@ func NewKeeper(
storeKey storetypes.StoreKey,
cdc codec.BinaryCodec,
stakingKeeper types.StakingKeeper,
authority string,
) Keeper {
return Keeper{
storeKey: storeKey,
cdc: cdc,
stakingKeeper: stakingKeeper,
authority: authority,
}
}
@ -54,6 +60,17 @@ func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
store := ctx.KVStore(k.storeKey)
bz := k.cdc.MustMarshal(&params)
store.Set(types.ParamsKey, bz)
ctx.EventManager().EmitEvent(
sdk.NewEvent(
types.EventTypeUpdateParams,
sdk.NewAttribute(types.AttributeKeyBlockHeight, fmt.Sprint(ctx.BlockHeader().Height)),
sdk.NewAttribute(types.AttributeKeyTokensPerVote, fmt.Sprint(params.TokensPerVote)),
sdk.NewAttribute(types.AttributeKeyMaxQuorums, fmt.Sprint(params.MaxQuorums)),
sdk.NewAttribute(types.AttributeKeyEpochBlocks, fmt.Sprint(params.EpochBlocks)),
sdk.NewAttribute(types.AttributeKeyEncodedSlices, fmt.Sprint(params.EncodedSlices)),
),
)
}
func (k Keeper) GetEpochNumber(ctx sdk.Context) (uint64, error) {

13
x/dasigners/v1/keeper/msg_server.go
View File

@ -3,15 +3,28 @@ package keeper
import (
"context"
errorsmod "cosmossdk.io/errors"
"github.com/0glabs/0g-chain/crypto/bn254util"
"github.com/0glabs/0g-chain/x/dasigners/v1/types"
sdk "github.com/cosmos/cosmos-sdk/types"
gov "github.com/cosmos/cosmos-sdk/x/gov/types"
"github.com/ethereum/go-ethereum/common"
etherminttypes "github.com/evmos/ethermint/types"
)
var _ types.MsgServer = &Keeper{}
func (k Keeper) ChangeParams(goCtx context.Context, msg *types.MsgChangeParams) (*types.MsgChangeParamsResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
// validate authority
if k.authority != msg.Authority {
return nil, errorsmod.Wrapf(gov.ErrInvalidSigner, "expected %s got %s", k.authority, msg.Authority)
}
// save params
k.SetParams(ctx, *msg.Params)
return &types.MsgChangeParamsResponse{}, nil
}
func (k Keeper) RegisterSigner(goCtx context.Context, msg *types.MsgRegisterSigner) (*types.MsgRegisterSignerResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
// validate sender

87
x/dasigners/v1/keeper/msg_server_test.go Normal file
View File

@ -0,0 +1,87 @@
package keeper_test
import (
"fmt"
"testing"
"github.com/0glabs/0g-chain/x/dasigners/v1/testutil"
"github.com/0glabs/0g-chain/x/dasigners/v1/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/suite"
)
type MsgServerTestSuite struct {
testutil.Suite
}
func (suite *MsgServerTestSuite) TestChangeParams() {
govAccAddr := suite.GovKeeper.GetGovernanceAccount(suite.Ctx).GetAddress().String()
testCases := []struct {
name string
req *types.MsgChangeParams
expectErr bool
errMsg string
}{
{
name: "invalid signer",
req: &types.MsgChangeParams{
Authority: suite.Addresses[0].String(),
Params: &types.Params{
TokensPerVote: 10,
MaxVotesPerSigner: 1024,
MaxQuorums: 10,
EpochBlocks: 5760,
EncodedSlices: 3072,
},
},
expectErr: true,
errMsg: "expected gov account as only signer for proposal message",
},
{
name: "success",
req: &types.MsgChangeParams{
Authority: govAccAddr,
Params: &types.Params{
TokensPerVote: 1,
MaxVotesPerSigner: 2048,
MaxQuorums: 1,
EpochBlocks: 100,
EncodedSlices: 2048 * 3,
},
},
expectErr: false,
},
}
for _, tc := range testCases {
suite.Run(tc.name, func() {
oldEventNum := len(suite.Ctx.EventManager().Events())
_, err := suite.Keeper.ChangeParams(suite.Ctx, tc.req)
if tc.expectErr {
suite.Require().Error(err)
suite.Require().Contains(err.Error(), tc.errMsg)
} else {
suite.Require().NoError(err)
params := suite.Keeper.GetParams(suite.Ctx)
suite.Require().EqualValues(*tc.req.Params, params)
suite.Assert().NoError(err)
events := suite.Ctx.EventManager().Events()
suite.Assert().EqualValues(len(events), oldEventNum+1)
suite.Assert().EqualValues(events[len(events)-1], sdk.NewEvent(
types.EventTypeUpdateParams,
sdk.NewAttribute(types.AttributeKeyBlockHeight, fmt.Sprint(suite.Ctx.BlockHeader().Height)),
sdk.NewAttribute(types.AttributeKeyTokensPerVote, fmt.Sprint(params.TokensPerVote)),
sdk.NewAttribute(types.AttributeKeyMaxQuorums, fmt.Sprint(params.MaxQuorums)),
sdk.NewAttribute(types.AttributeKeyEpochBlocks, fmt.Sprint(params.EpochBlocks)),
sdk.NewAttribute(types.AttributeKeyEncodedSlices, fmt.Sprint(params.EncodedSlices)),
),
)
}
})
}
}
func TestMsgServerSuite(t *testing.T) {
suite.Run(t, new(MsgServerTestSuite))
}

3
x/dasigners/v1/testutil/suite.go
View File

@ -14,6 +14,7 @@ import (
"github.com/0glabs/0g-chain/chaincfg"
"github.com/0glabs/0g-chain/x/dasigners/v1/keeper"
"github.com/0glabs/0g-chain/x/dasigners/v1/types"
govkeeper "github.com/cosmos/cosmos-sdk/x/gov/keeper"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/evmos/ethermint/crypto/ethsecp256k1"
)
@ -24,6 +25,7 @@ type Suite struct {
Keeper keeper.Keeper
StakingKeeper *stakingkeeper.Keeper
GovKeeper govkeeper.Keeper
App app.TestApp
Ctx sdk.Context
QueryClient types.QueryClient
@ -37,6 +39,7 @@ func (suite *Suite) SetupTest() {
suite.App.InitializeFromGenesisStates()
suite.Keeper = suite.App.GetDASignersKeeper()
suite.StakingKeeper = suite.App.GetStakingKeeper()
suite.GovKeeper = suite.App.GetGovKeeper()
// make block header
privkey, _ := ethsecp256k1.GenerateKey()

1
x/dasigners/v1/types/errors.go
View File

@ -12,4 +12,5 @@ var (
ErrQuorumBitmapLengthMismatch = errorsmod.Register(ModuleName, 7, "quorum bitmap length mismatch")
ErrInsufficientBonded = errorsmod.Register(ModuleName, 8, "insufficient bonded amount")
ErrRowIndexOutOfBound = errorsmod.Register(ModuleName, 9, "row index out of bound")
ErrInvalidEpochBlocks = errorsmod.Register(ModuleName, 10, "invalid epoch blocks")
)

7
x/dasigners/v1/types/events.go
View File

@ -3,9 +3,16 @@ package types
// Module event types
const (
EventTypeUpdateSigner = "update_signer"
EventTypeUpdateParams = "update_params"
AttributeKeySigner = "signer"
AttributeKeySocket = "socket"
AttributeKeyPublicKeyG1 = "pubkey_g1"
AttributeKeyPublicKeyG2 = "pubkey_g2"
AttributeKeyBlockHeight = "block_height"
AttributeKeyTokensPerVote = "tokens_per_vote"
AttributeKeyMaxVotesPerSigner = "max_votes_per_signer"
AttributeKeyMaxQuorums = "max_quorums"
AttributeKeyEpochBlocks = "epoch_blocks"
AttributeKeyEncodedSlices = "encoded_slices"
)

29
x/dasigners/v1/types/msg.go
View File

@ -4,14 +4,16 @@ import (
"encoding/hex"
fmt "fmt"
errorsmod "cosmossdk.io/errors"
"github.com/0glabs/0g-chain/crypto/bn254util"
sdk "github.com/cosmos/cosmos-sdk/types"
)
var _, _, _ sdk.Msg = &MsgRegisterSigner{}, &MsgUpdateSocket{}, &MsgRegisterNextEpoch{}
var _, _, _, _ sdk.Msg = &MsgRegisterSigner{}, &MsgUpdateSocket{}, &MsgRegisterNextEpoch{}, &MsgChangeParams{}
// GetSigners returns the expected signers for a MsgRegister message.
// GetSigners returns the expected signers for a MsgRegisterSigner message.
func (msg *MsgRegisterSigner) GetSigners() []sdk.AccAddress {
valAddr, err := sdk.ValAddressFromHex(msg.Signer.Account)
if err != nil {
@ -40,7 +42,7 @@ func (msg MsgRegisterSigner) GetSignBytes() []byte {
return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
}
// GetSigners returns the expected signers for a MsgVote message.
// GetSigners returns the expected signers for a MsgUpdateSocket message.
func (msg *MsgUpdateSocket) GetSigners() []sdk.AccAddress {
valAddr, err := sdk.ValAddressFromHex(msg.Account)
if err != nil {
@ -66,7 +68,7 @@ func (msg MsgUpdateSocket) GetSignBytes() []byte {
return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
}
// GetSigners returns the expected signers for a MsgVote message.
// GetSigners returns the expected signers for a MsgRegisterNextEpoch message.
func (msg *MsgRegisterNextEpoch) GetSigners() []sdk.AccAddress {
valAddr, err := sdk.ValAddressFromHex(msg.Account)
if err != nil {
@ -94,3 +96,22 @@ func (msg *MsgRegisterNextEpoch) ValidateBasic() error {
func (msg MsgRegisterNextEpoch) GetSignBytes() []byte {
return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
}
// GetSigners returns the expected signers for a MsgSetParams message.
func (msg *MsgChangeParams) GetSigners() []sdk.AccAddress {
addr, _ := sdk.AccAddressFromBech32(msg.Authority)
return []sdk.AccAddress{addr}
}
// ValidateBasic does a sanity check of the provided data
func (msg *MsgChangeParams) ValidateBasic() error {
if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil {
return errorsmod.Wrap(err, "authority")
}
if err := msg.Params.Validate(); err != nil {
return errorsmod.Wrap(err, "params")
}
return nil
}

8
x/dasigners/v1/types/params.go Normal file
View File

@ -0,0 +1,8 @@
package types
func (p *Params) Validate() error {
if p.EpochBlocks == 0 {
return ErrInvalidEpochBlocks
}
return nil
}

450
x/dasigners/v1/types/query.pb.go
View File

@ -32,6 +32,79 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type QueryParamsRequest struct {
}
func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} }
func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParamsRequest) ProtoMessage() {}
func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{0}
}
func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *QueryParamsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryParamsRequest.Merge(m, src)
}
func (m *QueryParamsRequest) XXX_Size() int {
return m.Size()
}
func (m *QueryParamsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo
type QueryParamsResponse struct {
Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
}
func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} }
func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParamsResponse) ProtoMessage() {}
func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{1}
}
func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryParamsResponse.Merge(m, src)
}
func (m *QueryParamsResponse) XXX_Size() int {
return m.Size()
}
func (m *QueryParamsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo
type QuerySignerRequest struct {
Accounts []string `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty"`
}
@ -40,7 +113,7 @@ func (m *QuerySignerRequest) Reset() { *m = QuerySignerRequest{} }
func (m *QuerySignerRequest) String() string { return proto.CompactTextString(m) }
func (*QuerySignerRequest) ProtoMessage() {}
func (*QuerySignerRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{0}
return fileDescriptor_991a610b84b5964c, []int{2}
}
func (m *QuerySignerRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -77,7 +150,7 @@ func (m *QuerySignerResponse) Reset() { *m = QuerySignerResponse{} }
func (m *QuerySignerResponse) String() string { return proto.CompactTextString(m) }
func (*QuerySignerResponse) ProtoMessage() {}
func (*QuerySignerResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{1}
return fileDescriptor_991a610b84b5964c, []int{3}
}
func (m *QuerySignerResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -113,7 +186,7 @@ func (m *QueryEpochNumberRequest) Reset() { *m = QueryEpochNumberRequest
func (m *QueryEpochNumberRequest) String() string { return proto.CompactTextString(m) }
func (*QueryEpochNumberRequest) ProtoMessage() {}
func (*QueryEpochNumberRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{2}
return fileDescriptor_991a610b84b5964c, []int{4}
}
func (m *QueryEpochNumberRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -150,7 +223,7 @@ func (m *QueryEpochNumberResponse) Reset() { *m = QueryEpochNumberRespon
func (m *QueryEpochNumberResponse) String() string { return proto.CompactTextString(m) }
func (*QueryEpochNumberResponse) ProtoMessage() {}
func (*QueryEpochNumberResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{3}
return fileDescriptor_991a610b84b5964c, []int{5}
}
func (m *QueryEpochNumberResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -187,7 +260,7 @@ func (m *QueryQuorumCountRequest) Reset() { *m = QueryQuorumCountRequest
func (m *QueryQuorumCountRequest) String() string { return proto.CompactTextString(m) }
func (*QueryQuorumCountRequest) ProtoMessage() {}
func (*QueryQuorumCountRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{4}
return fileDescriptor_991a610b84b5964c, []int{6}
}
func (m *QueryQuorumCountRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -224,7 +297,7 @@ func (m *QueryQuorumCountResponse) Reset() { *m = QueryQuorumCountRespon
func (m *QueryQuorumCountResponse) String() string { return proto.CompactTextString(m) }
func (*QueryQuorumCountResponse) ProtoMessage() {}
func (*QueryQuorumCountResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{5}
return fileDescriptor_991a610b84b5964c, []int{7}
}
func (m *QueryQuorumCountResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -262,7 +335,7 @@ func (m *QueryEpochQuorumRequest) Reset() { *m = QueryEpochQuorumRequest
func (m *QueryEpochQuorumRequest) String() string { return proto.CompactTextString(m) }
func (*QueryEpochQuorumRequest) ProtoMessage() {}
func (*QueryEpochQuorumRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{6}
return fileDescriptor_991a610b84b5964c, []int{8}
}
func (m *QueryEpochQuorumRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -299,7 +372,7 @@ func (m *QueryEpochQuorumResponse) Reset() { *m = QueryEpochQuorumRespon
func (m *QueryEpochQuorumResponse) String() string { return proto.CompactTextString(m) }
func (*QueryEpochQuorumResponse) ProtoMessage() {}
func (*QueryEpochQuorumResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{7}
return fileDescriptor_991a610b84b5964c, []int{9}
}
func (m *QueryEpochQuorumResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -338,7 +411,7 @@ func (m *QueryEpochQuorumRowRequest) Reset() { *m = QueryEpochQuorumRowR
func (m *QueryEpochQuorumRowRequest) String() string { return proto.CompactTextString(m) }
func (*QueryEpochQuorumRowRequest) ProtoMessage() {}
func (*QueryEpochQuorumRowRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{8}
return fileDescriptor_991a610b84b5964c, []int{10}
}
func (m *QueryEpochQuorumRowRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -375,7 +448,7 @@ func (m *QueryEpochQuorumRowResponse) Reset() { *m = QueryEpochQuorumRow
func (m *QueryEpochQuorumRowResponse) String() string { return proto.CompactTextString(m) }
func (*QueryEpochQuorumRowResponse) ProtoMessage() {}
func (*QueryEpochQuorumRowResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{9}
return fileDescriptor_991a610b84b5964c, []int{11}
}
func (m *QueryEpochQuorumRowResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -414,7 +487,7 @@ func (m *QueryAggregatePubkeyG1Request) Reset() { *m = QueryAggregatePub
func (m *QueryAggregatePubkeyG1Request) String() string { return proto.CompactTextString(m) }
func (*QueryAggregatePubkeyG1Request) ProtoMessage() {}
func (*QueryAggregatePubkeyG1Request) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{10}
return fileDescriptor_991a610b84b5964c, []int{12}
}
func (m *QueryAggregatePubkeyG1Request) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -453,7 +526,7 @@ func (m *QueryAggregatePubkeyG1Response) Reset() { *m = QueryAggregatePu
func (m *QueryAggregatePubkeyG1Response) String() string { return proto.CompactTextString(m) }
func (*QueryAggregatePubkeyG1Response) ProtoMessage() {}
func (*QueryAggregatePubkeyG1Response) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{11}
return fileDescriptor_991a610b84b5964c, []int{13}
}
func (m *QueryAggregatePubkeyG1Response) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -483,6 +556,8 @@ func (m *QueryAggregatePubkeyG1Response) XXX_DiscardUnknown() {
var xxx_messageInfo_QueryAggregatePubkeyG1Response proto.InternalMessageInfo
func init() {
proto.RegisterType((*QueryParamsRequest)(nil), "zgc.dasigners.v1.QueryParamsRequest")
proto.RegisterType((*QueryParamsResponse)(nil), "zgc.dasigners.v1.QueryParamsResponse")
proto.RegisterType((*QuerySignerRequest)(nil), "zgc.dasigners.v1.QuerySignerRequest")
proto.RegisterType((*QuerySignerResponse)(nil), "zgc.dasigners.v1.QuerySignerResponse")
proto.RegisterType((*QueryEpochNumberRequest)(nil), "zgc.dasigners.v1.QueryEpochNumberRequest")
@ -500,54 +575,57 @@ func init() {
func init() { proto.RegisterFile("zgc/dasigners/v1/query.proto", fileDescriptor_991a610b84b5964c) }
var fileDescriptor_991a610b84b5964c = []byte{
// 737 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0xcb, 0x4e, 0xdb, 0x4a,
0x18, 0xc7, 0x63, 0x2e, 0x11, 0x0c, 0x70, 0x04, 0x03, 0x3a, 0x24, 0x06, 0x4c, 0x30, 0x70, 0x14,
0x8e, 0x48, 0x9c, 0x50, 0x75, 0xd7, 0x2e, 0x4a, 0x55, 0x21, 0xa4, 0xb6, 0x2a, 0xee, 0xaa, 0xdd,
0x44, 0x63, 0x67, 0x3a, 0xb1, 0x8a, 0x3d, 0x8e, 0x3d, 0x26, 0x84, 0x65, 0xd5, 0x5d, 0x37, 0x95,
0xba, 0xe9, 0x03, 0xf4, 0x61, 0x58, 0x22, 0x75, 0xd3, 0x65, 0x0b, 0xdd, 0xf5, 0x25, 0x2a, 0xcf,
0x4c, 0x2e, 0xc6, 0x49, 0xc8, 0x82, 0x9d, 0xe7, 0xbb, 0xfe, 0xbe, 0xcf, 0xf3, 0xb7, 0xc1, 0xfa,
0x05, 0xb1, 0x8d, 0x3a, 0x0a, 0x1d, 0xe2, 0xe1, 0x20, 0x34, 0xce, 0xaa, 0x46, 0x33, 0xc2, 0x41,
0xbb, 0xec, 0x07, 0x94, 0x51, 0xb8, 0x78, 0x41, 0xec, 0x72, 0xd7, 0x5b, 0x3e, 0xab, 0xaa, 0x79,
0x9b, 0x86, 0x2e, 0x0d, 0x6b, 0xdc, 0x6f, 0x88, 0x83, 0x08, 0x56, 0x57, 0x08, 0x25, 0x54, 0xd8,
0xe3, 0x27, 0x69, 0x5d, 0x27, 0x94, 0x92, 0x53, 0x6c, 0x20, 0xdf, 0x31, 0x90, 0xe7, 0x51, 0x86,
0x98, 0x43, 0xbd, 0x4e, 0x4e, 0x5e, 0x7a, 0xf9, 0xc9, 0x8a, 0xde, 0x19, 0xc8, 0x93, 0xbd, 0xd5,
0xcd, 0xdb, 0x2e, 0xe6, 0xb8, 0x38, 0x64, 0xc8, 0xf5, 0x65, 0x40, 0x21, 0x85, 0xde, 0x23, 0xe5,
0x11, 0x7a, 0x05, 0xc0, 0x93, 0x78, 0x9a, 0xd7, 0xdc, 0x6a, 0xe2, 0x66, 0x84, 0x43, 0x06, 0x55,
0x30, 0x83, 0x6c, 0x9b, 0x46, 0x1e, 0x0b, 0x73, 0x4a, 0x61, 0xb2, 0x38, 0x6b, 0x76, 0xcf, 0xfa,
0x11, 0x58, 0x4e, 0x64, 0x84, 0x3e, 0xf5, 0x42, 0x0c, 0x2b, 0x20, 0x2b, 0x2a, 0xf3, 0x84, 0xb9,
0x83, 0x5c, 0xf9, 0xf6, 0x62, 0xca, 0x32, 0x43, 0xc6, 0xe9, 0x79, 0xb0, 0xca, 0x0b, 0x3d, 0xf3,
0xa9, 0xdd, 0x78, 0x19, 0xb9, 0x56, 0xb7, 0xbf, 0xfe, 0x18, 0xe4, 0xd2, 0x2e, 0xd9, 0x68, 0x0b,
0xcc, 0xe3, 0xd8, 0x5c, 0xf3, 0xb8, 0x3d, 0xa7, 0x14, 0x94, 0xe2, 0x94, 0x39, 0x87, 0x7b, 0xa1,
0xfa, 0x23, 0x59, 0xf9, 0x24, 0xa2, 0x41, 0xe4, 0x3e, 0x8d, 0xb9, 0x3b, 0x93, 0x8d, 0x91, 0xdd,
0x69, 0x9e, 0xc8, 0xee, 0x35, 0x6f, 0x72, 0x73, 0x8d, 0x6f, 0xa3, 0x93, 0xde, 0xec, 0x85, 0xea,
0x6f, 0xfa, 0xc7, 0x12, 0x35, 0xc6, 0x6f, 0x0e, 0xd7, 0xc0, 0xac, 0x6c, 0xe0, 0xd4, 0x73, 0x13,
0xdc, 0x3f, 0x23, 0x0c, 0xc7, 0x75, 0xfd, 0x79, 0xff, 0x5a, 0x3a, 0xa5, 0x7b, 0xfb, 0x17, 0x71,
0xbc, 0xea, 0xc0, 0xfd, 0xcb, 0x0c, 0x19, 0xa7, 0xb7, 0x81, 0x9a, 0xaa, 0x46, 0x5b, 0xf7, 0xc4,
0x1a, 0x3b, 0x03, 0xda, 0xaa, 0x39, 0x5e, 0x1d, 0x9f, 0xe7, 0x26, 0x0b, 0x4a, 0x71, 0xc1, 0x9c,
0x09, 0x68, 0xeb, 0x38, 0x3e, 0xeb, 0x0f, 0xc1, 0xda, 0xc0, 0xd6, 0x72, 0x96, 0x7f, 0xfb, 0xee,
0x92, 0x52, 0x9c, 0xed, 0xde, 0x98, 0x8f, 0x0a, 0xd8, 0xe0, 0x79, 0x4f, 0x08, 0x09, 0x30, 0x41,
0x0c, 0xbf, 0x8a, 0xac, 0xf7, 0xb8, 0x7d, 0x54, 0xbd, 0x2f, 0xea, 0x6d, 0xb0, 0x20, 0x9d, 0x96,
0xc3, 0x5c, 0xe4, 0x73, 0xf2, 0x79, 0x53, 0xbe, 0xf4, 0x43, 0x6e, 0xd3, 0xcf, 0x81, 0x36, 0x8c,
0x42, 0x0e, 0x50, 0x06, 0xcb, 0xa8, 0xe3, 0xac, 0xf9, 0xdc, 0x5b, 0x23, 0x55, 0x4e, 0x33, 0x6f,
0x2e, 0xa1, 0xdb, 0x79, 0x70, 0x05, 0x4c, 0x33, 0xca, 0xd0, 0xa9, 0xe4, 0x11, 0x07, 0xb8, 0x08,
0x26, 0x1b, 0x0e, 0xe3, 0x08, 0x53, 0x66, 0xfc, 0x78, 0xf0, 0x27, 0x0b, 0xa6, 0x79, 0x6b, 0xf8,
0x49, 0x01, 0x73, 0x7d, 0xea, 0x80, 0x7b, 0x83, 0x5e, 0xf7, 0x40, 0x71, 0xa9, 0xff, 0x8f, 0x13,
0x2a, 0x06, 0xd1, 0x77, 0x3f, 0x7c, 0xff, 0xfd, 0x65, 0x62, 0x13, 0x6e, 0x18, 0x15, 0x92, 0xfc,
0x90, 0xf0, 0x95, 0x96, 0xc4, 0x9a, 0x39, 0x4d, 0x9f, 0x5c, 0x86, 0xd2, 0xa4, 0x05, 0x39, 0x94,
0x66, 0x80, 0xfa, 0x46, 0xd0, 0x88, 0xf7, 0x53, 0xe2, 0xa2, 0xec, 0xed, 0x46, 0xd4, 0x18, 0xbd,
0x9b, 0x84, 0x42, 0x47, 0xef, 0x26, 0xa9, 0xb8, 0x3b, 0x77, 0x23, 0x98, 0xe0, 0x57, 0x05, 0xfc,
0x93, 0xbc, 0xe7, 0x70, 0x7f, 0x8c, 0x2e, 0x5d, 0x25, 0xaa, 0xa5, 0x31, 0xa3, 0x25, 0xd6, 0x1e,
0xc7, 0xda, 0x86, 0x5b, 0x23, 0xb1, 0x4a, 0x01, 0x6d, 0xc1, 0x6f, 0x0a, 0x58, 0x4a, 0x5d, 0x62,
0x68, 0x0c, 0xe9, 0x37, 0x4c, 0x74, 0x6a, 0x65, 0xfc, 0x04, 0xc9, 0xb8, 0xcf, 0x19, 0xff, 0x83,
0x3b, 0x29, 0xc6, 0xae, 0x36, 0x4a, 0x42, 0x36, 0x25, 0x52, 0x85, 0x67, 0x20, 0x2b, 0x7e, 0x1d,
0x70, 0x67, 0x48, 0xa7, 0xc4, 0xdf, 0x4b, 0xdd, 0xbd, 0x23, 0x4a, 0x42, 0x6c, 0x72, 0x88, 0x3c,
0x5c, 0x4d, 0x41, 0x88, 0xc7, 0xc3, 0x17, 0x97, 0xbf, 0xb4, 0xcc, 0xe5, 0xb5, 0xa6, 0x5c, 0x5d,
0x6b, 0xca, 0xcf, 0x6b, 0x4d, 0xf9, 0x7c, 0xa3, 0x65, 0xae, 0x6e, 0xb4, 0xcc, 0x8f, 0x1b, 0x2d,
0xf3, 0xd6, 0x20, 0x0e, 0x6b, 0x44, 0x56, 0xd9, 0xa6, 0xae, 0x51, 0x21, 0xa7, 0xc8, 0x0a, 0x8d,
0x0a, 0x29, 0xd9, 0x0d, 0xe4, 0x78, 0xc6, 0x79, 0xb2, 0x1e, 0x6b, 0xfb, 0x38, 0xb4, 0xb2, 0xfc,
0x8f, 0xfb, 0xe0, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x50, 0x33, 0x8a, 0x50, 0x08, 0x00,
0x00,
// 788 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4d, 0x4f, 0xdb, 0x4a,
0x14, 0x8d, 0xf9, 0x7a, 0x30, 0xc0, 0x13, 0x0c, 0xe8, 0x91, 0x18, 0x30, 0x60, 0xe0, 0x29, 0x3c,
0x91, 0x38, 0xe1, 0xa9, 0xbb, 0x76, 0x51, 0xaa, 0x0a, 0x21, 0xb5, 0x15, 0xa4, 0xab, 0x76, 0x13,
0x4d, 0x9c, 0xe9, 0xc4, 0x2a, 0xf6, 0x38, 0xf6, 0x98, 0x10, 0x96, 0x55, 0x77, 0xdd, 0x54, 0xea,
0xa6, 0x3f, 0xa0, 0x3f, 0x86, 0x25, 0x52, 0x37, 0x5d, 0xb6, 0xa4, 0x3f, 0xa4, 0xf2, 0xcc, 0x24,
0x8e, 0xe3, 0x38, 0x64, 0xc1, 0xce, 0x73, 0xef, 0xb9, 0xf7, 0x9c, 0xb9, 0xe3, 0x33, 0x36, 0xd8,
0xb8, 0x26, 0xa6, 0x51, 0x47, 0xbe, 0x45, 0x1c, 0xec, 0xf9, 0xc6, 0x65, 0xd9, 0x68, 0x06, 0xd8,
0x6b, 0x17, 0x5d, 0x8f, 0x32, 0x0a, 0x97, 0xae, 0x89, 0x59, 0xec, 0x65, 0x8b, 0x97, 0x65, 0x35,
0x67, 0x52, 0xdf, 0xa6, 0x7e, 0x95, 0xe7, 0x0d, 0xb1, 0x10, 0x60, 0x75, 0x95, 0x50, 0x42, 0x45,
0x3c, 0x7c, 0x92, 0xd1, 0x0d, 0x42, 0x29, 0xb9, 0xc0, 0x06, 0x72, 0x2d, 0x03, 0x39, 0x0e, 0x65,
0x88, 0x59, 0xd4, 0xe9, 0xd6, 0xe4, 0x64, 0x96, 0xaf, 0x6a, 0xc1, 0x3b, 0x03, 0x39, 0x92, 0x5b,
0xdd, 0x1a, 0x4c, 0x31, 0xcb, 0xc6, 0x3e, 0x43, 0xb6, 0x2b, 0x01, 0xdb, 0x09, 0xe9, 0x91, 0x52,
0x81, 0xd0, 0x12, 0x08, 0x82, 0x1d, 0xec, 0x5b, 0x32, 0xaf, 0xaf, 0x02, 0x78, 0x1e, 0xee, 0xf6,
0x0c, 0x79, 0xc8, 0xf6, 0x2b, 0xb8, 0x19, 0x60, 0x9f, 0xe9, 0x27, 0x60, 0x25, 0x16, 0xf5, 0x5d,
0xea, 0xf8, 0x18, 0x96, 0xc0, 0x8c, 0xcb, 0x23, 0x59, 0x65, 0x5b, 0xc9, 0xcf, 0x1f, 0x65, 0x8b,
0x83, 0xc3, 0x29, 0xca, 0x0a, 0x89, 0xd3, 0x4b, 0xb2, 0xfd, 0x6b, 0x8e, 0x90, 0xed, 0xa1, 0x0a,
0x66, 0x91, 0x69, 0xd2, 0xc0, 0x61, 0x61, 0xa7, 0xc9, 0xfc, 0x5c, 0xa5, 0xb7, 0xee, 0x51, 0x77,
0x2b, 0x22, 0x6a, 0xc1, 0xc2, 0x0b, 0x86, 0x52, 0xcb, 0x0a, 0x89, 0xd3, 0x73, 0x60, 0x8d, 0x37,
0x7a, 0xee, 0x52, 0xb3, 0xf1, 0x2a, 0xb0, 0x6b, 0x3d, 0x7e, 0xfd, 0x09, 0xc8, 0x26, 0x53, 0x92,
0x68, 0x07, 0x2c, 0xe0, 0x30, 0x5c, 0x75, 0x78, 0x9c, 0xef, 0x74, 0xaa, 0x32, 0x8f, 0x23, 0xa8,
0xfe, 0x58, 0x76, 0x3e, 0x0f, 0xa8, 0x17, 0xd8, 0xcf, 0x42, 0xdd, 0xdd, 0x9d, 0x8d, 0x51, 0xdd,
0x25, 0x8f, 0x55, 0x47, 0xe4, 0x4d, 0x1e, 0xae, 0xf2, 0x69, 0x74, 0xcb, 0x9b, 0x11, 0x54, 0x7f,
0xd3, 0xbf, 0x2d, 0xd1, 0x63, 0x7c, 0x72, 0xb8, 0x0e, 0xe6, 0x24, 0x81, 0x55, 0xcf, 0x4e, 0xf0,
0xfc, 0xac, 0x08, 0x9c, 0xd6, 0xf5, 0x17, 0xfd, 0x63, 0xe9, 0xb6, 0x8e, 0xe6, 0x2f, 0x70, 0xe9,
0x47, 0x2f, 0x2b, 0x24, 0x4e, 0x6f, 0x03, 0x35, 0xd1, 0x8d, 0xb6, 0x1e, 0x48, 0x6b, 0x98, 0xf4,
0x68, 0xab, 0x6a, 0x39, 0x75, 0x7c, 0x95, 0x9d, 0xdc, 0x56, 0xf2, 0x8b, 0x95, 0x59, 0x8f, 0xb6,
0x4e, 0xc3, 0xb5, 0xfe, 0x08, 0xac, 0x0f, 0xa5, 0x96, 0x7b, 0xf9, 0xa7, 0xef, 0x5d, 0x52, 0xf2,
0x73, 0xbd, 0x37, 0xe6, 0xa3, 0x02, 0x36, 0x79, 0xdd, 0x53, 0x42, 0x3c, 0x4c, 0x10, 0xc3, 0x67,
0x41, 0xed, 0x3d, 0x6e, 0x9f, 0x94, 0x1f, 0x4a, 0xf5, 0x2e, 0x58, 0x94, 0xc9, 0x9a, 0xc5, 0x6c,
0xe4, 0x72, 0xe5, 0x0b, 0x15, 0x79, 0xe8, 0xc7, 0x3c, 0xa6, 0x5f, 0x01, 0x2d, 0x4d, 0x85, 0xdc,
0x40, 0x11, 0xac, 0xa0, 0x6e, 0xb2, 0xea, 0xf2, 0x6c, 0x95, 0x94, 0xb9, 0x9a, 0x85, 0xca, 0x32,
0x1a, 0xac, 0x83, 0xab, 0x60, 0x9a, 0x51, 0x86, 0x2e, 0xa4, 0x1e, 0xb1, 0x80, 0x4b, 0x60, 0xb2,
0x61, 0x31, 0x2e, 0x61, 0xaa, 0x12, 0x3e, 0x1e, 0x75, 0xfe, 0x02, 0xd3, 0x9c, 0x1a, 0x5e, 0x82,
0x19, 0xe1, 0x64, 0xb8, 0x37, 0xec, 0xa0, 0x07, 0x2f, 0x0c, 0x75, 0xff, 0x1e, 0x94, 0x10, 0xae,
0x6f, 0x7d, 0xf8, 0xfe, 0xfb, 0xcb, 0x44, 0x0e, 0xae, 0x19, 0x25, 0x12, 0xbf, 0x95, 0xc4, 0x7d,
0x01, 0x3f, 0x29, 0x60, 0xbe, 0xcf, 0x95, 0xf0, 0x20, 0xa5, 0x6f, 0xd2, 0xd4, 0xea, 0x7f, 0xe3,
0x40, 0xa5, 0x8e, 0x7d, 0xae, 0x63, 0x0b, 0x6e, 0x26, 0x74, 0xf0, 0xa3, 0x2c, 0x88, 0xe3, 0xe5,
0x6a, 0xfa, 0x6c, 0x9a, 0xaa, 0x26, 0x79, 0x11, 0xa4, 0xaa, 0x19, 0xe2, 0xfa, 0x11, 0x6a, 0xc4,
0x7b, 0x51, 0xe0, 0x97, 0x41, 0x34, 0x1b, 0xd1, 0x63, 0xf4, 0x6c, 0x62, 0x37, 0xc3, 0xe8, 0xd9,
0xc4, 0x9d, 0x7e, 0xef, 0x6c, 0x84, 0x26, 0xf8, 0x55, 0x01, 0x7f, 0xc7, 0xfd, 0x05, 0x0f, 0xc7,
0x60, 0xe9, 0xdd, 0x00, 0x6a, 0x61, 0x4c, 0xb4, 0x94, 0x75, 0xc0, 0x65, 0xed, 0xc2, 0x9d, 0x91,
0xb2, 0x0a, 0x1e, 0x6d, 0xc1, 0x6f, 0x0a, 0x58, 0x4e, 0x98, 0x07, 0x1a, 0x29, 0x7c, 0x69, 0x66,
0x57, 0x4b, 0xe3, 0x17, 0x48, 0x8d, 0x87, 0x5c, 0xe3, 0xbf, 0x70, 0x2f, 0xa1, 0xb1, 0xe7, 0xc9,
0x82, 0xb0, 0x6b, 0x81, 0x94, 0x43, 0x8f, 0x89, 0x4f, 0x56, 0xaa, 0xc7, 0x62, 0x5f, 0xcd, 0x54,
0x8f, 0xc5, 0xbf, 0x94, 0x23, 0x3c, 0x26, 0x1e, 0x8f, 0x5f, 0xde, 0xfc, 0xd2, 0x32, 0x37, 0x77,
0x9a, 0x72, 0x7b, 0xa7, 0x29, 0x3f, 0xef, 0x34, 0xe5, 0x73, 0x47, 0xcb, 0xdc, 0x76, 0xb4, 0xcc,
0x8f, 0x8e, 0x96, 0x79, 0x6b, 0x10, 0x8b, 0x35, 0x82, 0x5a, 0xd1, 0xa4, 0xb6, 0x51, 0x22, 0x17,
0xa8, 0xe6, 0x1b, 0x25, 0x52, 0x30, 0x1b, 0xc8, 0x72, 0x8c, 0xab, 0x78, 0x3f, 0xd6, 0x76, 0xb1,
0x5f, 0x9b, 0xe1, 0x3f, 0x12, 0xff, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xfd, 0x6e, 0x10, 0xbe,
0x47, 0x09, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -562,6 +640,7 @@ const _ = grpc.SupportPackageIsVersion4
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
EpochNumber(ctx context.Context, in *QueryEpochNumberRequest, opts ...grpc.CallOption) (*QueryEpochNumberResponse, error)
QuorumCount(ctx context.Context, in *QueryQuorumCountRequest, opts ...grpc.CallOption) (*QueryQuorumCountResponse, error)
EpochQuorum(ctx context.Context, in *QueryEpochQuorumRequest, opts ...grpc.CallOption) (*QueryEpochQuorumResponse, error)
@ -578,6 +657,15 @@ func NewQueryClient(cc grpc1.ClientConn) QueryClient {
return &queryClient{cc}
}
func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
out := new(QueryParamsResponse)
err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Query/Params", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *queryClient) EpochNumber(ctx context.Context, in *QueryEpochNumberRequest, opts ...grpc.CallOption) (*QueryEpochNumberResponse, error) {
out := new(QueryEpochNumberResponse)
err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Query/EpochNumber", in, out, opts...)
@ -634,6 +722,7 @@ func (c *queryClient) Signer(ctx context.Context, in *QuerySignerRequest, opts .
// QueryServer is the server API for Query service.
type QueryServer interface {
Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
EpochNumber(context.Context, *QueryEpochNumberRequest) (*QueryEpochNumberResponse, error)
QuorumCount(context.Context, *QueryQuorumCountRequest) (*QueryQuorumCountResponse, error)
EpochQuorum(context.Context, *QueryEpochQuorumRequest) (*QueryEpochQuorumResponse, error)
@ -646,6 +735,9 @@ type QueryServer interface {
type UnimplementedQueryServer struct {
}
func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) EpochNumber(ctx context.Context, req *QueryEpochNumberRequest) (*QueryEpochNumberResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method EpochNumber not implemented")
}
@ -669,6 +761,24 @@ func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
s.RegisterService(&_Query_serviceDesc, srv)
}
func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryParamsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryServer).Params(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/zgc.dasigners.v1.Query/Params",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Query_EpochNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryEpochNumberRequest)
if err := dec(in); err != nil {
@ -781,6 +891,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
ServiceName: "zgc.dasigners.v1.Query",
HandlerType: (*QueryServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Params",
Handler: _Query_Params_Handler,
},
{
MethodName: "EpochNumber",
Handler: _Query_EpochNumber_Handler,
@ -810,6 +924,64 @@ var _Query_serviceDesc = grpc.ServiceDesc{
Metadata: "zgc/dasigners/v1/query.proto",
}
func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
return len(dAtA) - i, nil
}
func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Params != nil {
{
size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *QuerySignerRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -1213,6 +1385,28 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func (m *QueryParamsRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
return n
}
func (m *QueryParamsResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Params != nil {
l = m.Params.Size()
n += 1 + l + sovQuery(uint64(l))
}
return n
}
func (m *QuerySignerRequest) Size() (n int) {
if m == nil {
return 0
@ -1391,6 +1585,142 @@ func sovQuery(x uint64) (n int) {
func sozQuery(x uint64) (n int) {
return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Params == nil {
m.Params = &Params{}
}
if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *QuerySignerRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0

65
x/dasigners/v1/types/query.pb.gw.go
View File

@ -33,6 +33,24 @@ var _ = utilities.NewDoubleArray
var _ = descriptor.ForMessage
var _ = metadata.Join
func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryParamsRequest
var metadata runtime.ServerMetadata
msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryParamsRequest
var metadata runtime.ServerMetadata
msg, err := server.Params(ctx, &protoReq)
return msg, metadata, err
}
func request_Query_EpochNumber_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryEpochNumberRequest
var metadata runtime.ServerMetadata
@ -237,6 +255,29 @@ func local_request_Query_Signer_0(ctx context.Context, marshaler runtime.Marshal
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.
func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error {
mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_EpochNumber_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@ -416,6 +457,26 @@ func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
// "QueryClient" to call the correct interceptors.
func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error {
mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_EpochNumber_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@ -540,6 +601,8 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
}
var (
pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "params"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_EpochNumber_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "epoch-number"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_QuorumCount_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "quorum-count"}, "", runtime.AssumeColonVerbOpt(true)))
@ -554,6 +617,8 @@ var (
)
var (
forward_Query_Params_0 = runtime.ForwardResponseMessage
forward_Query_EpochNumber_0 = runtime.ForwardResponseMessage
forward_Query_QuorumCount_0 = runtime.ForwardResponseMessage

440
x/dasigners/v1/types/tx.pb.go
View File

@ -30,6 +30,80 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type MsgChangeParams struct {
Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
}
func (m *MsgChangeParams) Reset() { *m = MsgChangeParams{} }
func (m *MsgChangeParams) String() string { return proto.CompactTextString(m) }
func (*MsgChangeParams) ProtoMessage() {}
func (*MsgChangeParams) Descriptor() ([]byte, []int) {
return fileDescriptor_8bfa0cc0bd2f98e0, []int{0}
}
func (m *MsgChangeParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgChangeParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgChangeParams.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *MsgChangeParams) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgChangeParams.Merge(m, src)
}
func (m *MsgChangeParams) XXX_Size() int {
return m.Size()
}
func (m *MsgChangeParams) XXX_DiscardUnknown() {
xxx_messageInfo_MsgChangeParams.DiscardUnknown(m)
}
var xxx_messageInfo_MsgChangeParams proto.InternalMessageInfo
type MsgChangeParamsResponse struct {
}
func (m *MsgChangeParamsResponse) Reset() { *m = MsgChangeParamsResponse{} }
func (m *MsgChangeParamsResponse) String() string { return proto.CompactTextString(m) }
func (*MsgChangeParamsResponse) ProtoMessage() {}
func (*MsgChangeParamsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_8bfa0cc0bd2f98e0, []int{1}
}
func (m *MsgChangeParamsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgChangeParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgChangeParamsResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *MsgChangeParamsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgChangeParamsResponse.Merge(m, src)
}
func (m *MsgChangeParamsResponse) XXX_Size() int {
return m.Size()
}
func (m *MsgChangeParamsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_MsgChangeParamsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_MsgChangeParamsResponse proto.InternalMessageInfo
type MsgRegisterSigner struct {
Signer *Signer `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
@ -39,7 +113,7 @@ func (m *MsgRegisterSigner) Reset() { *m = MsgRegisterSigner{} }
func (m *MsgRegisterSigner) String() string { return proto.CompactTextString(m) }
func (*MsgRegisterSigner) ProtoMessage() {}
func (*MsgRegisterSigner) Descriptor() ([]byte, []int) {
return fileDescriptor_8bfa0cc0bd2f98e0, []int{0}
return fileDescriptor_8bfa0cc0bd2f98e0, []int{2}
}
func (m *MsgRegisterSigner) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -75,7 +149,7 @@ func (m *MsgRegisterSignerResponse) Reset() { *m = MsgRegisterSignerResp
func (m *MsgRegisterSignerResponse) String() string { return proto.CompactTextString(m) }
func (*MsgRegisterSignerResponse) ProtoMessage() {}
func (*MsgRegisterSignerResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_8bfa0cc0bd2f98e0, []int{1}
return fileDescriptor_8bfa0cc0bd2f98e0, []int{3}
}
func (m *MsgRegisterSignerResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -113,7 +187,7 @@ func (m *MsgUpdateSocket) Reset() { *m = MsgUpdateSocket{} }
func (m *MsgUpdateSocket) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateSocket) ProtoMessage() {}
func (*MsgUpdateSocket) Descriptor() ([]byte, []int) {
return fileDescriptor_8bfa0cc0bd2f98e0, []int{2}
return fileDescriptor_8bfa0cc0bd2f98e0, []int{4}
}
func (m *MsgUpdateSocket) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -149,7 +223,7 @@ func (m *MsgUpdateSocketResponse) Reset() { *m = MsgUpdateSocketResponse
func (m *MsgUpdateSocketResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateSocketResponse) ProtoMessage() {}
func (*MsgUpdateSocketResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_8bfa0cc0bd2f98e0, []int{3}
return fileDescriptor_8bfa0cc0bd2f98e0, []int{5}
}
func (m *MsgUpdateSocketResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -187,7 +261,7 @@ func (m *MsgRegisterNextEpoch) Reset() { *m = MsgRegisterNextEpoch{} }
func (m *MsgRegisterNextEpoch) String() string { return proto.CompactTextString(m) }
func (*MsgRegisterNextEpoch) ProtoMessage() {}
func (*MsgRegisterNextEpoch) Descriptor() ([]byte, []int) {
return fileDescriptor_8bfa0cc0bd2f98e0, []int{4}
return fileDescriptor_8bfa0cc0bd2f98e0, []int{6}
}
func (m *MsgRegisterNextEpoch) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -223,7 +297,7 @@ func (m *MsgRegisterNextEpochResponse) Reset() { *m = MsgRegisterNextEpo
func (m *MsgRegisterNextEpochResponse) String() string { return proto.CompactTextString(m) }
func (*MsgRegisterNextEpochResponse) ProtoMessage() {}
func (*MsgRegisterNextEpochResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_8bfa0cc0bd2f98e0, []int{5}
return fileDescriptor_8bfa0cc0bd2f98e0, []int{7}
}
func (m *MsgRegisterNextEpochResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -253,6 +327,8 @@ func (m *MsgRegisterNextEpochResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_MsgRegisterNextEpochResponse proto.InternalMessageInfo
func init() {
proto.RegisterType((*MsgChangeParams)(nil), "zgc.dasigners.v1.MsgChangeParams")
proto.RegisterType((*MsgChangeParamsResponse)(nil), "zgc.dasigners.v1.MsgChangeParamsResponse")
proto.RegisterType((*MsgRegisterSigner)(nil), "zgc.dasigners.v1.MsgRegisterSigner")
proto.RegisterType((*MsgRegisterSignerResponse)(nil), "zgc.dasigners.v1.MsgRegisterSignerResponse")
proto.RegisterType((*MsgUpdateSocket)(nil), "zgc.dasigners.v1.MsgUpdateSocket")
@ -264,32 +340,37 @@ func init() {
func init() { proto.RegisterFile("zgc/dasigners/v1/tx.proto", fileDescriptor_8bfa0cc0bd2f98e0) }
var fileDescriptor_8bfa0cc0bd2f98e0 = []byte{
// 399 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0xae, 0xd2, 0x40,
0x14, 0x87, 0x5b, 0x4c, 0x30, 0x8c, 0x44, 0xa5, 0x21, 0xda, 0x56, 0x32, 0xc1, 0x9a, 0x18, 0x8c,
0xb1, 0x03, 0xf8, 0x06, 0x1a, 0x97, 0x65, 0x51, 0xe2, 0xc6, 0x98, 0x98, 0x76, 0x18, 0x87, 0x06,
0xe8, 0x34, 0x9d, 0x29, 0x01, 0x9e, 0xc2, 0x87, 0xf1, 0x21, 0x58, 0xb2, 0x74, 0xe9, 0x85, 0x17,
0xb9, 0x61, 0xfa, 0x07, 0x6e, 0x4b, 0xb8, 0xec, 0xe6, 0xcc, 0xf9, 0x7a, 0xbe, 0xd3, 0x5f, 0x5a,
0x60, 0x6c, 0x28, 0x46, 0x13, 0x8f, 0x07, 0x34, 0x24, 0x31, 0x47, 0xcb, 0x01, 0x12, 0x2b, 0x3b,
0x8a, 0x99, 0x60, 0xda, 0xcb, 0x0d, 0xc5, 0x76, 0xd1, 0xb2, 0x97, 0x03, 0xd3, 0xc0, 0x8c, 0x2f,
0x18, 0xff, 0x25, 0xfb, 0x28, 0x2d, 0x52, 0xd8, 0x6c, 0x53, 0x46, 0x59, 0x7a, 0x7f, 0x3c, 0x65,
0xb7, 0x06, 0x65, 0x8c, 0xce, 0x09, 0x92, 0x95, 0x9f, 0xfc, 0x46, 0x5e, 0xb8, 0xce, 0x5a, 0xdd,
0x8a, 0xf8, 0xa4, 0x92, 0x84, 0x85, 0x41, 0xcb, 0xe1, 0xd4, 0x25, 0x34, 0xe0, 0x82, 0xc4, 0x63,
0xd9, 0xd3, 0xfa, 0xa0, 0x9e, 0x52, 0xba, 0xda, 0x55, 0x7b, 0xcf, 0x86, 0xba, 0x5d, 0xde, 0xd2,
0x4e, 0x49, 0x37, 0xe3, 0xb4, 0x0e, 0x68, 0x1c, 0x4f, 0x9e, 0x48, 0x62, 0xa2, 0xd7, 0xba, 0x6a,
0xaf, 0xe9, 0x9e, 0x2e, 0xac, 0x37, 0xc0, 0xa8, 0x48, 0x5c, 0xc2, 0x23, 0x16, 0x72, 0x62, 0x7d,
0x05, 0x2f, 0x1c, 0x4e, 0xbf, 0x47, 0x13, 0x4f, 0x90, 0x31, 0xc3, 0x33, 0x22, 0x34, 0x1d, 0x3c,
0xf5, 0x30, 0x66, 0x49, 0x28, 0xe4, 0x02, 0x0d, 0x37, 0x2f, 0xb5, 0x57, 0xa0, 0xce, 0x25, 0x23,
0x25, 0x0d, 0x37, 0xab, 0x2c, 0x03, 0xbc, 0x2e, 0x0d, 0x29, 0xe6, 0x8f, 0x40, 0xfb, 0x4c, 0x3e,
0x22, 0x2b, 0xf1, 0x2d, 0x62, 0x78, 0x7a, 0x45, 0x72, 0xfd, 0x65, 0x20, 0xe8, 0x5c, 0x9a, 0x97,
0xfb, 0x86, 0x7f, 0x6b, 0xe0, 0x89, 0xc3, 0xa9, 0xe6, 0x83, 0xe7, 0xa5, 0x58, 0xdf, 0x55, 0x63,
0xac, 0xc4, 0x62, 0x7e, 0xbc, 0x01, 0xca, 0x5d, 0xda, 0x4f, 0xd0, 0x7c, 0x10, 0xdc, 0xdb, 0x8b,
0x0f, 0x9f, 0x23, 0xe6, 0x87, 0x47, 0x91, 0x62, 0xfa, 0x0c, 0xb4, 0xaa, 0xb1, 0xbd, 0xbf, 0xba,
0x5f, 0xc1, 0x99, 0xf6, 0x6d, 0x5c, 0x2e, 0xfb, 0xe2, 0x6c, 0xef, 0xa0, 0xb2, 0xdd, 0x43, 0x75,
0xb7, 0x87, 0xea, 0xff, 0x3d, 0x54, 0xff, 0x1c, 0xa0, 0xb2, 0x3b, 0x40, 0xe5, 0xdf, 0x01, 0x2a,
0x3f, 0x10, 0x0d, 0xc4, 0x34, 0xf1, 0x6d, 0xcc, 0x16, 0xa8, 0x4f, 0xe7, 0x9e, 0xcf, 0x51, 0x9f,
0x7e, 0xc2, 0x53, 0x2f, 0x08, 0xd1, 0xaa, 0xf4, 0x6b, 0xad, 0x23, 0xc2, 0xfd, 0xba, 0xfc, 0xbc,
0x3f, 0xdf, 0x07, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x5a, 0xce, 0x9a, 0x7b, 0x03, 0x00, 0x00,
// 466 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xc1, 0x6e, 0xd3, 0x40,
0x10, 0x40, 0x63, 0x2a, 0x05, 0x65, 0x88, 0x80, 0x5a, 0x15, 0xc4, 0xa6, 0x5a, 0x85, 0x20, 0xa1,
0x22, 0x84, 0x37, 0x2d, 0x7f, 0x40, 0xc5, 0x31, 0x15, 0x72, 0xc5, 0x05, 0x55, 0x42, 0xeb, 0xed,
0x32, 0xb6, 0xda, 0x78, 0x2d, 0xef, 0xba, 0x4a, 0xfa, 0x15, 0x88, 0xaf, 0xea, 0xb1, 0x47, 0x8e,
0x90, 0xfc, 0x08, 0xca, 0xda, 0x71, 0x12, 0xdb, 0xa4, 0xb9, 0xed, 0xcc, 0xbc, 0xcc, 0x9b, 0xc9,
0x28, 0x01, 0xe7, 0x16, 0x39, 0xbd, 0x64, 0x2a, 0xc2, 0x58, 0xa4, 0x8a, 0xde, 0x1c, 0x53, 0x3d,
0xf1, 0x92, 0x54, 0x6a, 0x69, 0x3f, 0xbf, 0x45, 0xee, 0x95, 0x25, 0xef, 0xe6, 0xd8, 0x75, 0xb8,
0x54, 0x63, 0xa9, 0xbe, 0x9b, 0x3a, 0xcd, 0x83, 0x1c, 0x76, 0x0f, 0x50, 0xa2, 0xcc, 0xf3, 0x8b,
0x57, 0x91, 0x75, 0x50, 0x4a, 0xbc, 0x16, 0xd4, 0x44, 0x41, 0xf6, 0x83, 0xb2, 0x78, 0x5a, 0x94,
0xfa, 0x35, 0xf1, 0x4a, 0x95, 0x13, 0xa4, 0x46, 0xa0, 0x88, 0x85, 0x8a, 0x8a, 0xfa, 0x80, 0xc1,
0xb3, 0x91, 0xc2, 0xd3, 0x90, 0xc5, 0x28, 0xbe, 0xb0, 0x94, 0x8d, 0x95, 0x7d, 0x08, 0x1d, 0x96,
0xe9, 0x50, 0xa6, 0x91, 0x9e, 0xf6, 0xac, 0xbe, 0x75, 0xd4, 0xf1, 0x57, 0x09, 0x7b, 0x08, 0xed,
0xc4, 0x70, 0xbd, 0x47, 0x7d, 0xeb, 0xe8, 0xc9, 0x49, 0xcf, 0xab, 0x6e, 0xe8, 0xe5, 0x7d, 0xfc,
0x82, 0x1b, 0x38, 0xf0, 0xb2, 0xa2, 0xf0, 0x85, 0x4a, 0x64, 0xac, 0xc4, 0x80, 0xc3, 0xfe, 0x48,
0xa1, 0x2f, 0x30, 0x52, 0x5a, 0xa4, 0xe7, 0xa6, 0xc5, 0xc2, 0x90, 0x37, 0x33, 0xf2, 0x46, 0x43,
0x4e, 0xfa, 0x05, 0xb7, 0x98, 0x78, 0xf1, 0x62, 0x3a, 0x4b, 0x85, 0x19, 0xab, 0xeb, 0xaf, 0x12,
0x83, 0x57, 0xe0, 0xd4, 0x24, 0xe5, 0x04, 0xa7, 0x66, 0xff, 0xaf, 0xc9, 0x25, 0xd3, 0xe2, 0x5c,
0xf2, 0x2b, 0xa1, 0xed, 0x1e, 0x3c, 0x66, 0x9c, 0xcb, 0x2c, 0xd6, 0xc5, 0xf6, 0xcb, 0xd0, 0x7e,
0x01, 0x6d, 0x65, 0x18, 0x23, 0xe9, 0xf8, 0x45, 0x54, 0x6c, 0xb8, 0xde, 0xa4, 0xec, 0x7f, 0x06,
0x07, 0x6b, 0xf2, 0x33, 0x31, 0xd1, 0x9f, 0x13, 0xc9, 0xc3, 0x2d, 0x92, 0xed, 0xcb, 0x10, 0x38,
0x6c, 0xea, 0xb7, 0xf4, 0x9d, 0xfc, 0xda, 0x83, 0xbd, 0x91, 0x42, 0xfb, 0x02, 0xba, 0x1b, 0x47,
0x7d, 0x5d, 0xff, 0x12, 0x2b, 0x47, 0x71, 0xdf, 0x3d, 0x88, 0x2c, 0x2d, 0x76, 0x00, 0x4f, 0x2b,
0x47, 0x7b, 0xd3, 0xf8, 0xe1, 0x4d, 0xc8, 0x7d, 0xbf, 0x03, 0x54, 0x3a, 0x2e, 0xa0, 0xbb, 0x71,
0x96, 0xe6, 0x0d, 0xd6, 0x91, 0xff, 0x6c, 0xd0, 0x74, 0x17, 0xfb, 0x0a, 0xf6, 0xeb, 0x47, 0x79,
0xbb, 0x75, 0xbe, 0x92, 0x73, 0xbd, 0xdd, 0xb8, 0xa5, 0xec, 0xd3, 0xe8, 0xee, 0x2f, 0x69, 0xdd,
0xcd, 0x88, 0x75, 0x3f, 0x23, 0xd6, 0x9f, 0x19, 0xb1, 0x7e, 0xce, 0x49, 0xeb, 0x7e, 0x4e, 0x5a,
0xbf, 0xe7, 0xa4, 0xf5, 0x8d, 0x62, 0xa4, 0xc3, 0x2c, 0xf0, 0xb8, 0x1c, 0xd3, 0x21, 0x5e, 0xb3,
0x40, 0xd1, 0x21, 0x7e, 0xe0, 0x21, 0x8b, 0x62, 0x3a, 0xa9, 0xfc, 0xad, 0x4c, 0x13, 0xa1, 0x82,
0xb6, 0xf9, 0xe9, 0x7e, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x94, 0x58, 0x6f, 0x77, 0x04,
0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -304,6 +385,7 @@ const _ = grpc.SupportPackageIsVersion4
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
ChangeParams(ctx context.Context, in *MsgChangeParams, opts ...grpc.CallOption) (*MsgChangeParamsResponse, error)
RegisterSigner(ctx context.Context, in *MsgRegisterSigner, opts ...grpc.CallOption) (*MsgRegisterSignerResponse, error)
UpdateSocket(ctx context.Context, in *MsgUpdateSocket, opts ...grpc.CallOption) (*MsgUpdateSocketResponse, error)
RegisterNextEpoch(ctx context.Context, in *MsgRegisterNextEpoch, opts ...grpc.CallOption) (*MsgRegisterNextEpochResponse, error)
@ -317,6 +399,15 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient {
return &msgClient{cc}
}
func (c *msgClient) ChangeParams(ctx context.Context, in *MsgChangeParams, opts ...grpc.CallOption) (*MsgChangeParamsResponse, error) {
out := new(MsgChangeParamsResponse)
err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Msg/ChangeParams", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *msgClient) RegisterSigner(ctx context.Context, in *MsgRegisterSigner, opts ...grpc.CallOption) (*MsgRegisterSignerResponse, error) {
out := new(MsgRegisterSignerResponse)
err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Msg/RegisterSigner", in, out, opts...)
@ -346,6 +437,7 @@ func (c *msgClient) RegisterNextEpoch(ctx context.Context, in *MsgRegisterNextEp
// MsgServer is the server API for Msg service.
type MsgServer interface {
ChangeParams(context.Context, *MsgChangeParams) (*MsgChangeParamsResponse, error)
RegisterSigner(context.Context, *MsgRegisterSigner) (*MsgRegisterSignerResponse, error)
UpdateSocket(context.Context, *MsgUpdateSocket) (*MsgUpdateSocketResponse, error)
RegisterNextEpoch(context.Context, *MsgRegisterNextEpoch) (*MsgRegisterNextEpochResponse, error)
@ -355,6 +447,9 @@ type MsgServer interface {
type UnimplementedMsgServer struct {
}
func (*UnimplementedMsgServer) ChangeParams(ctx context.Context, req *MsgChangeParams) (*MsgChangeParamsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ChangeParams not implemented")
}
func (*UnimplementedMsgServer) RegisterSigner(ctx context.Context, req *MsgRegisterSigner) (*MsgRegisterSignerResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method RegisterSigner not implemented")
}
@ -369,6 +464,24 @@ func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
s.RegisterService(&_Msg_serviceDesc, srv)
}
func _Msg_ChangeParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgChangeParams)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MsgServer).ChangeParams(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/zgc.dasigners.v1.Msg/ChangeParams",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MsgServer).ChangeParams(ctx, req.(*MsgChangeParams))
}
return interceptor(ctx, in, info, handler)
}
func _Msg_RegisterSigner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgRegisterSigner)
if err := dec(in); err != nil {
@ -427,6 +540,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
ServiceName: "zgc.dasigners.v1.Msg",
HandlerType: (*MsgServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ChangeParams",
Handler: _Msg_ChangeParams_Handler,
},
{
MethodName: "RegisterSigner",
Handler: _Msg_RegisterSigner_Handler,
@ -444,6 +561,71 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
Metadata: "zgc/dasigners/v1/tx.proto",
}
func (m *MsgChangeParams) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *MsgChangeParams) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgChangeParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Params != nil {
{
size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTx(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
if len(m.Authority) > 0 {
i -= len(m.Authority)
copy(dAtA[i:], m.Authority)
i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *MsgChangeParamsResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *MsgChangeParamsResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgChangeParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
return len(dAtA) - i, nil
}
func (m *MsgRegisterSigner) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -640,6 +822,32 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func (m *MsgChangeParams) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Authority)
if l > 0 {
n += 1 + l + sovTx(uint64(l))
}
if m.Params != nil {
l = m.Params.Size()
n += 1 + l + sovTx(uint64(l))
}
return n
}
func (m *MsgChangeParamsResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
return n
}
func (m *MsgRegisterSigner) Size() (n int) {
if m == nil {
return 0
@ -724,6 +932,174 @@ func sovTx(x uint64) (n int) {
func sozTx(x uint64) (n int) {
return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgChangeParams) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MsgChangeParams: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgChangeParams: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTx
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthTx
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Authority = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTx
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTx
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Params == nil {
m.Params = &Params{}
}
if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTx(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTx
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *MsgChangeParamsResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MsgChangeParamsResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgChangeParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
default:
iNdEx = preIndex
skippy, err := skipTx(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTx
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *MsgRegisterSigner) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0