smeb_y/0g-chain
1
0
Fork 0
mirror of https://github.com/0glabs/0g-chain.git synced 2024-12-25 15:55:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: quorum

Browse Source
This commit is contained in:
MiniFrenchBread 2024-05-16 22:49:29 +08:00 committed by 0g-wh
parent 9839a244bf
commit e4989f10cd
19 changed files with 1300 additions and 526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
precompiles/dasigners/IDASigners.abi
View File

@ -84,12 +84,17 @@
"inputs": [ "inputs": [
{ {
"internalType": "uint256", "internalType": "uint256",
"name": "epoch", "name": "_epoch",
"type": "uint256"
},
{
"internalType": "uint256",
"name": "_quorumId",
"type": "uint256" "type": "uint256"
}, },
{ {
"internalType": "bytes", "internalType": "bytes",
"name": "signersBitmap", "name": "_quorumBitmap",
"type": "bytes" "type": "bytes"
} }
], ],
@ -129,9 +134,33 @@
{ {
"inputs": [ "inputs": [
{ {
"internalType": "address", "internalType": "uint256",
"name": "account", "name": "_epoch",
"type": "address" "type": "uint256"
},
{
"internalType": "uint256",
"name": "_quorumId",
"type": "uint256"
}
],
"name": "getQuorum",
"outputs": [
{
"internalType": "address[]",
"name": "",
"type": "address[]"
}
],
"stateMutability": "view",
"type": "function"
},
{
"inputs": [
{
"internalType": "address[]",
"name": "_account",
"type": "address[]"
} }
], ],
"name": "getSigner", "name": "getSigner",
@ -183,9 +212,9 @@
"type": "tuple" "type": "tuple"
} }
], ],
"internalType": "struct IDASigners.SignerDetail", "internalType": "struct IDASigners.SignerDetail[]",
"name": "", "name": "",
"type": "tuple" "type": "tuple[]"
} }
], ],
"stateMutability": "view", "stateMutability": "view",
@ -195,62 +224,16 @@
"inputs": [ "inputs": [
{ {
"internalType": "uint256", "internalType": "uint256",
"name": "epoch", "name": "_epoch",
"type": "uint256" "type": "uint256"
} }
], ],
"name": "getSigners", "name": "quorumCount",
"outputs": [ "outputs": [
{
"components": [
{
"internalType": "address",
"name": "signer",
"type": "address"
},
{
"internalType": "string",
"name": "socket",
"type": "string"
},
{
"components": [
{ {
"internalType": "uint256", "internalType": "uint256",
"name": "X", "name": "",
"type": "uint256" "type": "uint256"
},
{
"internalType": "uint256",
"name": "Y",
"type": "uint256"
}
],
"internalType": "struct BN254.G1Point",
"name": "pkG1",
"type": "tuple"
},
{
"components": [
{
"internalType": "uint256[2]",
"name": "X",
"type": "uint256[2]"
},
{
"internalType": "uint256[2]",
"name": "Y",
"type": "uint256[2]"
}
],
"internalType": "struct BN254.G2Point",
"name": "pkG2",
"type": "tuple"
}
],
"internalType": "struct IDASigners.SignerDetail[]",
"name": "details",
"type": "tuple[]"
} }
], ],
"stateMutability": "view", "stateMutability": "view",
@ -361,7 +344,7 @@
"inputs": [ "inputs": [
{ {
"internalType": "string", "internalType": "string",
"name": "socket", "name": "_socket",
"type": "string" "type": "string"
} }
], ],

127
precompiles/dasigners/contract.go
View File

File diff suppressed because one or more lines are too long

11
precompiles/dasigners/dasigners.go
View File

@ -19,11 +19,12 @@ const (
RequiredGasMax uint64 = 1000_000_000 RequiredGasMax uint64 = 1000_000_000
DASignersFunctionEpochNumber = "epochNumber" DASignersFunctionEpochNumber = "epochNumber"
DASignersFunctionQuorumCount = "quorumCount"
DASignersFunctionGetSigner = "getSigner" DASignersFunctionGetSigner = "getSigner"
DASignersFunctionGetSigners = "getSigners" DASignersFunctionGetQuorum = "getQuorum"
DASignersFunctionRegisterSigner = "registerSigner"
DASignersFunctionUpdateSocket = "updateSocket" DASignersFunctionUpdateSocket = "updateSocket"
DASignersFunctionRegisterNextEpoch = "registerNextEpoch" DASignersFunctionRegisterNextEpoch = "registerNextEpoch"
DASignersFunctionRegisterSigner = "registerSigner"
DASignersFunctionGetAggPkG1 = "getAggPkG1" DASignersFunctionGetAggPkG1 = "getAggPkG1"
) )
@ -111,10 +112,12 @@ func (d *DASignersPrecompile) Run(evm *vm.EVM, contract *vm.Contract, readonly b
// queries // queries
case DASignersFunctionEpochNumber: case DASignersFunctionEpochNumber:
bz, err = d.EpochNumber(ctx, evm, method, args) bz, err = d.EpochNumber(ctx, evm, method, args)
case DASignersFunctionQuorumCount:
bz, err = d.QuorumCount(ctx, evm, method, args)
case DASignersFunctionGetSigner: case DASignersFunctionGetSigner:
bz, err = d.GetSigner(ctx, evm, method, args) bz, err = d.GetSigner(ctx, evm, method, args)
case DASignersFunctionGetSigners: case DASignersFunctionGetQuorum:
bz, err = d.GetSigners(ctx, evm, method, args) bz, err = d.GetQuorum(ctx, evm, method, args)
case DASignersFunctionGetAggPkG1: case DASignersFunctionGetAggPkG1:
bz, err = d.GetAggPkG1(ctx, evm, method, args) bz, err = d.GetAggPkG1(ctx, evm, method, args)
// txs // txs

28
precompiles/dasigners/query.go
View File

@ -5,6 +5,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm"
) )
@ -16,6 +17,15 @@ func (d *DASignersPrecompile) EpochNumber(ctx sdk.Context, _ *vm.EVM, method *ab
return method.Outputs.Pack(big.NewInt(int64(epochNumber))) return method.Outputs.Pack(big.NewInt(int64(epochNumber)))
} }
func (d *DASignersPrecompile) QuorumCount(ctx sdk.Context, _ *vm.EVM, method *abi.Method, args []interface{}) ([]byte, error) {
req, err := NewQueryQuorumCountRequest(args)
response, err := d.dasignersKeeper.QuorumCount(ctx, req)
if err != nil {
return nil, err
}
return method.Outputs.Pack(big.NewInt(int64(response.QuorumCount)))
}
func (d *DASignersPrecompile) GetSigner(ctx sdk.Context, _ *vm.EVM, method *abi.Method, args []interface{}) ([]byte, error) { func (d *DASignersPrecompile) GetSigner(ctx sdk.Context, _ *vm.EVM, method *abi.Method, args []interface{}) ([]byte, error) {
req, err := NewQuerySignerRequest(args) req, err := NewQuerySignerRequest(args)
if err != nil { if err != nil {
@ -25,21 +35,25 @@ func (d *DASignersPrecompile) GetSigner(ctx sdk.Context, _ *vm.EVM, method *abi.
if err != nil { if err != nil {
return nil, err return nil, err
} }
return method.Outputs.Pack(NewIDASignersSignerDetail(response.Signer)) signers := make([]IDASignersSignerDetail, len(response.Signer))
for i, signer := range response.Signer {
signers[i] = NewIDASignersSignerDetail(signer)
}
return method.Outputs.Pack(signers)
} }
func (d *DASignersPrecompile) GetSigners(ctx sdk.Context, _ *vm.EVM, method *abi.Method, args []interface{}) ([]byte, error) { func (d *DASignersPrecompile) GetQuorum(ctx sdk.Context, _ *vm.EVM, method *abi.Method, args []interface{}) ([]byte, error) {
req, err := NewQueryEpochSignerSetRequest(args) req, err := NewQueryEpochQuorumRequest(args)
if err != nil { if err != nil {
return nil, err return nil, err
} }
response, err := d.dasignersKeeper.EpochSignerSet(sdk.WrapSDKContext(ctx), req) response, err := d.dasignersKeeper.EpochQuorum(sdk.WrapSDKContext(ctx), req)
if err != nil { if err != nil {
return nil, err return nil, err
} }
signers := make([]IDASignersSignerDetail, 0) signers := make([]common.Address, len(response.Quorum.Signers))
for _, signer := range response.Signers { for i, signer := range response.Quorum.Signers {
signers = append(signers, NewIDASignersSignerDetail(signer)) signers[i] = common.HexToAddress(signer)
} }
return method.Outputs.Pack(signers) return method.Outputs.Pack(signers)
} }

48
precompiles/dasigners/types.go
View File

@ -63,34 +63,50 @@ func SerializeG2(p BN254G2Point) []byte {
return b return b
} }
func NewQueryQuorumCountRequest(args []interface{}) (*dasignerstypes.QueryQuorumCountRequest, error) {
if len(args) != 1 {
return nil, fmt.Errorf(precopmiles_common.ErrInvalidNumberOfArgs, 1, len(args))
}
return &dasignerstypes.QueryQuorumCountRequest{
EpochNumber: args[0].(*big.Int).Uint64(),
}, nil
}
func NewQuerySignerRequest(args []interface{}) (*dasignerstypes.QuerySignerRequest, error) { func NewQuerySignerRequest(args []interface{}) (*dasignerstypes.QuerySignerRequest, error) {
if len(args) != 1 { if len(args) != 1 {
return nil, fmt.Errorf(precopmiles_common.ErrInvalidNumberOfArgs, 1, len(args)) return nil, fmt.Errorf(precopmiles_common.ErrInvalidNumberOfArgs, 1, len(args))
} }
accounts := args[0].([]common.Address)
return &dasignerstypes.QuerySignerRequest{ req := dasignerstypes.QuerySignerRequest{
Account: ToLowerHexWithoutPrefix(args[0].(common.Address)), Accounts: make([]string, len(accounts)),
}, nil }
for i, account := range accounts {
req.Accounts[i] = ToLowerHexWithoutPrefix(account)
}
return &req, nil
} }
func NewQueryEpochSignerSetRequest(args []interface{}) (*dasignerstypes.QueryEpochSignerSetRequest, error) { func NewQueryEpochQuorumRequest(args []interface{}) (*dasignerstypes.QueryEpochQuorumRequest, error) {
if len(args) != 1 {
return nil, fmt.Errorf(precopmiles_common.ErrInvalidNumberOfArgs, 1, len(args))
}
return &dasignerstypes.QueryEpochSignerSetRequest{
EpochNumber: args[0].(*big.Int).Uint64(),
}, nil
}
func NewQueryAggregatePubkeyG1Request(args []interface{}) (*dasignerstypes.QueryAggregatePubkeyG1Request, error) {
if len(args) != 2 { if len(args) != 2 {
return nil, fmt.Errorf(precopmiles_common.ErrInvalidNumberOfArgs, 2, len(args)) return nil, fmt.Errorf(precopmiles_common.ErrInvalidNumberOfArgs, 2, len(args))
} }
return &dasignerstypes.QueryEpochQuorumRequest{
EpochNumber: args[0].(*big.Int).Uint64(),
QuorumId: args[1].(*big.Int).Uint64(),
}, nil
}
func NewQueryAggregatePubkeyG1Request(args []interface{}) (*dasignerstypes.QueryAggregatePubkeyG1Request, error) {
if len(args) != 3 {
return nil, fmt.Errorf(precopmiles_common.ErrInvalidNumberOfArgs, 3, len(args))
}
return &dasignerstypes.QueryAggregatePubkeyG1Request{ return &dasignerstypes.QueryAggregatePubkeyG1Request{
EpochNumber: args[0].(*big.Int).Uint64(), EpochNumber: args[0].(*big.Int).Uint64(),
SignersBitmap: args[1].([]byte), QuorumId: args[1].(*big.Int).Uint64(),
QuorumBitmap: args[2].([]byte),
}, nil }, nil
} }

6
proto/zgc/dasigners/v1/dasigners.proto
View File

@ -20,6 +20,10 @@ message Signer {
bytes pubkey_g2 = 4; bytes pubkey_g2 = 4;
} }
message EpochSignerSet { message Quorum {
repeated string signers = 1; repeated string signers = 1;
} }
message Quorums {
repeated Quorum quorums = 1;
}

12
proto/zgc/dasigners/v1/genesis.proto
View File

@ -10,10 +10,10 @@ import "zgc/dasigners/v1/dasigners.proto";
option go_package = "github.com/0glabs/0g-chain/x/dasigners/v1/types"; option go_package = "github.com/0glabs/0g-chain/x/dasigners/v1/types";
message Params { message Params {
uint64 quorum_size = 1; string tokens_per_vote = 1;
string tokens_per_vote = 2; uint64 max_votes = 2;
uint64 max_votes = 3; uint64 epoch_blocks = 3;
uint64 epoch_blocks = 4; uint64 encoded_slices = 4;
} }
// GenesisState defines the dasigners module's genesis state. // GenesisState defines the dasigners module's genesis state.
@ -24,6 +24,6 @@ message GenesisState {
uint64 epoch_number = 2; uint64 epoch_number = 2;
// signers defines all signers information // signers defines all signers information
repeated Signer signers = 3; repeated Signer signers = 3;
// signers_by_epoch defines chosen signers by epoch // quorums_by_epoch defines chosen quorums by epoch
repeated EpochSignerSet signers_by_epoch = 4; repeated Quorums quorums_by_epoch = 4;
} }

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

@ -16,8 +16,11 @@ service Query {
rpc EpochNumber(QueryEpochNumberRequest) returns (QueryEpochNumberResponse) { rpc EpochNumber(QueryEpochNumberRequest) returns (QueryEpochNumberResponse) {
option (google.api.http).get = "/0g/dasigners/v1/epoch-number"; option (google.api.http).get = "/0g/dasigners/v1/epoch-number";
} }
rpc EpochSignerSet(QueryEpochSignerSetRequest) returns (QueryEpochSignerSetResponse) { rpc QuorumCount(QueryQuorumCountRequest) returns (QueryQuorumCountResponse) {
option (google.api.http).get = "/0g/dasigners/v1/epoch-signer-set"; option (google.api.http).get = "/0g/dasigners/v1/quorum-count";
}
rpc EpochQuorum(QueryEpochQuorumRequest) returns (QueryEpochQuorumResponse) {
option (google.api.http).get = "/0g/dasigners/v1/epoch-quorum";
} }
rpc AggregatePubkeyG1(QueryAggregatePubkeyG1Request) returns (QueryAggregatePubkeyG1Response) { rpc AggregatePubkeyG1(QueryAggregatePubkeyG1Request) returns (QueryAggregatePubkeyG1Response) {
option (google.api.http).get = "/0g/dasigners/v1/aggregate-pubkey-g1"; option (google.api.http).get = "/0g/dasigners/v1/aggregate-pubkey-g1";
@ -28,11 +31,11 @@ service Query {
} }
message QuerySignerRequest { message QuerySignerRequest {
string account = 1; repeated string accounts = 1;
} }
message QuerySignerResponse { message QuerySignerResponse {
Signer signer = 1; repeated Signer signer = 1;
} }
message QueryEpochNumberRequest {} message QueryEpochNumberRequest {}
@ -41,17 +44,27 @@ message QueryEpochNumberResponse {
uint64 epoch_number = 1; uint64 epoch_number = 1;
} }
message QueryEpochSignerSetRequest { message QueryQuorumCountRequest {
uint64 epoch_number = 1; uint64 epoch_number = 1;
} }
message QueryEpochSignerSetResponse { message QueryQuorumCountResponse {
repeated Signer signers = 1; uint64 quorum_count = 1;
}
message QueryEpochQuorumRequest {
uint64 epoch_number = 1;
uint64 quorum_id = 2;
}
message QueryEpochQuorumResponse {
Quorum quorum = 1;
} }
message QueryAggregatePubkeyG1Request { message QueryAggregatePubkeyG1Request {
uint64 epoch_number = 1; uint64 epoch_number = 1;
bytes signersBitmap = 2; uint64 quorum_id = 2;
bytes quorum_bitmap = 3;
} }
message QueryAggregatePubkeyG1Response { message QueryAggregatePubkeyG1Response {

14
x/dasigners/v1/genesis.go
View File

@ -20,8 +20,8 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, gs types.GenesisState) {
panic(fmt.Sprintf("failed to write genesis state into store: %s", err)) panic(fmt.Sprintf("failed to write genesis state into store: %s", err))
} }
} }
for epoch, signers := range gs.SignersByEpoch { for epoch, quorums := range gs.QuorumsByEpoch {
keeper.SetEpochSignerSet(ctx, uint64(epoch), *signers) keeper.SetEpochQuorums(ctx, uint64(epoch), *quorums)
} }
keeper.SetParams(ctx, gs.Params) keeper.SetParams(ctx, gs.Params)
} }
@ -38,13 +38,13 @@ func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) *types.GenesisState {
signers = append(signers, &signer) signers = append(signers, &signer)
return false return false
}) })
epochSignerSets := make([]*types.EpochSignerSet, 0) epochQuorums := make([]*types.Quorums, 0)
for i := 0; i < int(epochNumber); i += 1 { for i := 0; i < int(epochNumber); i += 1 {
epochSignerSet, found := keeper.GetEpochSignerSet(ctx, uint64(i)) quorums, found := keeper.GetEpochQuorums(ctx, uint64(i))
if !found { if !found {
panic("historical epoch signer set not found") panic("historical quorums not found")
} }
epochSignerSets = append(epochSignerSets, &epochSignerSet) epochQuorums = append(epochQuorums, &quorums)
} }
return types.NewGenesisState(params, epochNumber, signers, epochSignerSets) return types.NewGenesisState(params, epochNumber, signers, epochQuorums)
} }

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

@ -72,17 +72,32 @@ func (k Keeper) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) {
sort.Slice(ballots, func(i, j int) bool { sort.Slice(ballots, func(i, j int) bool {
return bytes.Compare(ballots[i].content, ballots[j].content) < 0 return bytes.Compare(ballots[i].content, ballots[j].content) < 0
}) })
chosen := make(map[string]struct{})
epochSignerSet := types.EpochSignerSet{ quorums := types.Quorums{
Signers: make([]string, 0), Quorums: make([]*types.Quorum, 0),
} }
for _, ballot := range ballots { if len(ballots) >= int(params.EncodedSlices) {
if _, ok := chosen[ballot.account]; !ok { for i := 0; i+int(params.EncodedSlices) < len(ballots); i += 1 {
chosen[ballot.account] = struct{}{} quorum := types.Quorum{
epochSignerSet.Signers = append(epochSignerSet.Signers, ballot.account) Signers: make([]string, params.EncodedSlices),
} }
for j := 0; j < int(params.EncodedSlices); j += 1 {
quorum.Signers[j] = ballots[i+j].account
} }
quorums.Quorums = append(quorums.Quorums, &quorum)
}
} else {
quorum := types.Quorum{
Signers: make([]string, params.EncodedSlices),
}
n := len(ballots)
for i := 0; i < int(params.EncodedSlices); i += 1 {
quorum.Signers[i] = ballots[i%n].account
}
quorums.Quorums = append(quorums.Quorums, &quorum)
}
// save to store // save to store
k.SetEpochSignerSet(ctx, expectedEpoch, epochSignerSet) k.SetEpochQuorums(ctx, expectedEpoch, quorums)
k.SetEpochNumber(ctx, expectedEpoch) k.SetEpochNumber(ctx, expectedEpoch)
} }

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

@ -13,17 +13,22 @@ var _ types.QueryServer = Keeper{}
func (k Keeper) Signer( func (k Keeper) Signer(
c context.Context, c context.Context,
req *types.QuerySignerRequest, request *types.QuerySignerRequest,
) (*types.QuerySignerResponse, error) { ) (*types.QuerySignerResponse, error) {
ctx := sdk.UnwrapSDKContext(c) ctx := sdk.UnwrapSDKContext(c)
signer, found, err := k.GetSigner(ctx, req.Account) n := len(request.Accounts)
response := types.QuerySignerResponse{Signer: make([]*types.Signer, n)}
for i := 0; i < n; i += 1 {
signer, found, err := k.GetSigner(ctx, request.Accounts[i])
if err != nil { if err != nil {
return nil, err return nil, err
} }
if !found { if !found {
return nil, nil return nil, nil
} }
return &types.QuerySignerResponse{Signer: &signer}, nil response.Signer[i] = &signer
}
return &response, nil
} }
func (k Keeper) EpochNumber( func (k Keeper) EpochNumber(
@ -38,43 +43,56 @@ func (k Keeper) EpochNumber(
return &types.QueryEpochNumberResponse{EpochNumber: epochNumber}, nil return &types.QueryEpochNumberResponse{EpochNumber: epochNumber}, nil
} }
func (k Keeper) EpochSignerSet(c context.Context, request *types.QueryEpochSignerSetRequest) (*types.QueryEpochSignerSetResponse, error) { func (k Keeper) QuorumCount(
c context.Context,
request *types.QueryQuorumCountRequest,
) (*types.QueryQuorumCountResponse, error) {
ctx := sdk.UnwrapSDKContext(c) ctx := sdk.UnwrapSDKContext(c)
signers, found := k.GetEpochSignerSet(ctx, request.EpochNumber) quorumCount, err := k.GetQuorumCount(ctx, request.EpochNumber)
if !found {
return nil, types.ErrEpochSignerSetNotFound
}
epochSignerSet := make([]*types.Signer, len(signers.Signers))
for _, account := range signers.Signers {
signer, found, err := k.GetSigner(ctx, account)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &types.QueryQuorumCountResponse{QuorumCount: quorumCount}, nil
}
func (k Keeper) EpochQuorum(c context.Context, request *types.QueryEpochQuorumRequest) (*types.QueryEpochQuorumResponse, error) {
ctx := sdk.UnwrapSDKContext(c)
quorums, found := k.GetEpochQuorums(ctx, request.EpochNumber)
if !found { if !found {
return nil, types.ErrSignerNotFound return nil, types.ErrQuorumNotFound
} }
epochSignerSet = append(epochSignerSet, &signer) if len(quorums.Quorums) <= int(request.QuorumId) {
return nil, types.ErrQuorumIdOutOfBound
} }
return &types.QueryEpochSignerSetResponse{Signers: epochSignerSet}, nil return &types.QueryEpochQuorumResponse{Quorum: quorums.Quorums[request.QuorumId]}, nil
} }
func (k Keeper) AggregatePubkeyG1(c context.Context, request *types.QueryAggregatePubkeyG1Request) (*types.QueryAggregatePubkeyG1Response, error) { func (k Keeper) AggregatePubkeyG1(c context.Context, request *types.QueryAggregatePubkeyG1Request) (*types.QueryAggregatePubkeyG1Response, error) {
ctx := sdk.UnwrapSDKContext(c) ctx := sdk.UnwrapSDKContext(c)
signers, found := k.GetEpochSignerSet(ctx, request.EpochNumber) quorums, found := k.GetEpochQuorums(ctx, request.EpochNumber)
if !found { if !found {
return nil, types.ErrEpochSignerSetNotFound return nil, types.ErrQuorumNotFound
} }
if len(request.SignersBitmap) != (len(signers.Signers)+7)/8 { if len(quorums.Quorums) <= int(request.QuorumId) {
return nil, types.ErrSignerLengthNotMatch return nil, types.ErrQuorumIdOutOfBound
}
quorum := quorums.Quorums[request.QuorumId]
if (len(quorum.Signers)+7)/8 != len(request.QuorumBitmap) {
return nil, types.ErrQuorumBitmapLengthMismatch
} }
aggPubkeyG1 := new(bn254.G1Affine) aggPubkeyG1 := new(bn254.G1Affine)
hit := 0 hit := 0
for i, account := range signers.Signers { added := make(map[string]struct{})
b := request.SignersBitmap[i/8] & (1 << (i % 8)) for i, signer := range quorum.Signers {
b := request.QuorumBitmap[i/8] & (1 << (i % 8))
if b == 0 { if b == 0 {
continue continue
} }
signer, found, err := k.GetSigner(ctx, account) if _, ok := added[signer]; ok {
continue
}
added[signer] = struct{}{}
signer, found, err := k.GetSigner(ctx, signer)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -86,7 +104,7 @@ func (k Keeper) AggregatePubkeyG1(c context.Context, request *types.QueryAggrega
} }
return &types.QueryAggregatePubkeyG1Response{ return &types.QueryAggregatePubkeyG1Response{
AggregatePubkeyG1: bn254util.SerializeG1(aggPubkeyG1), AggregatePubkeyG1: bn254util.SerializeG1(aggPubkeyG1),
Total: uint64(len(signers.Signers)), Total: uint64(len(quorum.Signers)),
Hit: uint64(hit), Hit: uint64(hit),
}, nil }, nil
} }

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

@ -64,6 +64,20 @@ func (k Keeper) SetEpochNumber(ctx sdk.Context, epoch uint64) {
store.Set(types.EpochNumberKey, sdk.Uint64ToBigEndian(epoch)) store.Set(types.EpochNumberKey, sdk.Uint64ToBigEndian(epoch))
} }
func (k Keeper) GetQuorumCount(ctx sdk.Context, epoch uint64) (uint64, error) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.QuorumCountKeyPrefix)
bz := store.Get(types.GetQuorumCountKey(epoch))
if bz == nil {
return 0, types.ErrQuorumNotFound
}
return sdk.BigEndianToUint64(bz), nil
}
func (k Keeper) SetQuorumCount(ctx sdk.Context, epoch uint64, quorums uint64) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.QuorumCountKeyPrefix)
store.Set(types.GetQuorumCountKey(epoch), sdk.Uint64ToBigEndian(quorums))
}
func (k Keeper) GetSigner(ctx sdk.Context, account string) (types.Signer, bool, error) { func (k Keeper) GetSigner(ctx sdk.Context, account string) (types.Signer, bool, error) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.SignerKeyPrefix) store := prefix.NewStore(ctx.KVStore(k.storeKey), types.SignerKeyPrefix)
key, err := types.GetSignerKeyFromAccount(account) key, err := types.GetSignerKeyFromAccount(account)
@ -122,21 +136,22 @@ func (k Keeper) IterateSigners(ctx sdk.Context, fn func(index int64, signer type
} }
} }
func (k Keeper) GetEpochSignerSet(ctx sdk.Context, epoch uint64) (types.EpochSignerSet, bool) { func (k Keeper) GetEpochQuorums(ctx sdk.Context, epoch uint64) (types.Quorums, bool) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.EpochSignerSetKeyPrefix) store := prefix.NewStore(ctx.KVStore(k.storeKey), types.EpochQuorumsKeyPrefix)
bz := store.Get(types.GetEpochSignerSetKeyFromEpoch(epoch)) bz := store.Get(types.GetEpochQuorumsKeyFromEpoch(epoch))
if bz == nil { if bz == nil {
return types.EpochSignerSet{}, false return types.Quorums{}, false
} }
var signers types.EpochSignerSet var quorums types.Quorums
k.cdc.MustUnmarshal(bz, &signers) k.cdc.MustUnmarshal(bz, &quorums)
return signers, true return quorums, true
} }
func (k Keeper) SetEpochSignerSet(ctx sdk.Context, epoch uint64, signers types.EpochSignerSet) { func (k Keeper) SetEpochQuorums(ctx sdk.Context, epoch uint64, quorums types.Quorums) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.EpochSignerSetKeyPrefix) store := prefix.NewStore(ctx.KVStore(k.storeKey), types.EpochQuorumsKeyPrefix)
bz := k.cdc.MustMarshal(&signers) bz := k.cdc.MustMarshal(&quorums)
store.Set(types.GetEpochSignerSetKeyFromEpoch(epoch), bz) store.Set(types.GetEpochQuorumsKeyFromEpoch(epoch), bz)
k.SetQuorumCount(ctx, epoch, uint64(len(quorums.Quorums)))
} }
func (k Keeper) GetRegistration(ctx sdk.Context, epoch uint64, account string) ([]byte, bool, error) { func (k Keeper) GetRegistration(ctx sdk.Context, epoch uint64, account string) ([]byte, bool, error) {

258
x/dasigners/v1/types/dasigners.pb.go
View File

@ -70,22 +70,22 @@ func (m *Signer) XXX_DiscardUnknown() {
var xxx_messageInfo_Signer proto.InternalMessageInfo var xxx_messageInfo_Signer proto.InternalMessageInfo
type EpochSignerSet struct { type Quorum struct {
Signers []string `protobuf:"bytes,1,rep,name=signers,proto3" json:"signers,omitempty"` Signers []string `protobuf:"bytes,1,rep,name=signers,proto3" json:"signers,omitempty"`
} }
func (m *EpochSignerSet) Reset() { *m = EpochSignerSet{} } func (m *Quorum) Reset() { *m = Quorum{} }
func (m *EpochSignerSet) String() string { return proto.CompactTextString(m) } func (m *Quorum) String() string { return proto.CompactTextString(m) }
func (*EpochSignerSet) ProtoMessage() {} func (*Quorum) ProtoMessage() {}
func (*EpochSignerSet) Descriptor() ([]byte, []int) { func (*Quorum) Descriptor() ([]byte, []int) {
return fileDescriptor_b7328dc8ffac059e, []int{1} return fileDescriptor_b7328dc8ffac059e, []int{1}
} }
func (m *EpochSignerSet) XXX_Unmarshal(b []byte) error { func (m *Quorum) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
} }
func (m *EpochSignerSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *Quorum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic { if deterministic {
return xxx_messageInfo_EpochSignerSet.Marshal(b, m, deterministic) return xxx_messageInfo_Quorum.Marshal(b, m, deterministic)
} else { } else {
b = b[:cap(b)] b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b) n, err := m.MarshalToSizedBuffer(b)
@ -95,45 +95,85 @@ func (m *EpochSignerSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
return b[:n], nil return b[:n], nil
} }
} }
func (m *EpochSignerSet) XXX_Merge(src proto.Message) { func (m *Quorum) XXX_Merge(src proto.Message) {
xxx_messageInfo_EpochSignerSet.Merge(m, src) xxx_messageInfo_Quorum.Merge(m, src)
} }
func (m *EpochSignerSet) XXX_Size() int { func (m *Quorum) XXX_Size() int {
return m.Size() return m.Size()
} }
func (m *EpochSignerSet) XXX_DiscardUnknown() { func (m *Quorum) XXX_DiscardUnknown() {
xxx_messageInfo_EpochSignerSet.DiscardUnknown(m) xxx_messageInfo_Quorum.DiscardUnknown(m)
} }
var xxx_messageInfo_EpochSignerSet proto.InternalMessageInfo var xxx_messageInfo_Quorum proto.InternalMessageInfo
type Quorums struct {
Quorums []*Quorum `protobuf:"bytes,1,rep,name=quorums,proto3" json:"quorums,omitempty"`
}
func (m *Quorums) Reset() { *m = Quorums{} }
func (m *Quorums) String() string { return proto.CompactTextString(m) }
func (*Quorums) ProtoMessage() {}
func (*Quorums) Descriptor() ([]byte, []int) {
return fileDescriptor_b7328dc8ffac059e, []int{2}
}
func (m *Quorums) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Quorums) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Quorums.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 *Quorums) XXX_Merge(src proto.Message) {
xxx_messageInfo_Quorums.Merge(m, src)
}
func (m *Quorums) XXX_Size() int {
return m.Size()
}
func (m *Quorums) XXX_DiscardUnknown() {
xxx_messageInfo_Quorums.DiscardUnknown(m)
}
var xxx_messageInfo_Quorums proto.InternalMessageInfo
func init() { func init() {
proto.RegisterType((*Signer)(nil), "zgc.dasigners.v1.Signer") proto.RegisterType((*Signer)(nil), "zgc.dasigners.v1.Signer")
proto.RegisterType((*EpochSignerSet)(nil), "zgc.dasigners.v1.EpochSignerSet") proto.RegisterType((*Quorum)(nil), "zgc.dasigners.v1.Quorum")
proto.RegisterType((*Quorums)(nil), "zgc.dasigners.v1.Quorums")
} }
func init() { proto.RegisterFile("zgc/dasigners/v1/dasigners.proto", fileDescriptor_b7328dc8ffac059e) } func init() { proto.RegisterFile("zgc/dasigners/v1/dasigners.proto", fileDescriptor_b7328dc8ffac059e) }
var fileDescriptor_b7328dc8ffac059e = []byte{ var fileDescriptor_b7328dc8ffac059e = []byte{
// 287 bytes of a gzipped FileDescriptorProto // 309 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x90, 0xc1, 0x4a, 0xc3, 0x30, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x91, 0xb1, 0x6e, 0xea, 0x30,
0x1c, 0xc6, 0x1b, 0x27, 0xd3, 0x05, 0x11, 0x29, 0x22, 0xd9, 0x84, 0x50, 0x76, 0x1a, 0x82, 0xcd, 0x14, 0x86, 0xe3, 0xcb, 0x55, 0x28, 0x6e, 0x87, 0x2a, 0xaa, 0x2a, 0x43, 0x25, 0x2b, 0xca, 0xc4,
0x3a, 0xdf, 0x40, 0x10, 0x4f, 0x5e, 0xb6, 0x9b, 0x97, 0x91, 0x66, 0x31, 0x2d, 0xdb, 0xfa, 0x2f, 0xd2, 0x98, 0xa4, 0x73, 0x97, 0x2e, 0x9d, 0x3a, 0x94, 0x6e, 0x5d, 0x90, 0x63, 0x52, 0x13, 0x01,
0x4d, 0x3a, 0xec, 0x9e, 0xc2, 0xc7, 0xda, 0x71, 0x47, 0x8f, 0xda, 0xbe, 0x88, 0xb4, 0xa9, 0xcc, 0x39, 0x34, 0xb6, 0x51, 0xe1, 0x29, 0xfa, 0x58, 0x8c, 0x8c, 0x1d, 0x5b, 0x78, 0x91, 0x0a, 0x3b,
0x79, 0xcb, 0xef, 0xfb, 0x05, 0x3e, 0xfe, 0x1f, 0xf6, 0xb6, 0x4a, 0xb0, 0x05, 0xd7, 0xb1, 0x4a, 0x88, 0xc2, 0x76, 0xbe, 0xff, 0xfb, 0xa5, 0x23, 0x1f, 0xe3, 0x70, 0x29, 0x05, 0x1b, 0x72, 0x55,
0x64, 0xa6, 0xd9, 0x26, 0x38, 0x80, 0x9f, 0x66, 0x60, 0xc0, 0xbd, 0xda, 0x2a, 0xe1, 0x1f, 0xc2, 0xc8, 0x32, 0xaf, 0x14, 0x9b, 0x27, 0x07, 0x88, 0x67, 0x15, 0x68, 0x08, 0x2e, 0x97, 0x52, 0xc4,
0x4d, 0x30, 0xe8, 0x0b, 0xd0, 0x6b, 0xd0, 0xf3, 0xc6, 0x33, 0x0b, 0xf6, 0xf3, 0xe0, 0x5a, 0x81, 0x87, 0x70, 0x9e, 0x74, 0xda, 0x02, 0xd4, 0x14, 0xd4, 0xc0, 0x7a, 0xe6, 0xc0, 0x95, 0x3b, 0x57,
0x02, 0x9b, 0xd7, 0xaf, 0x36, 0xed, 0x2b, 0x00, 0xb5, 0x92, 0xac, 0xa1, 0x30, 0x7f, 0x63, 0x3c, 0x12, 0x24, 0xb8, 0x7c, 0x37, 0xd5, 0x69, 0x5b, 0x02, 0xc8, 0x49, 0xce, 0x2c, 0x65, 0xe6, 0x8d,
0x29, 0x5a, 0x45, 0xff, 0xab, 0x45, 0x9e, 0x71, 0x13, 0x43, 0x62, 0xfd, 0xd0, 0xe0, 0xee, 0xac, 0xf1, 0x72, 0x51, 0x2b, 0x7a, 0xaa, 0x86, 0xa6, 0xe2, 0xba, 0x80, 0xd2, 0xf9, 0x48, 0x63, 0xff,
0x69, 0x76, 0x09, 0x3e, 0xe3, 0x42, 0x40, 0x9e, 0x18, 0x82, 0x3c, 0x34, 0xea, 0x4d, 0x7f, 0xd1, 0xc5, 0x6e, 0x0e, 0x08, 0x6e, 0x72, 0x21, 0xc0, 0x94, 0x9a, 0xa0, 0x10, 0x75, 0x5b, 0xfd, 0x3d,
0xbd, 0xc1, 0x5d, 0x0d, 0x62, 0x29, 0x0d, 0x39, 0x69, 0x44, 0x4b, 0xee, 0x2d, 0xee, 0xa5, 0x79, 0x06, 0xd7, 0xd8, 0x57, 0x20, 0xc6, 0xb9, 0x26, 0xff, 0xac, 0xa8, 0x29, 0xb8, 0xc1, 0xad, 0x99,
0xb8, 0x94, 0xc5, 0x5c, 0x05, 0xa4, 0xe3, 0xa1, 0xd1, 0xc5, 0xf4, 0xdc, 0x06, 0xcf, 0xc1, 0x5f, 0xc9, 0xc6, 0xf9, 0x62, 0x20, 0x13, 0xd2, 0x08, 0x51, 0xf7, 0xa2, 0x7f, 0xe6, 0x82, 0xc7, 0xe4,
0x39, 0x21, 0xa7, 0x47, 0x72, 0x32, 0xbc, 0xc3, 0x97, 0x4f, 0x29, 0x88, 0xc8, 0x56, 0xcf, 0xa4, 0xaf, 0x4c, 0xc9, 0xff, 0x23, 0x99, 0x46, 0x11, 0xf6, 0x9f, 0x0d, 0x54, 0x66, 0xba, 0xdb, 0x5a,
0xa9, 0xdb, 0xdb, 0x05, 0x08, 0xf2, 0x3a, 0x75, 0x7b, 0x8b, 0x8f, 0x2f, 0xbb, 0x6f, 0xea, 0xec, 0xbf, 0x9c, 0xa0, 0xb0, 0xb1, 0xdb, 0x5a, 0x63, 0x74, 0x8f, 0x9b, 0xae, 0xa3, 0x82, 0x14, 0x37,
0x4a, 0x8a, 0xf6, 0x25, 0x45, 0x5f, 0x25, 0x45, 0x1f, 0x15, 0x75, 0xf6, 0x15, 0x75, 0x3e, 0x2b, 0xdf, 0xdd, 0x68, 0x4b, 0xe7, 0x29, 0x89, 0x4f, 0x8f, 0x16, 0xbb, 0x6e, 0x7f, 0x5f, 0x7c, 0x78,
0xea, 0xbc, 0x32, 0x15, 0x9b, 0x28, 0x0f, 0x7d, 0x01, 0x6b, 0x36, 0x56, 0x2b, 0x1e, 0x6a, 0x36, 0x5a, 0xfd, 0x50, 0x6f, 0xb5, 0xa1, 0x68, 0xbd, 0xa1, 0xe8, 0x7b, 0x43, 0xd1, 0xe7, 0x96, 0x7a,
0x56, 0xf7, 0x22, 0xe2, 0x71, 0xc2, 0xde, 0x8f, 0x87, 0x37, 0x45, 0x2a, 0x75, 0xd8, 0x6d, 0xee, 0xeb, 0x2d, 0xf5, 0xbe, 0xb6, 0xd4, 0x7b, 0x65, 0xb2, 0xd0, 0x23, 0x93, 0xc5, 0x02, 0xa6, 0xac,
0x7e, 0xf8, 0x09, 0x00, 0x00, 0xff, 0xff, 0x77, 0x51, 0x09, 0xd9, 0x99, 0x01, 0x00, 0x00, 0x27, 0x27, 0x3c, 0x53, 0xac, 0x27, 0x6f, 0xc5, 0x88, 0x17, 0x25, 0xfb, 0x38, 0xfe, 0x2f, 0xbd,
0x98, 0xe5, 0x2a, 0xf3, 0xed, 0xb9, 0xee, 0x7e, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc2, 0x80, 0xdc,
0x60, 0xd0, 0x01, 0x00, 0x00,
} }
func (m *Signer) Marshal() (dAtA []byte, err error) { func (m *Signer) Marshal() (dAtA []byte, err error) {
@ -187,7 +227,7 @@ func (m *Signer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *EpochSignerSet) Marshal() (dAtA []byte, err error) { func (m *Quorum) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size]) n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -197,12 +237,12 @@ func (m *EpochSignerSet) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *EpochSignerSet) MarshalTo(dAtA []byte) (int, error) { func (m *Quorum) MarshalTo(dAtA []byte) (int, error) {
size := m.Size() size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size]) return m.MarshalToSizedBuffer(dAtA[:size])
} }
func (m *EpochSignerSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { func (m *Quorum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA) i := len(dAtA)
_ = i _ = i
var l int var l int
@ -219,6 +259,43 @@ func (m *EpochSignerSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *Quorums) 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 *Quorums) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Quorums) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Quorums) > 0 {
for iNdEx := len(m.Quorums) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Quorums[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintDasigners(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func encodeVarintDasigners(dAtA []byte, offset int, v uint64) int { func encodeVarintDasigners(dAtA []byte, offset int, v uint64) int {
offset -= sovDasigners(v) offset -= sovDasigners(v)
base := offset base := offset
@ -255,7 +332,7 @@ func (m *Signer) Size() (n int) {
return n return n
} }
func (m *EpochSignerSet) Size() (n int) { func (m *Quorum) Size() (n int) {
if m == nil { if m == nil {
return 0 return 0
} }
@ -270,6 +347,21 @@ func (m *EpochSignerSet) Size() (n int) {
return n return n
} }
func (m *Quorums) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Quorums) > 0 {
for _, e := range m.Quorums {
l = e.Size()
n += 1 + l + sovDasigners(uint64(l))
}
}
return n
}
func sovDasigners(x uint64) (n int) { func sovDasigners(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7 return (math_bits.Len64(x|1) + 6) / 7
} }
@ -458,7 +550,7 @@ func (m *Signer) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *EpochSignerSet) Unmarshal(dAtA []byte) error { func (m *Quorum) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {
@ -481,10 +573,10 @@ func (m *EpochSignerSet) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3) fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7) wireType := int(wire & 0x7)
if wireType == 4 { if wireType == 4 {
return fmt.Errorf("proto: EpochSignerSet: wiretype end group for non-group") return fmt.Errorf("proto: Quorum: wiretype end group for non-group")
} }
if fieldNum <= 0 { if fieldNum <= 0 {
return fmt.Errorf("proto: EpochSignerSet: illegal tag %d (wire type %d)", fieldNum, wire) return fmt.Errorf("proto: Quorum: illegal tag %d (wire type %d)", fieldNum, wire)
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
@ -540,6 +632,90 @@ func (m *EpochSignerSet) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *Quorums) 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 ErrIntOverflowDasigners
}
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: Quorums: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Quorums: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Quorums", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowDasigners
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthDasigners
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthDasigners
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Quorums = append(m.Quorums, &Quorum{})
if err := m.Quorums[len(m.Quorums)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipDasigners(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthDasigners
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipDasigners(dAtA []byte) (n int, err error) { func skipDasigners(dAtA []byte) (n int, err error) {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0

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

@ -7,6 +7,7 @@ var (
ErrEpochNumberNotSet = errorsmod.Register(ModuleName, 2, "epoch number not set") ErrEpochNumberNotSet = errorsmod.Register(ModuleName, 2, "epoch number not set")
ErrSignerNotFound = errorsmod.Register(ModuleName, 3, "signer not found") ErrSignerNotFound = errorsmod.Register(ModuleName, 3, "signer not found")
ErrInvalidSignature = errorsmod.Register(ModuleName, 4, "invalid signature") ErrInvalidSignature = errorsmod.Register(ModuleName, 4, "invalid signature")
ErrEpochSignerSetNotFound = errorsmod.Register(ModuleName, 5, "signer set for epoch not found") ErrQuorumNotFound = errorsmod.Register(ModuleName, 5, "quorum for epoch not found")
ErrSignerLengthNotMatch = errorsmod.Register(ModuleName, 6, "signer set length not match") ErrQuorumIdOutOfBound = errorsmod.Register(ModuleName, 6, "quorum id out of bound")
ErrQuorumBitmapLengthMismatch = errorsmod.Register(ModuleName, 6, "quorum bitmap length mismatch")
) )

16
x/dasigners/v1/types/genesis.go
View File

@ -3,23 +3,23 @@ package types
import "fmt" import "fmt"
// NewGenesisState returns a new genesis state object for the module. // NewGenesisState returns a new genesis state object for the module.
func NewGenesisState(params Params, epoch uint64, signers []*Signer, signersByEpoch []*EpochSignerSet) *GenesisState { func NewGenesisState(params Params, epoch uint64, signers []*Signer, quorumsByEpoch []*Quorums) *GenesisState {
return &GenesisState{ return &GenesisState{
Params: params, Params: params,
EpochNumber: epoch, EpochNumber: epoch,
Signers: signers, Signers: signers,
SignersByEpoch: signersByEpoch, QuorumsByEpoch: quorumsByEpoch,
} }
} }
// DefaultGenesisState returns the default genesis state for the module. // DefaultGenesisState returns the default genesis state for the module.
func DefaultGenesisState() *GenesisState { func DefaultGenesisState() *GenesisState {
return NewGenesisState(Params{ return NewGenesisState(Params{
QuorumSize: 1024,
TokensPerVote: "100", TokensPerVote: "100",
MaxVotes: 100, MaxVotes: 100,
EpochBlocks: 1000, EpochBlocks: 1000,
}, 0, make([]*Signer, 0), make([]*EpochSignerSet, 0)) EncodedSlices: 3072,
}, 0, make([]*Signer, 0), make([]*Quorums, 0))
} }
// Validate performs basic validation of genesis data. // Validate performs basic validation of genesis data.
@ -31,11 +31,12 @@ func (gs GenesisState) Validate() error {
} }
registered[signer.Account] = struct{}{} registered[signer.Account] = struct{}{}
} }
if len(gs.SignersByEpoch) != int(gs.EpochNumber) { if len(gs.QuorumsByEpoch) != int(gs.EpochNumber) {
return fmt.Errorf("epoch history missing") return fmt.Errorf("epoch history missing")
} }
for _, signers := range gs.SignersByEpoch { for _, quorums := range gs.QuorumsByEpoch {
for _, signer := range signers.Signers { for _, quorum := range quorums.Quorums {
for _, signer := range quorum.Signers {
if err := ValidateHexAddress(signer); err != nil { if err := ValidateHexAddress(signer); err != nil {
return err return err
} }
@ -44,5 +45,6 @@ func (gs GenesisState) Validate() error {
} }
} }
} }
}
return nil return nil
} }

165
x/dasigners/v1/types/genesis.pb.go
View File

@ -27,10 +27,10 @@ var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type Params struct { type Params struct {
QuorumSize uint64 `protobuf:"varint,1,opt,name=quorum_size,json=quorumSize,proto3" json:"quorum_size,omitempty"` TokensPerVote string `protobuf:"bytes,1,opt,name=tokens_per_vote,json=tokensPerVote,proto3" json:"tokens_per_vote,omitempty"`
TokensPerVote string `protobuf:"bytes,2,opt,name=tokens_per_vote,json=tokensPerVote,proto3" json:"tokens_per_vote,omitempty"` MaxVotes uint64 `protobuf:"varint,2,opt,name=max_votes,json=maxVotes,proto3" json:"max_votes,omitempty"`
MaxVotes uint64 `protobuf:"varint,3,opt,name=max_votes,json=maxVotes,proto3" json:"max_votes,omitempty"` EpochBlocks uint64 `protobuf:"varint,3,opt,name=epoch_blocks,json=epochBlocks,proto3" json:"epoch_blocks,omitempty"`
EpochBlocks uint64 `protobuf:"varint,4,opt,name=epoch_blocks,json=epochBlocks,proto3" json:"epoch_blocks,omitempty"` EncodedSlices uint64 `protobuf:"varint,4,opt,name=encoded_slices,json=encodedSlices,proto3" json:"encoded_slices,omitempty"`
} }
func (m *Params) Reset() { *m = Params{} } func (m *Params) Reset() { *m = Params{} }
@ -66,13 +66,6 @@ func (m *Params) XXX_DiscardUnknown() {
var xxx_messageInfo_Params proto.InternalMessageInfo var xxx_messageInfo_Params proto.InternalMessageInfo
func (m *Params) GetQuorumSize() uint64 {
if m != nil {
return m.QuorumSize
}
return 0
}
func (m *Params) GetTokensPerVote() string { func (m *Params) GetTokensPerVote() string {
if m != nil { if m != nil {
return m.TokensPerVote return m.TokensPerVote
@ -94,6 +87,13 @@ func (m *Params) GetEpochBlocks() uint64 {
return 0 return 0
} }
func (m *Params) GetEncodedSlices() uint64 {
if m != nil {
return m.EncodedSlices
}
return 0
}
// GenesisState defines the dasigners module's genesis state. // GenesisState defines the dasigners module's genesis state.
type GenesisState struct { type GenesisState struct {
// params defines all the parameters of related to deposit. // params defines all the parameters of related to deposit.
@ -102,8 +102,8 @@ type GenesisState struct {
EpochNumber uint64 `protobuf:"varint,2,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"` EpochNumber uint64 `protobuf:"varint,2,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
// signers defines all signers information // signers defines all signers information
Signers []*Signer `protobuf:"bytes,3,rep,name=signers,proto3" json:"signers,omitempty"` Signers []*Signer `protobuf:"bytes,3,rep,name=signers,proto3" json:"signers,omitempty"`
// signers_by_epoch defines chosen signers by epoch // quorums_by_epoch defines chosen quorums by epoch
SignersByEpoch []*EpochSignerSet `protobuf:"bytes,4,rep,name=signers_by_epoch,json=signersByEpoch,proto3" json:"signers_by_epoch,omitempty"` QuorumsByEpoch []*Quorums `protobuf:"bytes,4,rep,name=quorums_by_epoch,json=quorumsByEpoch,proto3" json:"quorums_by_epoch,omitempty"`
} }
func (m *GenesisState) Reset() { *m = GenesisState{} } func (m *GenesisState) Reset() { *m = GenesisState{} }
@ -160,9 +160,9 @@ func (m *GenesisState) GetSigners() []*Signer {
return nil return nil
} }
func (m *GenesisState) GetSignersByEpoch() []*EpochSignerSet { func (m *GenesisState) GetQuorumsByEpoch() []*Quorums {
if m != nil { if m != nil {
return m.SignersByEpoch return m.QuorumsByEpoch
} }
return nil return nil
} }
@ -175,33 +175,34 @@ func init() {
func init() { proto.RegisterFile("zgc/dasigners/v1/genesis.proto", fileDescriptor_896efa766aaca3be) } func init() { proto.RegisterFile("zgc/dasigners/v1/genesis.proto", fileDescriptor_896efa766aaca3be) }
var fileDescriptor_896efa766aaca3be = []byte{ var fileDescriptor_896efa766aaca3be = []byte{
// 415 bytes of a gzipped FileDescriptorProto // 417 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xc1, 0x6e, 0xd3, 0x30, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xcf, 0x6e, 0xd3, 0x40,
0x1c, 0xc6, 0x6b, 0x1a, 0x15, 0xe6, 0x0e, 0x98, 0x2c, 0x0e, 0xd9, 0x90, 0xd2, 0xb0, 0x03, 0xda, 0x10, 0xc6, 0x63, 0x12, 0x05, 0xba, 0xfd, 0x43, 0x65, 0x71, 0x70, 0x8a, 0xe4, 0x86, 0x4a, 0xa0,
0x85, 0x78, 0x1b, 0x12, 0x0f, 0x10, 0x09, 0x21, 0x38, 0xa0, 0x29, 0x91, 0x38, 0x70, 0x89, 0x9c, 0x5e, 0xf0, 0xb6, 0x45, 0xe2, 0x01, 0x82, 0x10, 0xe2, 0x82, 0x8a, 0x23, 0x71, 0xe0, 0x62, 0xad,
0xf0, 0xc7, 0x8d, 0x56, 0xc7, 0x21, 0x76, 0xaa, 0x26, 0x4f, 0x01, 0x6f, 0xb5, 0xe3, 0x8e, 0x9c, 0x37, 0xc3, 0xc6, 0x6a, 0xd6, 0x63, 0x3c, 0xeb, 0x28, 0xe9, 0x53, 0x70, 0xe3, 0x95, 0x7a, 0xec,
0x10, 0x6a, 0x4f, 0xbc, 0x05, 0xea, 0xdf, 0x19, 0x13, 0xeb, 0x6e, 0x7f, 0x7f, 0xbf, 0xcf, 0x9f, 0x91, 0x13, 0x42, 0xce, 0x8b, 0xa0, 0x8e, 0x17, 0x2a, 0x5a, 0x6e, 0x3b, 0xdf, 0xf7, 0x9b, 0xd1,
0x3f, 0xdb, 0x34, 0xe8, 0x65, 0xc1, 0xbf, 0x08, 0x53, 0xca, 0x0a, 0x1a, 0xc3, 0x97, 0x67, 0x5c, 0xb7, 0x33, 0x22, 0xbe, 0x34, 0x5a, 0xce, 0x14, 0x15, 0xa6, 0x84, 0x9a, 0xe4, 0xf2, 0x54, 0x1a,
0x42, 0x05, 0xa6, 0x34, 0x51, 0xdd, 0x68, 0xab, 0xd9, 0x41, 0x2f, 0x8b, 0xe8, 0x1f, 0x8f, 0x96, 0x28, 0x81, 0x0a, 0x4a, 0xaa, 0x1a, 0x1d, 0x86, 0xfb, 0x97, 0x46, 0x27, 0x7f, 0xfd, 0x64, 0x79,
0x67, 0x47, 0x87, 0x85, 0x36, 0x4a, 0x9b, 0x0c, 0x39, 0x77, 0x0b, 0x67, 0x3e, 0x7a, 0x26, 0xb5, 0x7a, 0x30, 0xd2, 0x48, 0x16, 0x29, 0x63, 0x5f, 0x76, 0x45, 0x07, 0x1f, 0x3c, 0x31, 0x68, 0xb0,
0xd4, 0x4e, 0xdf, 0x4e, 0x83, 0x7a, 0x28, 0xb5, 0x96, 0x0b, 0xe0, 0xb8, 0xca, 0xdb, 0xaf, 0x5c, 0xd3, 0x6f, 0x5e, 0x5e, 0x1d, 0x19, 0x44, 0xb3, 0x00, 0xc9, 0x55, 0xde, 0x7c, 0x91, 0xaa, 0x5c,
0x54, 0xdd, 0x80, 0x66, 0x77, 0x91, 0x2d, 0x15, 0x18, 0x2b, 0x54, 0x3d, 0x18, 0xc2, 0x9d, 0x7a, 0x7b, 0xeb, 0xf0, 0xae, 0xe5, 0x0a, 0x0b, 0xe4, 0x94, 0xad, 0x3c, 0x30, 0xbe, 0x17, 0xef, 0x36,
0xb7, 0x5d, 0xd0, 0x71, 0xfc, 0x83, 0xd0, 0xc9, 0x85, 0x68, 0x84, 0x32, 0x6c, 0x46, 0xa7, 0xdf, 0x0b, 0x13, 0x47, 0xdf, 0x03, 0x31, 0x3c, 0x57, 0xb5, 0xb2, 0x14, 0xbe, 0x10, 0x8f, 0x1d, 0x5e,
0x5a, 0xdd, 0xb4, 0x2a, 0x33, 0x65, 0x0f, 0x3e, 0x09, 0xc9, 0x89, 0x97, 0x50, 0x27, 0xa5, 0x65, 0x40, 0x49, 0x59, 0x05, 0x75, 0xb6, 0x44, 0x07, 0x51, 0x30, 0x0e, 0x8e, 0xb7, 0xd2, 0xdd, 0x4e,
0x0f, 0xec, 0x25, 0x7d, 0x6a, 0xf5, 0x25, 0x54, 0x26, 0xab, 0xa1, 0xc9, 0x96, 0xda, 0x82, 0xff, 0x3e, 0x87, 0xfa, 0x13, 0x3a, 0x08, 0x9f, 0x8a, 0x2d, 0xab, 0x56, 0x0c, 0x50, 0xf4, 0x60, 0x1c,
0x20, 0x24, 0x27, 0x7b, 0xc9, 0x63, 0x27, 0x5f, 0x40, 0xf3, 0x49, 0x5b, 0x60, 0xcf, 0xe9, 0x9e, 0x1c, 0x0f, 0xd2, 0x47, 0x56, 0xad, 0x6e, 0x3c, 0x0a, 0x9f, 0x89, 0x1d, 0xa8, 0x50, 0xcf, 0xb3,
0x12, 0x2b, 0x34, 0x18, 0x7f, 0x8c, 0x31, 0x8f, 0x94, 0x58, 0x6d, 0x99, 0x61, 0x2f, 0xe8, 0x3e, 0x7c, 0x81, 0xfa, 0x82, 0xa2, 0x3e, 0xfb, 0xdb, 0xac, 0x4d, 0x58, 0x0a, 0x9f, 0x8b, 0x3d, 0x28,
0xd4, 0xba, 0x98, 0x67, 0xf9, 0x42, 0x17, 0x97, 0xc6, 0xf7, 0x90, 0x4f, 0x51, 0x8b, 0x51, 0x3a, 0x35, 0xce, 0x60, 0x96, 0xd1, 0xa2, 0xd0, 0x40, 0xd1, 0x80, 0xa1, 0x5d, 0xaf, 0x4e, 0x59, 0x3c,
0xfe, 0x43, 0xe8, 0xfe, 0x3b, 0xf7, 0x8c, 0xa9, 0x15, 0x16, 0xd8, 0x1b, 0x3a, 0xa9, 0xb1, 0x23, 0x6a, 0x03, 0xb1, 0xf3, 0xae, 0x5b, 0xe6, 0xd4, 0x29, 0x07, 0xe1, 0x6b, 0x31, 0xac, 0x38, 0x29,
0x96, 0x9a, 0x9e, 0xfb, 0xd1, 0xdd, 0x67, 0x8d, 0xdc, 0x1d, 0x62, 0xef, 0xea, 0xd7, 0x6c, 0x94, 0xc7, 0xda, 0x3e, 0x8b, 0x92, 0xbb, 0xcb, 0x4d, 0xba, 0x9f, 0x4c, 0x06, 0x57, 0x3f, 0x0f, 0x7b,
0x0c, 0xee, 0xdb, 0xb3, 0xaa, 0x56, 0xe5, 0xd0, 0x60, 0xdb, 0x9b, 0xb3, 0x3e, 0xa2, 0xc4, 0xce, 0xa9, 0xa7, 0x6f, 0x23, 0x95, 0x8d, 0xcd, 0xa1, 0xf6, 0x91, 0xbb, 0x48, 0x1f, 0x58, 0x0a, 0xcf,
0xe9, 0xc3, 0x21, 0xc5, 0x1f, 0x87, 0xe3, 0xfb, 0xb3, 0x53, 0x1c, 0x93, 0x1b, 0x23, 0xfb, 0x40, 0xc4, 0x43, 0x3f, 0x25, 0xea, 0x8f, 0xfb, 0xff, 0x9f, 0x3d, 0xe5, 0x67, 0xfa, 0x07, 0x0c, 0xdf,
0x0f, 0x86, 0x31, 0xcb, 0xbb, 0x0c, 0xd3, 0x7c, 0x0f, 0x37, 0x87, 0xbb, 0x9b, 0xdf, 0x6e, 0xb1, 0x88, 0xfd, 0xaf, 0x0d, 0xd6, 0x8d, 0xa5, 0x2c, 0x5f, 0x67, 0x3c, 0x2d, 0x1a, 0x70, 0xf3, 0xe8,
0x4b, 0x48, 0xc1, 0x26, 0x4f, 0x06, 0x14, 0x77, 0x08, 0xe2, 0xf7, 0x57, 0xeb, 0x80, 0x5c, 0xaf, 0x7e, 0xf3, 0xc7, 0x8e, 0x4c, 0xf7, 0x7c, 0xcb, 0x64, 0xfd, 0x96, 0x37, 0xf2, 0xfe, 0xaa, 0x8d,
0x03, 0xf2, 0x7b, 0x1d, 0x90, 0xef, 0x9b, 0x60, 0x74, 0xbd, 0x09, 0x46, 0x3f, 0x37, 0xc1, 0xe8, 0x83, 0xeb, 0x36, 0x0e, 0x7e, 0xb5, 0x71, 0xf0, 0x6d, 0x13, 0xf7, 0xae, 0x37, 0x71, 0xef, 0xc7,
0x33, 0x97, 0xa5, 0x9d, 0xb7, 0x79, 0x54, 0x68, 0xc5, 0x4f, 0xe5, 0x42, 0xe4, 0x86, 0x9f, 0xca, 0x26, 0xee, 0x7d, 0x96, 0xa6, 0x70, 0xf3, 0x26, 0x4f, 0x34, 0x5a, 0x79, 0x62, 0x16, 0x2a, 0x27,
0x57, 0xc5, 0x5c, 0x94, 0x15, 0x5f, 0xfd, 0xff, 0xa9, 0xb6, 0xab, 0xc1, 0xe4, 0x13, 0xfc, 0xd1, 0x79, 0x62, 0x5e, 0xea, 0xb9, 0x2a, 0x4a, 0xb9, 0xfa, 0xf7, 0xa6, 0x6e, 0x5d, 0x01, 0xe5, 0x43,
0xd7, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xd0, 0x84, 0xf4, 0xab, 0x94, 0x02, 0x00, 0x00, 0x3e, 0xe8, 0xab, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x46, 0x09, 0x1c, 0x6e, 0x93, 0x02, 0x00,
0x00,
} }
func (m *Params) Marshal() (dAtA []byte, err error) { func (m *Params) Marshal() (dAtA []byte, err error) {
@ -224,27 +225,27 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if m.EncodedSlices != 0 {
i = encodeVarintGenesis(dAtA, i, uint64(m.EncodedSlices))
i--
dAtA[i] = 0x20
}
if m.EpochBlocks != 0 { if m.EpochBlocks != 0 {
i = encodeVarintGenesis(dAtA, i, uint64(m.EpochBlocks)) i = encodeVarintGenesis(dAtA, i, uint64(m.EpochBlocks))
i-- i--
dAtA[i] = 0x20 dAtA[i] = 0x18
} }
if m.MaxVotes != 0 { if m.MaxVotes != 0 {
i = encodeVarintGenesis(dAtA, i, uint64(m.MaxVotes)) i = encodeVarintGenesis(dAtA, i, uint64(m.MaxVotes))
i-- i--
dAtA[i] = 0x18 dAtA[i] = 0x10
} }
if len(m.TokensPerVote) > 0 { if len(m.TokensPerVote) > 0 {
i -= len(m.TokensPerVote) i -= len(m.TokensPerVote)
copy(dAtA[i:], m.TokensPerVote) copy(dAtA[i:], m.TokensPerVote)
i = encodeVarintGenesis(dAtA, i, uint64(len(m.TokensPerVote))) i = encodeVarintGenesis(dAtA, i, uint64(len(m.TokensPerVote)))
i-- i--
dAtA[i] = 0x12 dAtA[i] = 0xa
}
if m.QuorumSize != 0 {
i = encodeVarintGenesis(dAtA, i, uint64(m.QuorumSize))
i--
dAtA[i] = 0x8
} }
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
@ -269,10 +270,10 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.SignersByEpoch) > 0 { if len(m.QuorumsByEpoch) > 0 {
for iNdEx := len(m.SignersByEpoch) - 1; iNdEx >= 0; iNdEx-- { for iNdEx := len(m.QuorumsByEpoch) - 1; iNdEx >= 0; iNdEx-- {
{ {
size, err := m.SignersByEpoch[iNdEx].MarshalToSizedBuffer(dAtA[:i]) size, err := m.QuorumsByEpoch[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -332,9 +333,6 @@ func (m *Params) Size() (n int) {
} }
var l int var l int
_ = l _ = l
if m.QuorumSize != 0 {
n += 1 + sovGenesis(uint64(m.QuorumSize))
}
l = len(m.TokensPerVote) l = len(m.TokensPerVote)
if l > 0 { if l > 0 {
n += 1 + l + sovGenesis(uint64(l)) n += 1 + l + sovGenesis(uint64(l))
@ -345,6 +343,9 @@ func (m *Params) Size() (n int) {
if m.EpochBlocks != 0 { if m.EpochBlocks != 0 {
n += 1 + sovGenesis(uint64(m.EpochBlocks)) n += 1 + sovGenesis(uint64(m.EpochBlocks))
} }
if m.EncodedSlices != 0 {
n += 1 + sovGenesis(uint64(m.EncodedSlices))
}
return n return n
} }
@ -365,8 +366,8 @@ func (m *GenesisState) Size() (n int) {
n += 1 + l + sovGenesis(uint64(l)) n += 1 + l + sovGenesis(uint64(l))
} }
} }
if len(m.SignersByEpoch) > 0 { if len(m.QuorumsByEpoch) > 0 {
for _, e := range m.SignersByEpoch { for _, e := range m.QuorumsByEpoch {
l = e.Size() l = e.Size()
n += 1 + l + sovGenesis(uint64(l)) n += 1 + l + sovGenesis(uint64(l))
} }
@ -410,25 +411,6 @@ func (m *Params) Unmarshal(dAtA []byte) error {
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field QuorumSize", wireType)
}
m.QuorumSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.QuorumSize |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TokensPerVote", wireType) return fmt.Errorf("proto: wrong wireType = %d for field TokensPerVote", wireType)
} }
@ -460,7 +442,7 @@ func (m *Params) Unmarshal(dAtA []byte) error {
} }
m.TokensPerVote = string(dAtA[iNdEx:postIndex]) m.TokensPerVote = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex iNdEx = postIndex
case 3: case 2:
if wireType != 0 { if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field MaxVotes", wireType) return fmt.Errorf("proto: wrong wireType = %d for field MaxVotes", wireType)
} }
@ -479,7 +461,7 @@ func (m *Params) Unmarshal(dAtA []byte) error {
break break
} }
} }
case 4: case 3:
if wireType != 0 { if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field EpochBlocks", wireType) return fmt.Errorf("proto: wrong wireType = %d for field EpochBlocks", wireType)
} }
@ -498,6 +480,25 @@ func (m *Params) Unmarshal(dAtA []byte) error {
break break
} }
} }
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field EncodedSlices", wireType)
}
m.EncodedSlices = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.EncodedSlices |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:]) skippy, err := skipGenesis(dAtA[iNdEx:])
@ -636,7 +637,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
iNdEx = postIndex iNdEx = postIndex
case 4: case 4:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SignersByEpoch", wireType) return fmt.Errorf("proto: wrong wireType = %d for field QuorumsByEpoch", wireType)
} }
var msglen int var msglen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
@ -663,8 +664,8 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.SignersByEpoch = append(m.SignersByEpoch, &EpochSignerSet{}) m.QuorumsByEpoch = append(m.QuorumsByEpoch, &Quorums{})
if err := m.SignersByEpoch[len(m.SignersByEpoch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { if err := m.QuorumsByEpoch[len(m.QuorumsByEpoch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex

9
x/dasigners/v1/types/keys.go
View File

@ -20,8 +20,9 @@ const (
var ( var (
// prefix // prefix
SignerKeyPrefix = []byte{0x00} SignerKeyPrefix = []byte{0x00}
EpochSignerSetKeyPrefix = []byte{0x01} EpochQuorumsKeyPrefix = []byte{0x01}
RegistrationKeyPrefix = []byte{0x02} RegistrationKeyPrefix = []byte{0x02}
QuorumCountKeyPrefix = []byte{0x03}
// keys // keys
ParamsKey = []byte{0x05} ParamsKey = []byte{0x05}
@ -32,7 +33,11 @@ func GetSignerKeyFromAccount(account string) ([]byte, error) {
return hex.DecodeString(account) return hex.DecodeString(account)
} }
func GetEpochSignerSetKeyFromEpoch(epoch uint64) []byte { func GetEpochQuorumsKeyFromEpoch(epoch uint64) []byte {
return sdk.Uint64ToBigEndian(epoch)
}
func GetQuorumCountKey(epoch uint64) []byte {
return sdk.Uint64ToBigEndian(epoch) return sdk.Uint64ToBigEndian(epoch)
} }

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

@ -33,7 +33,7 @@ var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type QuerySignerRequest struct { type QuerySignerRequest struct {
Account string `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` Accounts []string `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty"`
} }
func (m *QuerySignerRequest) Reset() { *m = QuerySignerRequest{} } func (m *QuerySignerRequest) Reset() { *m = QuerySignerRequest{} }
@ -70,7 +70,7 @@ func (m *QuerySignerRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_QuerySignerRequest proto.InternalMessageInfo var xxx_messageInfo_QuerySignerRequest proto.InternalMessageInfo
type QuerySignerResponse struct { type QuerySignerResponse struct {
Signer *Signer `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"` Signer []*Signer `protobuf:"bytes,1,rep,name=signer,proto3" json:"signer,omitempty"`
} }
func (m *QuerySignerResponse) Reset() { *m = QuerySignerResponse{} } func (m *QuerySignerResponse) Reset() { *m = QuerySignerResponse{} }
@ -179,22 +179,22 @@ func (m *QueryEpochNumberResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_QueryEpochNumberResponse proto.InternalMessageInfo var xxx_messageInfo_QueryEpochNumberResponse proto.InternalMessageInfo
type QueryEpochSignerSetRequest struct { type QueryQuorumCountRequest struct {
EpochNumber uint64 `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"` EpochNumber uint64 `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
} }
func (m *QueryEpochSignerSetRequest) Reset() { *m = QueryEpochSignerSetRequest{} } func (m *QueryQuorumCountRequest) Reset() { *m = QueryQuorumCountRequest{} }
func (m *QueryEpochSignerSetRequest) String() string { return proto.CompactTextString(m) } func (m *QueryQuorumCountRequest) String() string { return proto.CompactTextString(m) }
func (*QueryEpochSignerSetRequest) ProtoMessage() {} func (*QueryQuorumCountRequest) ProtoMessage() {}
func (*QueryEpochSignerSetRequest) Descriptor() ([]byte, []int) { func (*QueryQuorumCountRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{4} return fileDescriptor_991a610b84b5964c, []int{4}
} }
func (m *QueryEpochSignerSetRequest) XXX_Unmarshal(b []byte) error { func (m *QueryQuorumCountRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
} }
func (m *QueryEpochSignerSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *QueryQuorumCountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic { if deterministic {
return xxx_messageInfo_QueryEpochSignerSetRequest.Marshal(b, m, deterministic) return xxx_messageInfo_QueryQuorumCountRequest.Marshal(b, m, deterministic)
} else { } else {
b = b[:cap(b)] b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b) n, err := m.MarshalToSizedBuffer(b)
@ -204,34 +204,34 @@ func (m *QueryEpochSignerSetRequest) XXX_Marshal(b []byte, deterministic bool) (
return b[:n], nil return b[:n], nil
} }
} }
func (m *QueryEpochSignerSetRequest) XXX_Merge(src proto.Message) { func (m *QueryQuorumCountRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryEpochSignerSetRequest.Merge(m, src) xxx_messageInfo_QueryQuorumCountRequest.Merge(m, src)
} }
func (m *QueryEpochSignerSetRequest) XXX_Size() int { func (m *QueryQuorumCountRequest) XXX_Size() int {
return m.Size() return m.Size()
} }
func (m *QueryEpochSignerSetRequest) XXX_DiscardUnknown() { func (m *QueryQuorumCountRequest) XXX_DiscardUnknown() {
xxx_messageInfo_QueryEpochSignerSetRequest.DiscardUnknown(m) xxx_messageInfo_QueryQuorumCountRequest.DiscardUnknown(m)
} }
var xxx_messageInfo_QueryEpochSignerSetRequest proto.InternalMessageInfo var xxx_messageInfo_QueryQuorumCountRequest proto.InternalMessageInfo
type QueryEpochSignerSetResponse struct { type QueryQuorumCountResponse struct {
Signers []*Signer `protobuf:"bytes,1,rep,name=signers,proto3" json:"signers,omitempty"` QuorumCount uint64 `protobuf:"varint,1,opt,name=quorum_count,json=quorumCount,proto3" json:"quorum_count,omitempty"`
} }
func (m *QueryEpochSignerSetResponse) Reset() { *m = QueryEpochSignerSetResponse{} } func (m *QueryQuorumCountResponse) Reset() { *m = QueryQuorumCountResponse{} }
func (m *QueryEpochSignerSetResponse) String() string { return proto.CompactTextString(m) } func (m *QueryQuorumCountResponse) String() string { return proto.CompactTextString(m) }
func (*QueryEpochSignerSetResponse) ProtoMessage() {} func (*QueryQuorumCountResponse) ProtoMessage() {}
func (*QueryEpochSignerSetResponse) Descriptor() ([]byte, []int) { func (*QueryQuorumCountResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{5} return fileDescriptor_991a610b84b5964c, []int{5}
} }
func (m *QueryEpochSignerSetResponse) XXX_Unmarshal(b []byte) error { func (m *QueryQuorumCountResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
} }
func (m *QueryEpochSignerSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *QueryQuorumCountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic { if deterministic {
return xxx_messageInfo_QueryEpochSignerSetResponse.Marshal(b, m, deterministic) return xxx_messageInfo_QueryQuorumCountResponse.Marshal(b, m, deterministic)
} else { } else {
b = b[:cap(b)] b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b) n, err := m.MarshalToSizedBuffer(b)
@ -241,28 +241,104 @@ func (m *QueryEpochSignerSetResponse) XXX_Marshal(b []byte, deterministic bool)
return b[:n], nil return b[:n], nil
} }
} }
func (m *QueryEpochSignerSetResponse) XXX_Merge(src proto.Message) { func (m *QueryQuorumCountResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryEpochSignerSetResponse.Merge(m, src) xxx_messageInfo_QueryQuorumCountResponse.Merge(m, src)
} }
func (m *QueryEpochSignerSetResponse) XXX_Size() int { func (m *QueryQuorumCountResponse) XXX_Size() int {
return m.Size() return m.Size()
} }
func (m *QueryEpochSignerSetResponse) XXX_DiscardUnknown() { func (m *QueryQuorumCountResponse) XXX_DiscardUnknown() {
xxx_messageInfo_QueryEpochSignerSetResponse.DiscardUnknown(m) xxx_messageInfo_QueryQuorumCountResponse.DiscardUnknown(m)
} }
var xxx_messageInfo_QueryEpochSignerSetResponse proto.InternalMessageInfo var xxx_messageInfo_QueryQuorumCountResponse proto.InternalMessageInfo
type QueryEpochQuorumRequest struct {
EpochNumber uint64 `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
QuorumId uint64 `protobuf:"varint,2,opt,name=quorum_id,json=quorumId,proto3" json:"quorum_id,omitempty"`
}
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}
}
func (m *QueryEpochQuorumRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryEpochQuorumRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryEpochQuorumRequest.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 *QueryEpochQuorumRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryEpochQuorumRequest.Merge(m, src)
}
func (m *QueryEpochQuorumRequest) XXX_Size() int {
return m.Size()
}
func (m *QueryEpochQuorumRequest) XXX_DiscardUnknown() {
xxx_messageInfo_QueryEpochQuorumRequest.DiscardUnknown(m)
}
var xxx_messageInfo_QueryEpochQuorumRequest proto.InternalMessageInfo
type QueryEpochQuorumResponse struct {
Quorum *Quorum `protobuf:"bytes,1,opt,name=quorum,proto3" json:"quorum,omitempty"`
}
func (m *QueryEpochQuorumResponse) Reset() { *m = QueryEpochQuorumResponse{} }
func (m *QueryEpochQuorumResponse) String() string { return proto.CompactTextString(m) }
func (*QueryEpochQuorumResponse) ProtoMessage() {}
func (*QueryEpochQuorumResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{7}
}
func (m *QueryEpochQuorumResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryEpochQuorumResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryEpochQuorumResponse.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 *QueryEpochQuorumResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryEpochQuorumResponse.Merge(m, src)
}
func (m *QueryEpochQuorumResponse) XXX_Size() int {
return m.Size()
}
func (m *QueryEpochQuorumResponse) XXX_DiscardUnknown() {
xxx_messageInfo_QueryEpochQuorumResponse.DiscardUnknown(m)
}
var xxx_messageInfo_QueryEpochQuorumResponse proto.InternalMessageInfo
type QueryAggregatePubkeyG1Request struct { type QueryAggregatePubkeyG1Request struct {
EpochNumber uint64 `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"` EpochNumber uint64 `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
SignersBitmap []byte `protobuf:"bytes,2,opt,name=signersBitmap,proto3" json:"signersBitmap,omitempty"` QuorumId uint64 `protobuf:"varint,2,opt,name=quorum_id,json=quorumId,proto3" json:"quorum_id,omitempty"`
QuorumBitmap []byte `protobuf:"bytes,3,opt,name=quorum_bitmap,json=quorumBitmap,proto3" json:"quorum_bitmap,omitempty"`
} }
func (m *QueryAggregatePubkeyG1Request) Reset() { *m = QueryAggregatePubkeyG1Request{} } func (m *QueryAggregatePubkeyG1Request) Reset() { *m = QueryAggregatePubkeyG1Request{} }
func (m *QueryAggregatePubkeyG1Request) String() string { return proto.CompactTextString(m) } func (m *QueryAggregatePubkeyG1Request) String() string { return proto.CompactTextString(m) }
func (*QueryAggregatePubkeyG1Request) ProtoMessage() {} func (*QueryAggregatePubkeyG1Request) ProtoMessage() {}
func (*QueryAggregatePubkeyG1Request) Descriptor() ([]byte, []int) { func (*QueryAggregatePubkeyG1Request) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{6} return fileDescriptor_991a610b84b5964c, []int{8}
} }
func (m *QueryAggregatePubkeyG1Request) XXX_Unmarshal(b []byte) error { func (m *QueryAggregatePubkeyG1Request) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -301,7 +377,7 @@ func (m *QueryAggregatePubkeyG1Response) Reset() { *m = QueryAggregatePu
func (m *QueryAggregatePubkeyG1Response) String() string { return proto.CompactTextString(m) } func (m *QueryAggregatePubkeyG1Response) String() string { return proto.CompactTextString(m) }
func (*QueryAggregatePubkeyG1Response) ProtoMessage() {} func (*QueryAggregatePubkeyG1Response) ProtoMessage() {}
func (*QueryAggregatePubkeyG1Response) Descriptor() ([]byte, []int) { func (*QueryAggregatePubkeyG1Response) Descriptor() ([]byte, []int) {
return fileDescriptor_991a610b84b5964c, []int{7} return fileDescriptor_991a610b84b5964c, []int{9}
} }
func (m *QueryAggregatePubkeyG1Response) XXX_Unmarshal(b []byte) error { func (m *QueryAggregatePubkeyG1Response) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -335,8 +411,10 @@ func init() {
proto.RegisterType((*QuerySignerResponse)(nil), "zgc.dasigners.v1.QuerySignerResponse") proto.RegisterType((*QuerySignerResponse)(nil), "zgc.dasigners.v1.QuerySignerResponse")
proto.RegisterType((*QueryEpochNumberRequest)(nil), "zgc.dasigners.v1.QueryEpochNumberRequest") proto.RegisterType((*QueryEpochNumberRequest)(nil), "zgc.dasigners.v1.QueryEpochNumberRequest")
proto.RegisterType((*QueryEpochNumberResponse)(nil), "zgc.dasigners.v1.QueryEpochNumberResponse") proto.RegisterType((*QueryEpochNumberResponse)(nil), "zgc.dasigners.v1.QueryEpochNumberResponse")
proto.RegisterType((*QueryEpochSignerSetRequest)(nil), "zgc.dasigners.v1.QueryEpochSignerSetRequest") proto.RegisterType((*QueryQuorumCountRequest)(nil), "zgc.dasigners.v1.QueryQuorumCountRequest")
proto.RegisterType((*QueryEpochSignerSetResponse)(nil), "zgc.dasigners.v1.QueryEpochSignerSetResponse") proto.RegisterType((*QueryQuorumCountResponse)(nil), "zgc.dasigners.v1.QueryQuorumCountResponse")
proto.RegisterType((*QueryEpochQuorumRequest)(nil), "zgc.dasigners.v1.QueryEpochQuorumRequest")
proto.RegisterType((*QueryEpochQuorumResponse)(nil), "zgc.dasigners.v1.QueryEpochQuorumResponse")
proto.RegisterType((*QueryAggregatePubkeyG1Request)(nil), "zgc.dasigners.v1.QueryAggregatePubkeyG1Request") proto.RegisterType((*QueryAggregatePubkeyG1Request)(nil), "zgc.dasigners.v1.QueryAggregatePubkeyG1Request")
proto.RegisterType((*QueryAggregatePubkeyG1Response)(nil), "zgc.dasigners.v1.QueryAggregatePubkeyG1Response") proto.RegisterType((*QueryAggregatePubkeyG1Response)(nil), "zgc.dasigners.v1.QueryAggregatePubkeyG1Response")
} }
@ -344,45 +422,49 @@ func init() {
func init() { proto.RegisterFile("zgc/dasigners/v1/query.proto", fileDescriptor_991a610b84b5964c) } func init() { proto.RegisterFile("zgc/dasigners/v1/query.proto", fileDescriptor_991a610b84b5964c) }
var fileDescriptor_991a610b84b5964c = []byte{ var fileDescriptor_991a610b84b5964c = []byte{
// 600 bytes of a gzipped FileDescriptorProto // 658 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4f, 0x6f, 0xd3, 0x4e, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x4f, 0x4f, 0xd4, 0x4e,
0x10, 0x8d, 0xfb, 0x57, 0xbf, 0x6d, 0x7e, 0xa8, 0xdd, 0x56, 0xaa, 0x63, 0x5a, 0x27, 0x35, 0x29, 0x18, 0xde, 0xf2, 0x2f, 0x30, 0xf0, 0x4b, 0x60, 0x20, 0xa1, 0xdb, 0x1f, 0x94, 0xb5, 0x82, 0x41,
0x6a, 0x51, 0xed, 0x4d, 0xc2, 0x19, 0x21, 0x2a, 0xa1, 0x9e, 0x40, 0xd4, 0xbd, 0x71, 0x89, 0xd6, 0xe3, 0x76, 0xba, 0x78, 0xd5, 0x83, 0x18, 0x43, 0x4c, 0xd4, 0x48, 0x3d, 0xe9, 0x65, 0x33, 0x2d,
0x66, 0xd9, 0x58, 0xc4, 0x5e, 0x37, 0x5e, 0x47, 0x4d, 0x8f, 0x5c, 0xb9, 0x20, 0x71, 0xe1, 0x03, 0xe3, 0x6c, 0x23, 0xed, 0x74, 0xb7, 0x53, 0x02, 0x1c, 0x8d, 0x37, 0x2f, 0x26, 0x7e, 0x05, 0x3f,
0xf0, 0x61, 0x7a, 0xa3, 0x12, 0x17, 0x8e, 0x90, 0xf0, 0x41, 0x50, 0x76, 0x37, 0x09, 0x8e, 0x71, 0x0c, 0x47, 0x12, 0x2f, 0x1e, 0x15, 0xfc, 0x20, 0x66, 0x67, 0xa6, 0xdb, 0x2d, 0xdd, 0x2e, 0x7b,
0xc9, 0x6d, 0xf7, 0xcd, 0x9b, 0x79, 0x6f, 0x76, 0x46, 0x0b, 0xf6, 0xae, 0xa9, 0x8f, 0xde, 0xe0, 0xf0, 0x36, 0xf3, 0xbe, 0xef, 0xf3, 0x3e, 0xcf, 0x3c, 0x3c, 0x74, 0xc1, 0xc6, 0x39, 0xf5, 0xd1,
0x24, 0xa0, 0x11, 0xe9, 0x25, 0xa8, 0xdf, 0x44, 0x97, 0x29, 0xe9, 0x0d, 0x9c, 0xb8, 0xc7, 0x38, 0x11, 0x4e, 0x02, 0x1a, 0x91, 0x5e, 0x82, 0x4e, 0x5a, 0xa8, 0x9b, 0x92, 0xde, 0x99, 0x1d, 0xf7,
0x83, 0x9b, 0xd7, 0xd4, 0x77, 0xa6, 0x51, 0xa7, 0xdf, 0x34, 0x2a, 0x3e, 0x4b, 0x42, 0x96, 0xb4, 0x18, 0x67, 0x70, 0xf9, 0x9c, 0xfa, 0xf6, 0xa0, 0x6b, 0x9f, 0xb4, 0x8c, 0xba, 0xcf, 0x92, 0x90,
0x45, 0x1c, 0xc9, 0x8b, 0x24, 0x1b, 0x3b, 0x94, 0x51, 0x26, 0xf1, 0xf1, 0x49, 0xa1, 0x7b, 0x94, 0x25, 0x6d, 0xd1, 0x47, 0xf2, 0x22, 0x87, 0x8d, 0x35, 0xca, 0x28, 0x93, 0xf5, 0xfe, 0x49, 0x55,
0x31, 0xda, 0x25, 0x08, 0xc7, 0x01, 0xc2, 0x51, 0xc4, 0x38, 0xe6, 0x01, 0x8b, 0x26, 0x39, 0x15, 0x37, 0x28, 0x63, 0xf4, 0x98, 0x20, 0x1c, 0x07, 0x08, 0x47, 0x11, 0xe3, 0x98, 0x07, 0x2c, 0xca,
0x15, 0x15, 0x37, 0x2f, 0x7d, 0x8b, 0x70, 0xa4, 0xb4, 0x8d, 0xea, 0x7c, 0x88, 0x07, 0x21, 0x49, 0x30, 0x75, 0xd5, 0x15, 0x37, 0x2f, 0xfd, 0x80, 0x70, 0xa4, 0xb8, 0x8d, 0xad, 0x9b, 0x2d, 0x1e,
0x38, 0x0e, 0x63, 0x45, 0xa8, 0xe5, 0xac, 0xcf, 0x9c, 0x0a, 0x86, 0xe5, 0x00, 0x78, 0x3e, 0xee, 0x84, 0x24, 0xe1, 0x38, 0x8c, 0xd5, 0x40, 0xa3, 0x24, 0x3d, 0x57, 0x2a, 0x26, 0x2c, 0x07, 0xc0,
0xe6, 0x42, 0xa0, 0x2e, 0xb9, 0x4c, 0x49, 0xc2, 0xa1, 0x0e, 0xd6, 0xb1, 0xef, 0xb3, 0x34, 0xe2, 0xc3, 0xfe, 0x6b, 0xde, 0x8a, 0xaa, 0x4b, 0xba, 0x29, 0x49, 0x38, 0x34, 0xc0, 0x3c, 0xf6, 0x7d,
0xba, 0x56, 0xd3, 0x8e, 0xfe, 0x73, 0x27, 0x57, 0xeb, 0x0c, 0x6c, 0x67, 0xf8, 0x49, 0xcc, 0xa2, 0x96, 0x46, 0x3c, 0xd1, 0xb5, 0xc6, 0xf4, 0xee, 0x82, 0x3b, 0xb8, 0x5b, 0x07, 0x60, 0xb5, 0x80,
0x84, 0xc0, 0x06, 0x58, 0x93, 0x75, 0x05, 0x7f, 0xa3, 0xa5, 0x3b, 0xf3, 0xcf, 0xe2, 0xa8, 0x0c, 0x48, 0x62, 0x16, 0x25, 0x04, 0x3a, 0x60, 0x4e, 0x6e, 0x16, 0x80, 0xc5, 0x3d, 0xdd, 0xbe, 0x69,
0xc5, 0xb3, 0x2a, 0x60, 0x57, 0x14, 0x7a, 0x1e, 0x33, 0xbf, 0xf3, 0x32, 0x0d, 0xbd, 0xa9, 0xba, 0x8c, 0xad, 0x10, 0x6a, 0xce, 0xaa, 0x83, 0x75, 0xb1, 0xe8, 0x79, 0xcc, 0xfc, 0xce, 0xeb, 0x34,
0xf5, 0x04, 0xe8, 0xf9, 0x90, 0x12, 0x3a, 0x00, 0x65, 0x32, 0x86, 0xdb, 0x91, 0xc0, 0x85, 0xdc, 0xf4, 0x06, 0xfc, 0xd6, 0x13, 0xa0, 0x97, 0x5b, 0x8a, 0xe8, 0x0e, 0x58, 0x22, 0xfd, 0x72, 0x3b,
0x8a, 0xbb, 0x41, 0x66, 0x54, 0xeb, 0x29, 0x30, 0x66, 0xe9, 0x52, 0xf5, 0x82, 0xf0, 0x49, 0x6b, 0x12, 0x75, 0x5d, 0x6b, 0x68, 0xbb, 0x33, 0xee, 0x22, 0xc9, 0x47, 0xad, 0xc7, 0x6a, 0xf3, 0x61,
0x0b, 0x14, 0x38, 0x07, 0xf7, 0xff, 0x5a, 0x40, 0x59, 0x68, 0x81, 0x75, 0xd5, 0x96, 0xae, 0xd5, 0xca, 0x7a, 0x69, 0xf8, 0xac, 0xaf, 0x3b, 0x7b, 0xd9, 0x04, 0xe8, 0x8c, 0xbc, 0x80, 0xce, 0xc9,
0x96, 0xef, 0x6c, 0x76, 0x42, 0xb4, 0x3a, 0x60, 0x5f, 0x94, 0x7c, 0x46, 0x69, 0x8f, 0x50, 0xcc, 0xbb, 0xa2, 0xdc, 0x16, 0x6e, 0x64, 0xf0, 0x6e, 0x3e, 0x6a, 0xbd, 0x1b, 0x7e, 0x96, 0xdc, 0x31,
0xc9, 0xab, 0xd4, 0x7b, 0x47, 0x06, 0x67, 0xcd, 0xc5, 0x6d, 0xc1, 0x3a, 0xf8, 0x5f, 0x95, 0x3b, 0x39, 0x39, 0xfc, 0x1f, 0x2c, 0x28, 0x82, 0xe0, 0x48, 0x9f, 0x12, 0xfd, 0x79, 0x59, 0x78, 0x71,
0x0d, 0x78, 0x88, 0x63, 0x7d, 0xa9, 0xa6, 0x1d, 0x95, 0xdd, 0x2c, 0x68, 0x5d, 0x01, 0xb3, 0x48, 0x64, 0xbd, 0x1c, 0xb6, 0x25, 0x5b, 0x9d, 0xfb, 0x2f, 0xe7, 0xc4, 0xd6, 0x91, 0xfe, 0x2b, 0x84,
0x49, 0xf9, 0x77, 0xc0, 0x36, 0x9e, 0x04, 0xdb, 0xb1, 0x88, 0xb6, 0x69, 0x53, 0x28, 0x96, 0xdd, 0x9a, 0xb3, 0x3e, 0x6b, 0x60, 0x53, 0xac, 0x7b, 0x4a, 0x69, 0x8f, 0x50, 0xcc, 0xc9, 0x9b, 0xd4,
0x2d, 0x3c, 0x9f, 0x07, 0x77, 0xc0, 0x2a, 0x67, 0x1c, 0x77, 0x85, 0xde, 0x8a, 0x2b, 0x2f, 0x70, 0xfb, 0x48, 0xce, 0x0e, 0x5a, 0xff, 0x48, 0x2f, 0xbc, 0x0b, 0xfe, 0x53, 0x4d, 0x2f, 0xe0, 0x21,
0x13, 0x2c, 0x77, 0x02, 0xae, 0x2f, 0x0b, 0x6c, 0x7c, 0x6c, 0x7d, 0x5d, 0x01, 0xab, 0x42, 0x1a, 0x8e, 0xf5, 0xe9, 0x86, 0xb6, 0xbb, 0xe4, 0x2a, 0x0b, 0xf7, 0x45, 0xcd, 0x3a, 0x05, 0x66, 0x95,
0x7e, 0xd0, 0xc0, 0xc6, 0x1f, 0xc3, 0x83, 0xc7, 0xf9, 0x07, 0x2a, 0x98, 0xbd, 0xf1, 0x68, 0x11, 0x0a, 0xf5, 0x34, 0x1b, 0xac, 0xe2, 0xac, 0xd9, 0x8e, 0x45, 0xb7, 0x4d, 0x5b, 0x42, 0xcd, 0x92,
0xaa, 0x6c, 0xc4, 0x3a, 0x7c, 0xff, 0xed, 0xd7, 0xa7, 0xa5, 0x2a, 0xdc, 0x47, 0x0d, 0x9a, 0xdd, 0xbb, 0x82, 0x6f, 0xe2, 0xe0, 0x1a, 0x98, 0xe5, 0x8c, 0xe3, 0x63, 0xa5, 0x47, 0x5e, 0xe0, 0x32,
0x72, 0xf1, 0x6c, 0xb6, 0x7c, 0x4a, 0xf8, 0x59, 0x03, 0xf7, 0xb2, 0xa3, 0x84, 0x27, 0x77, 0xa9, 0x98, 0xee, 0x04, 0x5c, 0x48, 0x98, 0x71, 0xfb, 0xc7, 0xbd, 0xcb, 0x59, 0x30, 0x2b, 0xa8, 0xe1,
0xcc, 0xaf, 0x8c, 0x61, 0x2f, 0xc8, 0x56, 0xb6, 0x8e, 0x85, 0xad, 0x07, 0xf0, 0xa0, 0xc0, 0x96, 0x17, 0x0d, 0x2c, 0x0e, 0x65, 0x0d, 0xde, 0x1f, 0x65, 0xde, 0xc8, 0xa8, 0x1a, 0x0f, 0x26, 0x19,
0x04, 0xec, 0x84, 0x70, 0xf8, 0x45, 0x03, 0x5b, 0xb9, 0x41, 0x41, 0x54, 0xa0, 0x57, 0xb4, 0x3c, 0x95, 0x0f, 0xb1, 0x76, 0x3e, 0xfd, 0xf8, 0xf3, 0x6d, 0x6a, 0x0b, 0x6e, 0x22, 0x87, 0x16, 0xff,
0x46, 0x63, 0xf1, 0x04, 0xe5, 0xf1, 0x44, 0x78, 0x7c, 0x08, 0xeb, 0x39, 0x8f, 0xd3, 0xf9, 0xdb, 0x2d, 0x85, 0xa5, 0x4d, 0x69, 0xb3, 0x50, 0x33, 0x14, 0xbe, 0x4a, 0x35, 0xe5, 0x78, 0x57, 0xaa,
0x72, 0x35, 0x6c, 0xda, 0x84, 0x7d, 0xb0, 0x26, 0xdb, 0x84, 0xf5, 0x02, 0xa5, 0xcc, 0xf7, 0x61, 0x19, 0x91, 0xe5, 0x31, 0x6a, 0xe4, 0xdf, 0xa7, 0x29, 0x22, 0x9e, 0x7b, 0x23, 0x77, 0x8c, 0xf7,
0x1c, 0xfe, 0x83, 0xa5, 0x4c, 0x54, 0x85, 0x89, 0x0a, 0xdc, 0xcd, 0x99, 0x90, 0xc7, 0xd3, 0x17, 0xa6, 0x90, 0xf7, 0xf1, 0xde, 0x14, 0xf3, 0x7b, 0xab, 0x37, 0x52, 0x13, 0xfc, 0xae, 0x81, 0x95,
0x37, 0x3f, 0xcd, 0xd2, 0xcd, 0xd0, 0xd4, 0x6e, 0x87, 0xa6, 0xf6, 0x63, 0x68, 0x6a, 0x1f, 0x47, 0x52, 0x52, 0x20, 0xaa, 0x20, 0xaa, 0x4a, 0xb6, 0xe1, 0x4c, 0x0e, 0x50, 0xfa, 0x1e, 0x0a, 0x7d,
0x66, 0xe9, 0x76, 0x64, 0x96, 0xbe, 0x8f, 0xcc, 0xd2, 0x6b, 0x44, 0x03, 0xde, 0x49, 0x3d, 0xc7, 0xf7, 0xe0, 0x76, 0x49, 0xdf, 0x20, 0x80, 0x4d, 0x99, 0xcd, 0x26, 0x6d, 0xc1, 0x13, 0x30, 0x27,
0x67, 0x21, 0x6a, 0xd0, 0x2e, 0xf6, 0x12, 0xd4, 0xa0, 0xb6, 0xdf, 0xc1, 0x41, 0x84, 0xae, 0xb2, 0xbf, 0x76, 0x70, 0xbb, 0x82, 0xa9, 0xf0, 0xc1, 0x35, 0x76, 0x6e, 0x99, 0x52, 0x22, 0xb6, 0x84,
0xf5, 0xf8, 0x20, 0x26, 0x89, 0xb7, 0x26, 0xbe, 0xbc, 0xc7, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x88, 0x3a, 0x5c, 0x2f, 0x89, 0x90, 0xc7, 0xfd, 0x57, 0x17, 0xbf, 0xcd, 0xda, 0xc5, 0x95, 0xa9,
0x9b, 0xb2, 0x92, 0x94, 0xd1, 0x05, 0x00, 0x00, 0x5d, 0x5e, 0x99, 0xda, 0xaf, 0x2b, 0x53, 0xfb, 0x7a, 0x6d, 0xd6, 0x2e, 0xaf, 0xcd, 0xda, 0xcf,
0x6b, 0xb3, 0xf6, 0x1e, 0xd1, 0x80, 0x77, 0x52, 0xcf, 0xf6, 0x59, 0x88, 0x1c, 0x7a, 0x8c, 0xbd,
0x04, 0x39, 0xb4, 0xe9, 0x77, 0x70, 0x10, 0xa1, 0xd3, 0xe2, 0x3e, 0x7e, 0x16, 0x93, 0xc4, 0x9b,
0x13, 0x3f, 0x12, 0x8f, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x8c, 0xd5, 0xcf, 0x03, 0x07,
0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -398,7 +480,8 @@ 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. // 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 { type QueryClient interface {
EpochNumber(ctx context.Context, in *QueryEpochNumberRequest, opts ...grpc.CallOption) (*QueryEpochNumberResponse, error) EpochNumber(ctx context.Context, in *QueryEpochNumberRequest, opts ...grpc.CallOption) (*QueryEpochNumberResponse, error)
EpochSignerSet(ctx context.Context, in *QueryEpochSignerSetRequest, opts ...grpc.CallOption) (*QueryEpochSignerSetResponse, error) QuorumCount(ctx context.Context, in *QueryQuorumCountRequest, opts ...grpc.CallOption) (*QueryQuorumCountResponse, error)
EpochQuorum(ctx context.Context, in *QueryEpochQuorumRequest, opts ...grpc.CallOption) (*QueryEpochQuorumResponse, error)
AggregatePubkeyG1(ctx context.Context, in *QueryAggregatePubkeyG1Request, opts ...grpc.CallOption) (*QueryAggregatePubkeyG1Response, error) AggregatePubkeyG1(ctx context.Context, in *QueryAggregatePubkeyG1Request, opts ...grpc.CallOption) (*QueryAggregatePubkeyG1Response, error)
Signer(ctx context.Context, in *QuerySignerRequest, opts ...grpc.CallOption) (*QuerySignerResponse, error) Signer(ctx context.Context, in *QuerySignerRequest, opts ...grpc.CallOption) (*QuerySignerResponse, error)
} }
@ -420,9 +503,18 @@ func (c *queryClient) EpochNumber(ctx context.Context, in *QueryEpochNumberReque
return out, nil return out, nil
} }
func (c *queryClient) EpochSignerSet(ctx context.Context, in *QueryEpochSignerSetRequest, opts ...grpc.CallOption) (*QueryEpochSignerSetResponse, error) { func (c *queryClient) QuorumCount(ctx context.Context, in *QueryQuorumCountRequest, opts ...grpc.CallOption) (*QueryQuorumCountResponse, error) {
out := new(QueryEpochSignerSetResponse) out := new(QueryQuorumCountResponse)
err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Query/EpochSignerSet", in, out, opts...) err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Query/QuorumCount", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *queryClient) EpochQuorum(ctx context.Context, in *QueryEpochQuorumRequest, opts ...grpc.CallOption) (*QueryEpochQuorumResponse, error) {
out := new(QueryEpochQuorumResponse)
err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Query/EpochQuorum", in, out, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -450,7 +542,8 @@ func (c *queryClient) Signer(ctx context.Context, in *QuerySignerRequest, opts .
// QueryServer is the server API for Query service. // QueryServer is the server API for Query service.
type QueryServer interface { type QueryServer interface {
EpochNumber(context.Context, *QueryEpochNumberRequest) (*QueryEpochNumberResponse, error) EpochNumber(context.Context, *QueryEpochNumberRequest) (*QueryEpochNumberResponse, error)
EpochSignerSet(context.Context, *QueryEpochSignerSetRequest) (*QueryEpochSignerSetResponse, error) QuorumCount(context.Context, *QueryQuorumCountRequest) (*QueryQuorumCountResponse, error)
EpochQuorum(context.Context, *QueryEpochQuorumRequest) (*QueryEpochQuorumResponse, error)
AggregatePubkeyG1(context.Context, *QueryAggregatePubkeyG1Request) (*QueryAggregatePubkeyG1Response, error) AggregatePubkeyG1(context.Context, *QueryAggregatePubkeyG1Request) (*QueryAggregatePubkeyG1Response, error)
Signer(context.Context, *QuerySignerRequest) (*QuerySignerResponse, error) Signer(context.Context, *QuerySignerRequest) (*QuerySignerResponse, error)
} }
@ -462,8 +555,11 @@ type UnimplementedQueryServer struct {
func (*UnimplementedQueryServer) EpochNumber(ctx context.Context, req *QueryEpochNumberRequest) (*QueryEpochNumberResponse, error) { func (*UnimplementedQueryServer) EpochNumber(ctx context.Context, req *QueryEpochNumberRequest) (*QueryEpochNumberResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method EpochNumber not implemented") return nil, status.Errorf(codes.Unimplemented, "method EpochNumber not implemented")
} }
func (*UnimplementedQueryServer) EpochSignerSet(ctx context.Context, req *QueryEpochSignerSetRequest) (*QueryEpochSignerSetResponse, error) { func (*UnimplementedQueryServer) QuorumCount(ctx context.Context, req *QueryQuorumCountRequest) (*QueryQuorumCountResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method EpochSignerSet not implemented") return nil, status.Errorf(codes.Unimplemented, "method QuorumCount not implemented")
}
func (*UnimplementedQueryServer) EpochQuorum(ctx context.Context, req *QueryEpochQuorumRequest) (*QueryEpochQuorumResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method EpochQuorum not implemented")
} }
func (*UnimplementedQueryServer) AggregatePubkeyG1(ctx context.Context, req *QueryAggregatePubkeyG1Request) (*QueryAggregatePubkeyG1Response, error) { func (*UnimplementedQueryServer) AggregatePubkeyG1(ctx context.Context, req *QueryAggregatePubkeyG1Request) (*QueryAggregatePubkeyG1Response, error) {
return nil, status.Errorf(codes.Unimplemented, "method AggregatePubkeyG1 not implemented") return nil, status.Errorf(codes.Unimplemented, "method AggregatePubkeyG1 not implemented")
@ -494,20 +590,38 @@ func _Query_EpochNumber_Handler(srv interface{}, ctx context.Context, dec func(i
return interceptor(ctx, in, info, handler) return interceptor(ctx, in, info, handler)
} }
func _Query_EpochSignerSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { func _Query_QuorumCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryEpochSignerSetRequest) in := new(QueryQuorumCountRequest)
if err := dec(in); err != nil { if err := dec(in); err != nil {
return nil, err return nil, err
} }
if interceptor == nil { if interceptor == nil {
return srv.(QueryServer).EpochSignerSet(ctx, in) return srv.(QueryServer).QuorumCount(ctx, in)
} }
info := &grpc.UnaryServerInfo{ info := &grpc.UnaryServerInfo{
Server: srv, Server: srv,
FullMethod: "/zgc.dasigners.v1.Query/EpochSignerSet", FullMethod: "/zgc.dasigners.v1.Query/QuorumCount",
} }
handler := func(ctx context.Context, req interface{}) (interface{}, error) { handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryServer).EpochSignerSet(ctx, req.(*QueryEpochSignerSetRequest)) return srv.(QueryServer).QuorumCount(ctx, req.(*QueryQuorumCountRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Query_EpochQuorum_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryEpochQuorumRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryServer).EpochQuorum(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/zgc.dasigners.v1.Query/EpochQuorum",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryServer).EpochQuorum(ctx, req.(*QueryEpochQuorumRequest))
} }
return interceptor(ctx, in, info, handler) return interceptor(ctx, in, info, handler)
} }
@ -557,8 +671,12 @@ var _Query_serviceDesc = grpc.ServiceDesc{
Handler: _Query_EpochNumber_Handler, Handler: _Query_EpochNumber_Handler,
}, },
{ {
MethodName: "EpochSignerSet", MethodName: "QuorumCount",
Handler: _Query_EpochSignerSet_Handler, Handler: _Query_QuorumCount_Handler,
},
{
MethodName: "EpochQuorum",
Handler: _Query_EpochQuorum_Handler,
}, },
{ {
MethodName: "AggregatePubkeyG1", MethodName: "AggregatePubkeyG1",
@ -593,13 +711,15 @@ func (m *QuerySignerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.Account) > 0 { if len(m.Accounts) > 0 {
i -= len(m.Account) for iNdEx := len(m.Accounts) - 1; iNdEx >= 0; iNdEx-- {
copy(dAtA[i:], m.Account) i -= len(m.Accounts[iNdEx])
i = encodeVarintQuery(dAtA, i, uint64(len(m.Account))) copy(dAtA[i:], m.Accounts[iNdEx])
i = encodeVarintQuery(dAtA, i, uint64(len(m.Accounts[iNdEx])))
i-- i--
dAtA[i] = 0xa dAtA[i] = 0xa
} }
}
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
@ -623,9 +743,10 @@ func (m *QuerySignerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if m.Signer != nil { if len(m.Signer) > 0 {
for iNdEx := len(m.Signer) - 1; iNdEx >= 0; iNdEx-- {
{ {
size, err := m.Signer.MarshalToSizedBuffer(dAtA[:i]) size, err := m.Signer[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -635,6 +756,7 @@ func (m *QuerySignerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i-- i--
dAtA[i] = 0xa dAtA[i] = 0xa
} }
}
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
@ -689,7 +811,7 @@ func (m *QueryEpochNumberResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *QueryEpochSignerSetRequest) Marshal() (dAtA []byte, err error) { func (m *QueryQuorumCountRequest) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size]) n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -699,12 +821,12 @@ func (m *QueryEpochSignerSetRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *QueryEpochSignerSetRequest) MarshalTo(dAtA []byte) (int, error) { func (m *QueryQuorumCountRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size() size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size]) return m.MarshalToSizedBuffer(dAtA[:size])
} }
func (m *QueryEpochSignerSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { func (m *QueryQuorumCountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA) i := len(dAtA)
_ = i _ = i
var l int var l int
@ -717,7 +839,7 @@ func (m *QueryEpochSignerSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, err
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *QueryEpochSignerSetResponse) Marshal() (dAtA []byte, err error) { func (m *QueryQuorumCountResponse) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size]) n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -727,20 +849,80 @@ func (m *QueryEpochSignerSetResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *QueryEpochSignerSetResponse) MarshalTo(dAtA []byte) (int, error) { func (m *QueryQuorumCountResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size() size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size]) return m.MarshalToSizedBuffer(dAtA[:size])
} }
func (m *QueryEpochSignerSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { func (m *QueryQuorumCountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA) i := len(dAtA)
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.Signers) > 0 { if m.QuorumCount != 0 {
for iNdEx := len(m.Signers) - 1; iNdEx >= 0; iNdEx-- { i = encodeVarintQuery(dAtA, i, uint64(m.QuorumCount))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *QueryEpochQuorumRequest) 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 *QueryEpochQuorumRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryEpochQuorumRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.QuorumId != 0 {
i = encodeVarintQuery(dAtA, i, uint64(m.QuorumId))
i--
dAtA[i] = 0x10
}
if m.EpochNumber != 0 {
i = encodeVarintQuery(dAtA, i, uint64(m.EpochNumber))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *QueryEpochQuorumResponse) 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 *QueryEpochQuorumResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryEpochQuorumResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Quorum != nil {
{ {
size, err := m.Signers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) size, err := m.Quorum.MarshalToSizedBuffer(dAtA[:i])
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -750,7 +932,6 @@ func (m *QueryEpochSignerSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, er
i-- i--
dAtA[i] = 0xa dAtA[i] = 0xa
} }
}
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
@ -774,12 +955,17 @@ func (m *QueryAggregatePubkeyG1Request) MarshalToSizedBuffer(dAtA []byte) (int,
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.SignersBitmap) > 0 { if len(m.QuorumBitmap) > 0 {
i -= len(m.SignersBitmap) i -= len(m.QuorumBitmap)
copy(dAtA[i:], m.SignersBitmap) copy(dAtA[i:], m.QuorumBitmap)
i = encodeVarintQuery(dAtA, i, uint64(len(m.SignersBitmap))) i = encodeVarintQuery(dAtA, i, uint64(len(m.QuorumBitmap)))
i-- i--
dAtA[i] = 0x12 dAtA[i] = 0x1a
}
if m.QuorumId != 0 {
i = encodeVarintQuery(dAtA, i, uint64(m.QuorumId))
i--
dAtA[i] = 0x10
} }
if m.EpochNumber != 0 { if m.EpochNumber != 0 {
i = encodeVarintQuery(dAtA, i, uint64(m.EpochNumber)) i = encodeVarintQuery(dAtA, i, uint64(m.EpochNumber))
@ -846,10 +1032,12 @@ func (m *QuerySignerRequest) Size() (n int) {
} }
var l int var l int
_ = l _ = l
l = len(m.Account) if len(m.Accounts) > 0 {
if l > 0 { for _, s := range m.Accounts {
l = len(s)
n += 1 + l + sovQuery(uint64(l)) n += 1 + l + sovQuery(uint64(l))
} }
}
return n return n
} }
@ -859,10 +1047,12 @@ func (m *QuerySignerResponse) Size() (n int) {
} }
var l int var l int
_ = l _ = l
if m.Signer != nil { if len(m.Signer) > 0 {
l = m.Signer.Size() for _, e := range m.Signer {
l = e.Size()
n += 1 + l + sovQuery(uint64(l)) n += 1 + l + sovQuery(uint64(l))
} }
}
return n return n
} }
@ -887,7 +1077,7 @@ func (m *QueryEpochNumberResponse) Size() (n int) {
return n return n
} }
func (m *QueryEpochSignerSetRequest) Size() (n int) { func (m *QueryQuorumCountRequest) Size() (n int) {
if m == nil { if m == nil {
return 0 return 0
} }
@ -899,17 +1089,42 @@ func (m *QueryEpochSignerSetRequest) Size() (n int) {
return n return n
} }
func (m *QueryEpochSignerSetResponse) Size() (n int) { func (m *QueryQuorumCountResponse) Size() (n int) {
if m == nil { if m == nil {
return 0 return 0
} }
var l int var l int
_ = l _ = l
if len(m.Signers) > 0 { if m.QuorumCount != 0 {
for _, e := range m.Signers { n += 1 + sovQuery(uint64(m.QuorumCount))
l = e.Size()
n += 1 + l + sovQuery(uint64(l))
} }
return n
}
func (m *QueryEpochQuorumRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.EpochNumber != 0 {
n += 1 + sovQuery(uint64(m.EpochNumber))
}
if m.QuorumId != 0 {
n += 1 + sovQuery(uint64(m.QuorumId))
}
return n
}
func (m *QueryEpochQuorumResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Quorum != nil {
l = m.Quorum.Size()
n += 1 + l + sovQuery(uint64(l))
} }
return n return n
} }
@ -923,7 +1138,10 @@ func (m *QueryAggregatePubkeyG1Request) Size() (n int) {
if m.EpochNumber != 0 { if m.EpochNumber != 0 {
n += 1 + sovQuery(uint64(m.EpochNumber)) n += 1 + sovQuery(uint64(m.EpochNumber))
} }
l = len(m.SignersBitmap) if m.QuorumId != 0 {
n += 1 + sovQuery(uint64(m.QuorumId))
}
l = len(m.QuorumBitmap)
if l > 0 { if l > 0 {
n += 1 + l + sovQuery(uint64(l)) n += 1 + l + sovQuery(uint64(l))
} }
@ -986,7 +1204,7 @@ func (m *QuerySignerRequest) Unmarshal(dAtA []byte) error {
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Accounts", wireType)
} }
var stringLen uint64 var stringLen uint64
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
@ -1014,7 +1232,7 @@ func (m *QuerySignerRequest) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Account = string(dAtA[iNdEx:postIndex]) m.Accounts = append(m.Accounts, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
@ -1095,10 +1313,8 @@ func (m *QuerySignerResponse) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
if m.Signer == nil { m.Signer = append(m.Signer, &Signer{})
m.Signer = &Signer{} if err := m.Signer[len(m.Signer)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
}
if err := m.Signer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
@ -1242,7 +1458,7 @@ func (m *QueryEpochNumberResponse) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *QueryEpochSignerSetRequest) Unmarshal(dAtA []byte) error { func (m *QueryQuorumCountRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {
@ -1265,10 +1481,10 @@ func (m *QueryEpochSignerSetRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3) fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7) wireType := int(wire & 0x7)
if wireType == 4 { if wireType == 4 {
return fmt.Errorf("proto: QueryEpochSignerSetRequest: wiretype end group for non-group") return fmt.Errorf("proto: QueryQuorumCountRequest: wiretype end group for non-group")
} }
if fieldNum <= 0 { if fieldNum <= 0 {
return fmt.Errorf("proto: QueryEpochSignerSetRequest: illegal tag %d (wire type %d)", fieldNum, wire) return fmt.Errorf("proto: QueryQuorumCountRequest: illegal tag %d (wire type %d)", fieldNum, wire)
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
@ -1311,7 +1527,7 @@ func (m *QueryEpochSignerSetRequest) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *QueryEpochSignerSetResponse) Unmarshal(dAtA []byte) error { func (m *QueryQuorumCountResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {
@ -1334,15 +1550,172 @@ func (m *QueryEpochSignerSetResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3) fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7) wireType := int(wire & 0x7)
if wireType == 4 { if wireType == 4 {
return fmt.Errorf("proto: QueryEpochSignerSetResponse: wiretype end group for non-group") return fmt.Errorf("proto: QueryQuorumCountResponse: wiretype end group for non-group")
} }
if fieldNum <= 0 { if fieldNum <= 0 {
return fmt.Errorf("proto: QueryEpochSignerSetResponse: illegal tag %d (wire type %d)", fieldNum, wire) return fmt.Errorf("proto: QueryQuorumCountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field QuorumCount", wireType)
}
m.QuorumCount = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.QuorumCount |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
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 *QueryEpochQuorumRequest) 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: QueryEpochQuorumRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryEpochQuorumRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field EpochNumber", wireType)
}
m.EpochNumber = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.EpochNumber |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field QuorumId", wireType)
}
m.QuorumId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.QuorumId |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
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 *QueryEpochQuorumResponse) 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: QueryEpochQuorumResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryEpochQuorumResponse: illegal tag %d (wire type %d)", fieldNum, wire)
} }
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signers", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Quorum", wireType)
} }
var msglen int var msglen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
@ -1369,8 +1742,10 @@ func (m *QueryEpochSignerSetResponse) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.Signers = append(m.Signers, &Signer{}) if m.Quorum == nil {
if err := m.Signers[len(m.Signers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { m.Quorum = &Quorum{}
}
if err := m.Quorum.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
@ -1444,8 +1819,27 @@ func (m *QueryAggregatePubkeyG1Request) Unmarshal(dAtA []byte) error {
} }
} }
case 2: case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field QuorumId", wireType)
}
m.QuorumId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.QuorumId |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SignersBitmap", wireType) return fmt.Errorf("proto: wrong wireType = %d for field QuorumBitmap", wireType)
} }
var byteLen int var byteLen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
@ -1472,9 +1866,9 @@ func (m *QueryAggregatePubkeyG1Request) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.SignersBitmap = append(m.SignersBitmap[:0], dAtA[iNdEx:postIndex]...) m.QuorumBitmap = append(m.QuorumBitmap[:0], dAtA[iNdEx:postIndex]...)
if m.SignersBitmap == nil { if m.QuorumBitmap == nil {
m.SignersBitmap = []byte{} m.QuorumBitmap = []byte{}
} }
iNdEx = postIndex iNdEx = postIndex
default: default:

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

@ -52,37 +52,73 @@ func local_request_Query_EpochNumber_0(ctx context.Context, marshaler runtime.Ma
} }
var ( var (
filter_Query_EpochSignerSet_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} filter_Query_QuorumCount_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
) )
func request_Query_EpochSignerSet_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { func request_Query_QuorumCount_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryEpochSignerSetRequest var protoReq QueryQuorumCountRequest
var metadata runtime.ServerMetadata var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil { if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
} }
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_EpochSignerSet_0); err != nil { if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QuorumCount_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
} }
msg, err := client.EpochSignerSet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) msg, err := client.QuorumCount(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err return msg, metadata, err
} }
func local_request_Query_EpochSignerSet_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { func local_request_Query_QuorumCount_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryEpochSignerSetRequest var protoReq QueryQuorumCountRequest
var metadata runtime.ServerMetadata var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil { if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
} }
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_EpochSignerSet_0); err != nil { if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QuorumCount_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
} }
msg, err := server.EpochSignerSet(ctx, &protoReq) msg, err := server.QuorumCount(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_Query_EpochQuorum_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
func request_Query_EpochQuorum_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryEpochQuorumRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_EpochQuorum_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.EpochQuorum(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_EpochQuorum_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryEpochQuorumRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_EpochQuorum_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.EpochQuorum(ctx, &protoReq)
return msg, metadata, err return msg, metadata, err
} }
@ -188,7 +224,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
}) })
mux.Handle("GET", pattern_Query_EpochSignerSet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { mux.Handle("GET", pattern_Query_QuorumCount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context()) ctx, cancel := context.WithCancel(req.Context())
defer cancel() defer cancel()
var stream runtime.ServerTransportStream var stream runtime.ServerTransportStream
@ -199,7 +235,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return return
} }
resp, md, err := local_request_Query_EpochSignerSet_0(rctx, inboundMarshaler, server, req, pathParams) resp, md, err := local_request_Query_QuorumCount_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md) ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil { if err != nil {
@ -207,7 +243,30 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
return return
} }
forward_Query_EpochSignerSet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) forward_Query_QuorumCount_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_EpochQuorum_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_EpochQuorum_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_EpochQuorum_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
}) })
@ -318,7 +377,7 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
}) })
mux.Handle("GET", pattern_Query_EpochSignerSet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { mux.Handle("GET", pattern_Query_QuorumCount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context()) ctx, cancel := context.WithCancel(req.Context())
defer cancel() defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
@ -327,14 +386,34 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return return
} }
resp, md, err := request_Query_EpochSignerSet_0(rctx, inboundMarshaler, client, req, pathParams) resp, md, err := request_Query_QuorumCount_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md) ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil { if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return return
} }
forward_Query_EpochSignerSet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) forward_Query_QuorumCount_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_EpochQuorum_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_EpochQuorum_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_EpochQuorum_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
}) })
@ -384,7 +463,9 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
var ( var (
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(false))) 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(false)))
pattern_Query_EpochSignerSet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "epoch-signer-set"}, "", runtime.AssumeColonVerbOpt(false))) 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(false)))
pattern_Query_EpochQuorum_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "epoch-quorum"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_AggregatePubkeyG1_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "aggregate-pubkey-g1"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_AggregatePubkeyG1_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "aggregate-pubkey-g1"}, "", runtime.AssumeColonVerbOpt(false)))
@ -394,7 +475,9 @@ var (
var ( var (
forward_Query_EpochNumber_0 = runtime.ForwardResponseMessage forward_Query_EpochNumber_0 = runtime.ForwardResponseMessage
forward_Query_EpochSignerSet_0 = runtime.ForwardResponseMessage forward_Query_QuorumCount_0 = runtime.ForwardResponseMessage
forward_Query_EpochQuorum_0 = runtime.ForwardResponseMessage
forward_Query_AggregatePubkeyG1_0 = runtime.ForwardResponseMessage forward_Query_AggregatePubkeyG1_0 = runtime.ForwardResponseMessage