From 78d1f13a93ec51a819681e854e20271d9d79e5e1 Mon Sep 17 00:00:00 2001 From: Solovyov1796 Date: Wed, 1 May 2024 14:08:58 +0800 Subject: [PATCH] add 0g code --- app/app.go | 28 +- app/config.go | 41 - app/test_common.go | 2 +- helper/da/client/client.go | 61 + helper/da/client/pool.go | 101 ++ helper/da/go.mod | 26 + helper/da/go.sum | 60 + helper/da/light/light.pb.go | 397 ++++++ helper/da/light/light_grpc.pb.go | 141 +++ helper/da/main.go | 89 ++ helper/da/proto/light.proto | 33 + helper/da/service/handler.go | 186 +++ helper/da/types/dasreq.go | 8 + helper/da/types/keys.go | 10 + helper/da/utils/sizedw8grp/sizedw8grp.go | 51 + proto/zgc/council/v1/genesis.proto | 52 + proto/zgc/council/v1/query.proto | 34 + proto/zgc/council/v1/tx.proto | 31 + proto/zgc/das/v1/genesis.proto | 37 + proto/zgc/das/v1/query.proto | 24 + proto/zgc/das/v1/tx.proto | 35 + x/council/v1/client/cli/query.go | 87 ++ x/council/v1/client/cli/tx.go | 198 +++ x/council/v1/genesis.go | 56 + x/council/v1/keeper/abci.go | 72 ++ x/council/v1/keeper/grpc_query.go | 35 + x/council/v1/keeper/keeper.go | 323 +++++ x/council/v1/keeper/msg_server.go | 51 + x/council/v1/keeper/params.go | 29 + x/council/v1/module.go | 182 +++ x/council/v1/types/codec.go | 52 + x/council/v1/types/council.go | 21 + x/council/v1/types/epoch.go | 3 + x/council/v1/types/errors.go | 19 + x/council/v1/types/events.go | 19 + x/council/v1/types/genesis.go | 42 + x/council/v1/types/genesis.pb.go | 1467 ++++++++++++++++++++++ x/council/v1/types/interfaces.go | 23 + x/council/v1/types/keys.go | 52 + x/council/v1/types/msg.go | 65 + x/council/v1/types/query.pb.go | 839 +++++++++++++ x/council/v1/types/query.pb.gw.go | 218 ++++ x/council/v1/types/tx.pb.go | 975 ++++++++++++++ x/das/v1/client/cli/query.go | 57 + x/das/v1/client/cli/tx.go | 103 ++ x/das/v1/genesis.go | 39 + x/das/v1/keeper/grpc_query.go | 22 + x/das/v1/keeper/keeper.go | 198 +++ x/das/v1/keeper/msg_server.go | 49 + x/das/v1/module.go | 180 +++ x/das/v1/types/codec.go | 47 + x/das/v1/types/errors.go | 8 + x/das/v1/types/events.go | 11 + x/das/v1/types/genesis.go | 28 + x/das/v1/types/genesis.pb.go | 1191 ++++++++++++++++++ x/das/v1/types/interfaces.go | 10 + x/das/v1/types/keys.go | 44 + x/das/v1/types/msg.go | 57 + x/das/v1/types/query.pb.go | 511 ++++++++ x/das/v1/types/query.pb.gw.go | 153 +++ x/das/v1/types/tx.pb.go | 1110 ++++++++++++++++ 61 files changed, 10050 insertions(+), 43 deletions(-) delete mode 100644 app/config.go create mode 100644 helper/da/client/client.go create mode 100644 helper/da/client/pool.go create mode 100644 helper/da/go.mod create mode 100644 helper/da/go.sum create mode 100644 helper/da/light/light.pb.go create mode 100644 helper/da/light/light_grpc.pb.go create mode 100644 helper/da/main.go create mode 100644 helper/da/proto/light.proto create mode 100644 helper/da/service/handler.go create mode 100644 helper/da/types/dasreq.go create mode 100644 helper/da/types/keys.go create mode 100644 helper/da/utils/sizedw8grp/sizedw8grp.go create mode 100644 proto/zgc/council/v1/genesis.proto create mode 100644 proto/zgc/council/v1/query.proto create mode 100644 proto/zgc/council/v1/tx.proto create mode 100644 proto/zgc/das/v1/genesis.proto create mode 100644 proto/zgc/das/v1/query.proto create mode 100644 proto/zgc/das/v1/tx.proto create mode 100644 x/council/v1/client/cli/query.go create mode 100644 x/council/v1/client/cli/tx.go create mode 100644 x/council/v1/genesis.go create mode 100644 x/council/v1/keeper/abci.go create mode 100644 x/council/v1/keeper/grpc_query.go create mode 100644 x/council/v1/keeper/keeper.go create mode 100644 x/council/v1/keeper/msg_server.go create mode 100644 x/council/v1/keeper/params.go create mode 100644 x/council/v1/module.go create mode 100644 x/council/v1/types/codec.go create mode 100644 x/council/v1/types/council.go create mode 100644 x/council/v1/types/epoch.go create mode 100644 x/council/v1/types/errors.go create mode 100644 x/council/v1/types/events.go create mode 100644 x/council/v1/types/genesis.go create mode 100644 x/council/v1/types/genesis.pb.go create mode 100644 x/council/v1/types/interfaces.go create mode 100644 x/council/v1/types/keys.go create mode 100644 x/council/v1/types/msg.go create mode 100644 x/council/v1/types/query.pb.go create mode 100644 x/council/v1/types/query.pb.gw.go create mode 100644 x/council/v1/types/tx.pb.go create mode 100644 x/das/v1/client/cli/query.go create mode 100644 x/das/v1/client/cli/tx.go create mode 100644 x/das/v1/genesis.go create mode 100644 x/das/v1/keeper/grpc_query.go create mode 100644 x/das/v1/keeper/keeper.go create mode 100644 x/das/v1/keeper/msg_server.go create mode 100644 x/das/v1/module.go create mode 100644 x/das/v1/types/codec.go create mode 100644 x/das/v1/types/errors.go create mode 100644 x/das/v1/types/events.go create mode 100644 x/das/v1/types/genesis.go create mode 100644 x/das/v1/types/genesis.pb.go create mode 100644 x/das/v1/types/interfaces.go create mode 100644 x/das/v1/types/keys.go create mode 100644 x/das/v1/types/msg.go create mode 100644 x/das/v1/types/query.pb.go create mode 100644 x/das/v1/types/query.pb.gw.go create mode 100644 x/das/v1/types/tx.pb.go diff --git a/app/app.go b/app/app.go index 602f75c5..a3ed9bcb 100644 --- a/app/app.go +++ b/app/app.go @@ -106,6 +106,12 @@ import ( committeeclient "github.com/0glabs/0g-chain/x/committee/client" committeekeeper "github.com/0glabs/0g-chain/x/committee/keeper" committeetypes "github.com/0glabs/0g-chain/x/committee/types" + council "github.com/0glabs/0g-chain/x/council/v1" + councilkeeper "github.com/0glabs/0g-chain/x/council/v1/keeper" + counciltypes "github.com/0glabs/0g-chain/x/council/v1/types" + das "github.com/0glabs/0g-chain/x/das/v1" + daskeeper "github.com/0glabs/0g-chain/x/das/v1/keeper" + dastypes "github.com/0glabs/0g-chain/x/das/v1/types" evmutil "github.com/0glabs/0g-chain/x/evmutil" evmutilkeeper "github.com/0glabs/0g-chain/x/evmutil/keeper" evmutiltypes "github.com/0glabs/0g-chain/x/evmutil/types" @@ -157,6 +163,8 @@ var ( validatorvesting.AppModuleBasic{}, evmutil.AppModuleBasic{}, mint.AppModuleBasic{}, + council.AppModuleBasic{}, + das.AppModuleBasic{}, ) // module account permissions @@ -233,6 +241,8 @@ type App struct { upgradeKeeper upgradekeeper.Keeper evidenceKeeper evidencekeeper.Keeper transferKeeper ibctransferkeeper.Keeper + CouncilKeeper councilkeeper.Keeper + DasKeeper daskeeper.Keeper issuanceKeeper issuancekeeper.Keeper bep3Keeper bep3keeper.Keeper pricefeedKeeper pricefeedkeeper.Keeper @@ -288,6 +298,8 @@ func NewApp( issuancetypes.StoreKey, bep3types.StoreKey, pricefeedtypes.StoreKey, committeetypes.StoreKey, evmutiltypes.StoreKey, minttypes.StoreKey, + counciltypes.StoreKey, + dastypes.StoreKey, ) tkeys := sdk.NewTransientStoreKeys(paramstypes.TStoreKey, evmtypes.TransientKey, feemarkettypes.TransientKey) memKeys := sdk.NewMemoryStoreKeys(capabilitytypes.MemStoreKey) @@ -547,6 +559,11 @@ func NewApp( ) app.govKeeper.SetTallyHandler(tallyHandler) + app.CouncilKeeper = councilkeeper.NewKeeper( + keys[counciltypes.StoreKey], appCodec, app.stakingKeeper, + ) + app.DasKeeper = daskeeper.NewKeeper(keys[dastypes.StoreKey], appCodec, app.stakingKeeper) + // create the module manager (Note: Any module instantiated in the module manager that is later modified // must be passed by reference here.) app.mm = module.NewManager( @@ -576,6 +593,8 @@ func NewApp( evmutil.NewAppModule(app.evmutilKeeper, app.bankKeeper, app.accountKeeper), // nil InflationCalculationFn, use SDK's default inflation function mint.NewAppModule(appCodec, app.mintKeeper, app.accountKeeper, nil), + council.NewAppModule(app.CouncilKeeper, app.stakingKeeper), + das.NewAppModule(app.DasKeeper), ) // Warning: Some begin blockers must run before others. Ensure the dependencies are understood before modifying this list. @@ -617,6 +636,9 @@ func NewApp( paramstypes.ModuleName, authz.ModuleName, evmutiltypes.ModuleName, + + counciltypes.ModuleName, + dastypes.ModuleName, ) // Warning: Some end blockers must run before others. Ensure the dependencies are understood before modifying this list. @@ -648,6 +670,8 @@ func NewApp( authz.ModuleName, evmutiltypes.ModuleName, minttypes.ModuleName, + counciltypes.ModuleName, + dastypes.ModuleName, ) // Warning: Some init genesis methods must run before others. Ensure the dependencies are understood before modifying this list @@ -678,6 +702,8 @@ func NewApp( paramstypes.ModuleName, upgradetypes.ModuleName, validatorvestingtypes.ModuleName, + counciltypes.ModuleName, + dastypes.ModuleName, ) app.mm.RegisterInvariants(&app.crisisKeeper) @@ -842,7 +868,7 @@ func RegisterAPIRouteRewrites(router *mux.Router) { // Eg: querying /cosmos/distribution/v1beta1/community_pool will return // the same response as querying /kava/community/v1beta1/total_balance routeMap := map[string]string{ - "/cosmos/distribution/v1beta1/community_pool": "/kava/community/v1beta1/total_balance", + "/cosmos/distribution/v1beta1/community_pool": "/0g-chain/community/v1beta1/total_balance", } for clientPath, backendPath := range routeMap { diff --git a/app/config.go b/app/config.go deleted file mode 100644 index fa00e72d..00000000 --- a/app/config.go +++ /dev/null @@ -1,41 +0,0 @@ -package app - -import sdk "github.com/cosmos/cosmos-sdk/types" - -const ( - // Bech32MainPrefix defines the Bech32 prefix for account addresses - Bech32MainPrefix = "kava" - // Bech32PrefixAccPub defines the Bech32 prefix of an account's public key - Bech32PrefixAccPub = Bech32MainPrefix + "pub" - // Bech32PrefixValAddr defines the Bech32 prefix of a validator's operator address - Bech32PrefixValAddr = Bech32MainPrefix + "val" + "oper" - // Bech32PrefixValPub defines the Bech32 prefix of a validator's operator public key - Bech32PrefixValPub = Bech32MainPrefix + "val" + "oper" + "pub" - // Bech32PrefixConsAddr defines the Bech32 prefix of a consensus node address - Bech32PrefixConsAddr = Bech32MainPrefix + "val" + "cons" - // Bech32PrefixConsPub defines the Bech32 prefix of a consensus node public key - Bech32PrefixConsPub = Bech32MainPrefix + "val" + "cons" + "pub" - - Bip44CoinType = 459 // see https://github.com/satoshilabs/slips/blob/master/slip-0044.md -) - -// SetSDKConfig configures the global config with kava app specific parameters. -// It does not seal the config to allow modification in tests. -func SetSDKConfig() *sdk.Config { - config := sdk.GetConfig() - SetBech32AddressPrefixes(config) - SetBip44CoinType(config) - return config -} - -// SetBech32AddressPrefixes sets the global prefix to be used when serializing addresses to bech32 strings. -func SetBech32AddressPrefixes(config *sdk.Config) { - config.SetBech32PrefixForAccount(Bech32MainPrefix, Bech32PrefixAccPub) - config.SetBech32PrefixForValidator(Bech32PrefixValAddr, Bech32PrefixValPub) - config.SetBech32PrefixForConsensusNode(Bech32PrefixConsAddr, Bech32PrefixConsPub) -} - -// SetBip44CoinType sets the global coin type to be used in hierarchical deterministic wallets. -func SetBip44CoinType(config *sdk.Config) { - config.SetCoinType(Bip44CoinType) -} diff --git a/app/test_common.go b/app/test_common.go index 4699afe6..29ab3ead 100644 --- a/app/test_common.go +++ b/app/test_common.go @@ -78,7 +78,7 @@ type TestApp struct { // // Note, it also sets the sdk config with the app's address prefix, coin type, etc. func NewTestApp() TestApp { - SetSDKConfig() + chaincfg.SetSDKConfig() return NewTestAppFromSealed() } diff --git a/helper/da/client/client.go b/helper/da/client/client.go new file mode 100644 index 00000000..0d760d6b --- /dev/null +++ b/helper/da/client/client.go @@ -0,0 +1,61 @@ +package client + +import ( + "context" + "time" + + "github.com/0glabs/0g-chain/helper/da/light" + + "github.com/pkg/errors" +) + +type DaLightRpcClient interface { + Sample(ctx context.Context, streamId, headerHash []byte, blobIdx, times uint32) (bool, error) + Destroy() + GetInstanceCount() int +} + +type daLightClient struct { + maxInstance int + pool ConnectionPool +} + +func NewDaLightClient(address string, instanceLimit int) DaLightRpcClient { + return &daLightClient{ + maxInstance: instanceLimit, + pool: NewConnectionPool(address, instanceLimit, 10*time.Minute), + } +} + +func (c *daLightClient) Sample(ctx context.Context, streamId, headerHash []byte, blobIdx, times uint32) (bool, error) { + connection, err := c.pool.GetConnection() + if err != nil { + return false, errors.Wrap(err, "failed to connect to da light server") + } + defer c.pool.ReleaseConnection(connection) + + req := &light.SampleRequest{ + StreamId: streamId, + BatchHeaderHash: headerHash, + BlobIndex: blobIdx, + Times: times, + } + client := light.NewLightClient(connection) + reply, err := client.Sample(ctx, req) + if err != nil { + return false, errors.Wrap(err, "failed to sample from da light server") + } + + return reply.Success, nil +} + +func (c *daLightClient) Destroy() { + if c.pool != nil { + c.pool.Close() + c.pool = nil + } +} + +func (c *daLightClient) GetInstanceCount() int { + return c.maxInstance +} diff --git a/helper/da/client/pool.go b/helper/da/client/pool.go new file mode 100644 index 00000000..887704a0 --- /dev/null +++ b/helper/da/client/pool.go @@ -0,0 +1,101 @@ +package client + +import ( + "errors" + "sync" + "time" + + "google.golang.org/grpc" + "google.golang.org/grpc/backoff" + "google.golang.org/grpc/credentials/insecure" +) + +type ConnectionPool interface { + GetConnection() (*grpc.ClientConn, error) + ReleaseConnection(*grpc.ClientConn) + Close() +} + +type connectionPoolImpl struct { + address string + maxSize int + timeout time.Duration + param grpc.ConnectParams + + mu sync.Mutex + pool []*grpc.ClientConn +} + +func NewConnectionPool(address string, maxSize int, timeout time.Duration) ConnectionPool { + return &connectionPoolImpl{ + address: address, + maxSize: maxSize, + timeout: timeout, + param: grpc.ConnectParams{ + Backoff: backoff.Config{ + BaseDelay: 1.0 * time.Second, + Multiplier: 1.5, + Jitter: 0.2, + MaxDelay: 30 * time.Second, + }, + MinConnectTimeout: 30 * time.Second, + }, + pool: make([]*grpc.ClientConn, 0, maxSize), + } +} + +func (p *connectionPoolImpl) GetConnection() (*grpc.ClientConn, error) { + p.mu.Lock() + defer p.mu.Unlock() + + if p.pool == nil { + return nil, errors.New("connection pool is closed") + } + + // Check if there's any available connection in the pool + if len(p.pool) > 0 { + conn := p.pool[0] + p.pool = p.pool[1:] + return conn, nil + } + + // If the pool is empty, create a new connection + conn, err := grpc.Dial(p.address, grpc.WithBlock(), + grpc.WithConnectParams(p.param), + grpc.WithTransportCredentials(insecure.NewCredentials())) + if err != nil { + return nil, err + } + return conn, nil +} + +func (p *connectionPoolImpl) ReleaseConnection(conn *grpc.ClientConn) { + p.mu.Lock() + defer p.mu.Unlock() + + if p.pool != nil { + // If the pool is full, close the connection + if len(p.pool) >= p.maxSize { + conn.Close() + return + } + + // Add the connection back to the pool + p.pool = append(p.pool, conn) + } else { + conn.Close() + } +} + +func (p *connectionPoolImpl) Close() { + p.mu.Lock() + defer p.mu.Unlock() + + if p.pool != nil { + for _, conn := range p.pool { + conn.Close() + } + + p.pool = nil + } +} diff --git a/helper/da/go.mod b/helper/da/go.mod new file mode 100644 index 00000000..c42d6564 --- /dev/null +++ b/helper/da/go.mod @@ -0,0 +1,26 @@ +module github.com/0glabs/0g-chain/helper/da + +go 1.20 + +require ( + github.com/json-iterator/go v1.1.12 + github.com/lesismal/nbio v1.5.4 + github.com/pkg/errors v0.9.1 + github.com/rs/zerolog v1.32.0 + google.golang.org/grpc v1.63.2 + google.golang.org/protobuf v1.33.0 +) + +require ( + github.com/lesismal/llib v1.1.13 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.19 // indirect + github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/stretchr/testify v1.8.4 // indirect + golang.org/x/crypto v0.19.0 // indirect + golang.org/x/net v0.21.0 // indirect + golang.org/x/sys v0.17.0 // indirect + golang.org/x/text v0.14.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de // indirect +) diff --git a/helper/da/go.sum b/helper/da/go.sum new file mode 100644 index 00000000..cc3cf3ca --- /dev/null +++ b/helper/da/go.sum @@ -0,0 +1,60 @@ +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/lesismal/llib v1.1.13 h1:+w1+t0PykXpj2dXQck0+p6vdC9/mnbEXHgUy/HXDGfE= +github.com/lesismal/llib v1.1.13/go.mod h1:70tFXXe7P1FZ02AU9l8LgSOK7d7sRrpnkUr3rd3gKSg= +github.com/lesismal/nbio v1.5.4 h1:fZ6FOVZOBm7nFuudYsq+WyHJuM2UNuPdlvF/1LVa6lo= +github.com/lesismal/nbio v1.5.4/go.mod h1:mvfYBAA1jmrafXf2XvkM28jWkMTfA5jGks+HKDBMmOc= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0= +github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +golang.org/x/crypto v0.0.0-20210513122933-cd7d49e622d5/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= +golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210510120150-4163338589ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de h1:cZGRis4/ot9uVm639a+rHCUaG0JJHEsdyzSQTMX+suY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de/go.mod h1:H4O17MA/PE9BsGx3w+a+W2VOLLD1Qf7oJneAoU6WktY= +google.golang.org/grpc v1.63.2 h1:MUeiw1B2maTVZthpU5xvASfTh3LDbxHd6IJ6QQVU+xM= +google.golang.org/grpc v1.63.2/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDomNkRA= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/helper/da/light/light.pb.go b/helper/da/light/light.pb.go new file mode 100644 index 00000000..60c987f2 --- /dev/null +++ b/helper/da/light/light.pb.go @@ -0,0 +1,397 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v4.25.3 +// source: light/light.proto + +package light + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// SampleRequest contains the blob to sample (by batch and blob index) and required sample times +type SampleRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StreamId []byte `protobuf:"bytes,1,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"` + BatchHeaderHash []byte `protobuf:"bytes,2,opt,name=batch_header_hash,json=batchHeaderHash,proto3" json:"batch_header_hash,omitempty"` + BlobIndex uint32 `protobuf:"varint,3,opt,name=blob_index,json=blobIndex,proto3" json:"blob_index,omitempty"` + Times uint32 `protobuf:"varint,4,opt,name=times,proto3" json:"times,omitempty"` +} + +func (x *SampleRequest) Reset() { + *x = SampleRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_light_light_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SampleRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SampleRequest) ProtoMessage() {} + +func (x *SampleRequest) ProtoReflect() protoreflect.Message { + mi := &file_light_light_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SampleRequest.ProtoReflect.Descriptor instead. +func (*SampleRequest) Descriptor() ([]byte, []int) { + return file_light_light_proto_rawDescGZIP(), []int{0} +} + +func (x *SampleRequest) GetStreamId() []byte { + if x != nil { + return x.StreamId + } + return nil +} + +func (x *SampleRequest) GetBatchHeaderHash() []byte { + if x != nil { + return x.BatchHeaderHash + } + return nil +} + +func (x *SampleRequest) GetBlobIndex() uint32 { + if x != nil { + return x.BlobIndex + } + return 0 +} + +func (x *SampleRequest) GetTimes() uint32 { + if x != nil { + return x.Times + } + return 0 +} + +// SampleReply contains the sample result +type SampleReply struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` +} + +func (x *SampleReply) Reset() { + *x = SampleReply{} + if protoimpl.UnsafeEnabled { + mi := &file_light_light_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SampleReply) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SampleReply) ProtoMessage() {} + +func (x *SampleReply) ProtoReflect() protoreflect.Message { + mi := &file_light_light_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SampleReply.ProtoReflect.Descriptor instead. +func (*SampleReply) Descriptor() ([]byte, []int) { + return file_light_light_proto_rawDescGZIP(), []int{1} +} + +func (x *SampleReply) GetSuccess() bool { + if x != nil { + return x.Success + } + return false +} + +type RetrieveRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BatchHeaderHash []byte `protobuf:"bytes,1,opt,name=batch_header_hash,json=batchHeaderHash,proto3" json:"batch_header_hash,omitempty"` + BlobIndex uint32 `protobuf:"varint,2,opt,name=blob_index,json=blobIndex,proto3" json:"blob_index,omitempty"` +} + +func (x *RetrieveRequest) Reset() { + *x = RetrieveRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_light_light_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RetrieveRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RetrieveRequest) ProtoMessage() {} + +func (x *RetrieveRequest) ProtoReflect() protoreflect.Message { + mi := &file_light_light_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RetrieveRequest.ProtoReflect.Descriptor instead. +func (*RetrieveRequest) Descriptor() ([]byte, []int) { + return file_light_light_proto_rawDescGZIP(), []int{2} +} + +func (x *RetrieveRequest) GetBatchHeaderHash() []byte { + if x != nil { + return x.BatchHeaderHash + } + return nil +} + +func (x *RetrieveRequest) GetBlobIndex() uint32 { + if x != nil { + return x.BlobIndex + } + return 0 +} + +type RetrieveReply struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Status bool `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *RetrieveReply) Reset() { + *x = RetrieveReply{} + if protoimpl.UnsafeEnabled { + mi := &file_light_light_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RetrieveReply) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RetrieveReply) ProtoMessage() {} + +func (x *RetrieveReply) ProtoReflect() protoreflect.Message { + mi := &file_light_light_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RetrieveReply.ProtoReflect.Descriptor instead. +func (*RetrieveReply) Descriptor() ([]byte, []int) { + return file_light_light_proto_rawDescGZIP(), []int{3} +} + +func (x *RetrieveReply) GetStatus() bool { + if x != nil { + return x.Status + } + return false +} + +func (x *RetrieveReply) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +var File_light_light_proto protoreflect.FileDescriptor + +var file_light_light_proto_rawDesc = []byte{ + 0x0a, 0x11, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x22, 0x8d, 0x01, 0x0a, 0x0d, 0x53, + 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x08, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x2a, 0x0a, 0x11, 0x62, 0x61, 0x74, + 0x63, 0x68, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x48, 0x61, 0x73, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x62, 0x49, + 0x6e, 0x64, 0x65, 0x78, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x05, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x22, 0x27, 0x0a, 0x0b, 0x53, 0x61, + 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, + 0x63, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x22, 0x5c, 0x0a, 0x0f, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x0f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x48, 0x61, + 0x73, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x62, 0x49, 0x6e, 0x64, 0x65, + 0x78, 0x22, 0x3b, 0x0a, 0x0d, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, 0x70, + 0x6c, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x32, 0x79, + 0x0a, 0x05, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x12, 0x34, 0x0a, 0x06, 0x53, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x12, 0x14, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, + 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x12, 0x3a, 0x0a, + 0x08, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x12, 0x16, 0x2e, 0x6c, 0x69, 0x67, 0x68, + 0x74, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x14, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, + 0x76, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x42, 0x30, 0x5a, 0x2e, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x30, 0x67, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x30, + 0x67, 0x2d, 0x64, 0x61, 0x74, 0x61, 0x2d, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x2f, 0x72, 0x75, 0x6e, + 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_light_light_proto_rawDescOnce sync.Once + file_light_light_proto_rawDescData = file_light_light_proto_rawDesc +) + +func file_light_light_proto_rawDescGZIP() []byte { + file_light_light_proto_rawDescOnce.Do(func() { + file_light_light_proto_rawDescData = protoimpl.X.CompressGZIP(file_light_light_proto_rawDescData) + }) + return file_light_light_proto_rawDescData +} + +var file_light_light_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_light_light_proto_goTypes = []interface{}{ + (*SampleRequest)(nil), // 0: light.SampleRequest + (*SampleReply)(nil), // 1: light.SampleReply + (*RetrieveRequest)(nil), // 2: light.RetrieveRequest + (*RetrieveReply)(nil), // 3: light.RetrieveReply +} +var file_light_light_proto_depIdxs = []int32{ + 0, // 0: light.Light.Sample:input_type -> light.SampleRequest + 2, // 1: light.Light.Retrieve:input_type -> light.RetrieveRequest + 1, // 2: light.Light.Sample:output_type -> light.SampleReply + 3, // 3: light.Light.Retrieve:output_type -> light.RetrieveReply + 2, // [2:4] is the sub-list for method output_type + 0, // [0:2] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_light_light_proto_init() } +func file_light_light_proto_init() { + if File_light_light_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_light_light_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SampleRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_light_light_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SampleReply); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_light_light_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RetrieveRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_light_light_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RetrieveReply); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_light_light_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_light_light_proto_goTypes, + DependencyIndexes: file_light_light_proto_depIdxs, + MessageInfos: file_light_light_proto_msgTypes, + }.Build() + File_light_light_proto = out.File + file_light_light_proto_rawDesc = nil + file_light_light_proto_goTypes = nil + file_light_light_proto_depIdxs = nil +} diff --git a/helper/da/light/light_grpc.pb.go b/helper/da/light/light_grpc.pb.go new file mode 100644 index 00000000..0586c987 --- /dev/null +++ b/helper/da/light/light_grpc.pb.go @@ -0,0 +1,141 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.2.0 +// - protoc v4.25.3 +// source: light/light.proto + +package light + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +// LightClient is the client API for Light service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type LightClient interface { + Sample(ctx context.Context, in *SampleRequest, opts ...grpc.CallOption) (*SampleReply, error) + Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveReply, error) +} + +type lightClient struct { + cc grpc.ClientConnInterface +} + +func NewLightClient(cc grpc.ClientConnInterface) LightClient { + return &lightClient{cc} +} + +func (c *lightClient) Sample(ctx context.Context, in *SampleRequest, opts ...grpc.CallOption) (*SampleReply, error) { + out := new(SampleReply) + err := c.cc.Invoke(ctx, "/light.Light/Sample", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightClient) Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveReply, error) { + out := new(RetrieveReply) + err := c.cc.Invoke(ctx, "/light.Light/Retrieve", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// LightServer is the server API for Light service. +// All implementations must embed UnimplementedLightServer +// for forward compatibility +type LightServer interface { + Sample(context.Context, *SampleRequest) (*SampleReply, error) + Retrieve(context.Context, *RetrieveRequest) (*RetrieveReply, error) + mustEmbedUnimplementedLightServer() +} + +// UnimplementedLightServer must be embedded to have forward compatible implementations. +type UnimplementedLightServer struct { +} + +func (UnimplementedLightServer) Sample(context.Context, *SampleRequest) (*SampleReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method Sample not implemented") +} +func (UnimplementedLightServer) Retrieve(context.Context, *RetrieveRequest) (*RetrieveReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method Retrieve not implemented") +} +func (UnimplementedLightServer) mustEmbedUnimplementedLightServer() {} + +// UnsafeLightServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to LightServer will +// result in compilation errors. +type UnsafeLightServer interface { + mustEmbedUnimplementedLightServer() +} + +func RegisterLightServer(s grpc.ServiceRegistrar, srv LightServer) { + s.RegisterService(&Light_ServiceDesc, srv) +} + +func _Light_Sample_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SampleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightServer).Sample(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/light.Light/Sample", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightServer).Sample(ctx, req.(*SampleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Light_Retrieve_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RetrieveRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightServer).Retrieve(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/light.Light/Retrieve", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightServer).Retrieve(ctx, req.(*RetrieveRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Light_ServiceDesc is the grpc.ServiceDesc for Light service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Light_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "light.Light", + HandlerType: (*LightServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Sample", + Handler: _Light_Sample_Handler, + }, + { + MethodName: "Retrieve", + Handler: _Light_Retrieve_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "light/light.proto", +} diff --git a/helper/da/main.go b/helper/da/main.go new file mode 100644 index 00000000..247f4e16 --- /dev/null +++ b/helper/da/main.go @@ -0,0 +1,89 @@ +package main + +import ( + "context" + "flag" + "fmt" + "io" + "log" + "net/url" + "os" + "os/signal" + "time" + + "github.com/0glabs/0g-chain/helper/da/service" + "github.com/0glabs/0g-chain/helper/da/types" + + "github.com/lesismal/nbio/nbhttp" + "github.com/lesismal/nbio/nbhttp/websocket" +) + +const ( + subscribeMsg = "{\"jsonrpc\":\"2.0\",\"method\":\"subscribe\",\"id\":1,\"params\":{\"query\":\"tm.event='Tx'\"}}" +) + +var ( + rpcAddress = flag.String("rpc-address", "34.214.2.28:32001", "address of da-light rpc server") + wsAddress = flag.String("ws-address", "127.0.0.1:26657", "address of emvos ws server") + relativePath = flag.String("relative-path", "", "relative path of evmosd") + account = flag.String("account", "", "account to run evmosd cli") + keyring = flag.String("keyring", "", "keyring to run evmosd cli") + homePath = flag.String("home", "", "home path of evmosd node") +) + +func newUpgrader() *websocket.Upgrader { + u := websocket.NewUpgrader() + u.OnMessage(func(c *websocket.Conn, messageType websocket.MessageType, data []byte) { + log.Println("onEcho:", string(data)) + ctx := context.WithValue(context.Background(), types.DA_RPC_ADDRESS, *rpcAddress) + ctx = context.WithValue(ctx, types.NODE_CLI_RELATIVE_PATH, *relativePath) + ctx = context.WithValue(ctx, types.NODE_CLI_EXEC_ACCOUNT, *account) + ctx = context.WithValue(ctx, types.NODE_CLI_EXEC_KEYRING, *keyring) + ctx = context.WithValue(ctx, types.NODE_HOME_PATH, *homePath) + go func() { service.OnMessage(ctx, c, messageType, data) }() + }) + + u.OnClose(func(c *websocket.Conn, err error) { + fmt.Println("OnClose:", c.RemoteAddr().String(), err) + service.OnClose() + }) + + return u +} + +func main() { + flag.Parse() + engine := nbhttp.NewEngine(nbhttp.Config{}) + err := engine.Start() + if err != nil { + fmt.Printf("nbio.Start failed: %v\n", err) + return + } + + go func() { + u := url.URL{Scheme: "ws", Host: *wsAddress, Path: "/websocket"} + dialer := &websocket.Dialer{ + Engine: engine, + Upgrader: newUpgrader(), + DialTimeout: time.Second * 3, + } + c, res, err := dialer.Dial(u.String(), nil) + if err != nil { + if res != nil && res.Body != nil { + bReason, _ := io.ReadAll(res.Body) + fmt.Printf("dial failed: %v, reason: %v\n", err, string(bReason)) + } else { + fmt.Printf("dial failed: %v\n", err) + } + return + } + c.WriteMessage(websocket.TextMessage, []byte(subscribeMsg)) + }() + + interrupt := make(chan os.Signal, 1) + signal.Notify(interrupt, os.Interrupt) + <-interrupt + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + engine.Shutdown(ctx) +} diff --git a/helper/da/proto/light.proto b/helper/da/proto/light.proto new file mode 100644 index 00000000..f816b54f --- /dev/null +++ b/helper/da/proto/light.proto @@ -0,0 +1,33 @@ +syntax = "proto3"; + +package light; + +option go_package = "proto/light"; + +service Light { + rpc Sample(SampleRequest) returns (SampleReply) {} + rpc Retrieve(RetrieveRequest) returns (RetrieveReply) {} +} + +// SampleRequest contains the blob to sample (by batch and blob index) and required sample times +message SampleRequest { + bytes stream_id = 1; + bytes batch_header_hash = 2; + uint32 blob_index = 3; + uint32 times = 4; +} + +// SampleReply contains the sample result +message SampleReply { + bool success = 1; +} + +message RetrieveRequest { + bytes batch_header_hash = 1; + uint32 blob_index = 2; +} + +message RetrieveReply { + bool status = 1; + bytes data = 2; +} \ No newline at end of file diff --git a/helper/da/service/handler.go b/helper/da/service/handler.go new file mode 100644 index 00000000..5a379bc8 --- /dev/null +++ b/helper/da/service/handler.go @@ -0,0 +1,186 @@ +package service + +import ( + "context" + "encoding/hex" + "os" + "os/exec" + "strconv" + "strings" + + "github.com/0glabs/0g-chain/helper/da/client" + "github.com/0glabs/0g-chain/helper/da/types" + "github.com/0glabs/0g-chain/helper/da/utils/sizedw8grp" + + jsoniter "github.com/json-iterator/go" + "github.com/lesismal/nbio/nbhttp/websocket" + "github.com/pkg/errors" + "github.com/rs/zerolog/log" +) + +const ( + defaultClientInstance = 10 +) + +var rpcClient client.DaLightRpcClient + +func OnMessage(ctx context.Context, c *websocket.Conn, messageType websocket.MessageType, data []byte) { + if messageType == websocket.TextMessage { + rawMsg := unwrapJsonRpc(data) + if verifyQuery(rawMsg) { + eventStr := jsoniter.Get(rawMsg, "events").ToString() + events := map[string][]string{} + if err := jsoniter.UnmarshalFromString(eventStr, &events); err == nil { + dasRequestMap := make(map[string]string, 4) + for key, val := range events { + if strings.HasPrefix(key, "das_request.") { + dasRequestMap[strings.ReplaceAll(key, "das_request.", "")] = val[0] + } + } + if len(dasRequestMap) == 4 { + rid, _ := strconv.ParseUint(dasRequestMap["request_id"], 10, 64) + numBlobs, _ := strconv.ParseUint(dasRequestMap["num_blobs"], 10, 64) + req := types.DASRequest{ + RequestId: rid, + StreamId: dasRequestMap["stream_id"], + BatchHeaderHash: dasRequestMap["batch_header_hash"], + NumBlobs: numBlobs, + } + err := handleDasRequest(ctx, req) + + if err != nil { + log.Err(err).Msgf("failed to handle das request: %v, %v", req, err) + } else { + log.Info().Msgf("successfully handled das request: %v", req) + } + } + } + } + } else { + // TODO: handle other message + } +} + +func OnClose() { + if rpcClient != nil { + rpcClient.Destroy() + rpcClient = nil + } +} + +func unwrapJsonRpc(data []byte) []byte { + result := jsoniter.Get(data, "result") + if 0 < len(result.Keys()) { + return []byte(result.ToString()) + } + return []byte{} +} + +func verifyQuery(data []byte) bool { + if len(data) > 0 { + return jsoniter.Get(data, "query").ToString() == "tm.event='Tx'" + } + return false +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} + +func handleDasRequest(ctx context.Context, request types.DASRequest) error { + if rpcClient == nil { + addrVal := ctx.Value(types.DA_RPC_ADDRESS) + if addrVal == nil { + return errors.New("da light service address not found in context") + } + + limit := ctx.Value(types.INSTANCE_LIMIT) + if limit == nil { + limit = defaultClientInstance + } + + rpcClient = client.NewDaLightClient(addrVal.(string), limit.(int)) + } + + streamID, err := hex.DecodeString(request.StreamId) + if err != nil { + return err + } + + batchHeaderHash, err := hex.DecodeString(request.BatchHeaderHash) + if err != nil { + return err + } + + result := make(chan bool, request.NumBlobs) + taskCnt := min(rpcClient.GetInstanceCount(), int(request.NumBlobs)) + wg := sizedw8grp.New(taskCnt) + + for i := uint64(0); i < request.NumBlobs; i++ { + wg.Add() + go func(idx uint64) { + defer wg.Done() + ret, err := rpcClient.Sample(ctx, streamID, batchHeaderHash, uint32(idx), 1) + if err != nil { + log.Err(err).Msgf("failed to sample data availability with blob index %d", idx) + result <- false + } else { + log.Info().Msgf("sample result for blob index %d: %v", idx, ret) + result <- ret + } + }(i) + } + wg.Wait() + close(result) + + finalResult := true + for val := range result { + if !val { + finalResult = false + break + } + } + + return runEvmosdCliReportDasResult(ctx, request.RequestId, finalResult) +} + +func runEvmosdCliReportDasResult(ctx context.Context, requestId uint64, result bool) error { + relativePath := ctx.Value(types.NODE_CLI_RELATIVE_PATH) + if relativePath == nil { + return errors.New("relativePath not found in context") + } + + account := ctx.Value(types.NODE_CLI_EXEC_ACCOUNT) + if account == nil { + return errors.New("account not found in context") + } + + args := []string{ + "tx", + "das", + "report-das-result", + strconv.FormatUint(requestId, 10), + strconv.FormatBool(result), + "--from", account.(string), + "--gas-prices", "7678500neuron", // TODO: use args to set gas prices + } + + homePath := ctx.Value(types.NODE_HOME_PATH) + if len(homePath.(string)) > 0 { + args = append(args, "--home", homePath.(string)) + } + + keyring := ctx.Value(types.NODE_CLI_EXEC_KEYRING) + if len(keyring.(string)) > 0 { + args = append(args, "--keyring-backend", keyring.(string)) + } + + cmdStr := relativePath.(string) + "0gchaind" + cmd := exec.Command(cmdStr, append(args, "-y")...) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + return cmd.Run() +} diff --git a/helper/da/types/dasreq.go b/helper/da/types/dasreq.go new file mode 100644 index 00000000..1c3b92e3 --- /dev/null +++ b/helper/da/types/dasreq.go @@ -0,0 +1,8 @@ +package types + +type DASRequest struct { + RequestId uint64 `json:"request_id"` + StreamId string `json:"stream_id"` + BatchHeaderHash string `json:"batch_header_hash"` + NumBlobs uint64 `json:"num_blobs"` +} diff --git a/helper/da/types/keys.go b/helper/da/types/keys.go new file mode 100644 index 00000000..e824f793 --- /dev/null +++ b/helper/da/types/keys.go @@ -0,0 +1,10 @@ +package types + +const ( + DA_RPC_ADDRESS = "rpc_address" + INSTANCE_LIMIT = "instance_limit" + NODE_CLI_RELATIVE_PATH = "relative_path" + NODE_CLI_EXEC_ACCOUNT = "node_exec_account" + NODE_CLI_EXEC_KEYRING = "node_exec_keyring" + NODE_HOME_PATH = "home_path" +) diff --git a/helper/da/utils/sizedw8grp/sizedw8grp.go b/helper/da/utils/sizedw8grp/sizedw8grp.go new file mode 100644 index 00000000..ac7348e6 --- /dev/null +++ b/helper/da/utils/sizedw8grp/sizedw8grp.go @@ -0,0 +1,51 @@ +package sizedw8grp + +import ( + "context" + "math" + "sync" +) + +type SizedWaitGroup struct { + Size int + + current chan struct{} + wg sync.WaitGroup +} + +func New(limit int) SizedWaitGroup { + size := math.MaxInt32 + if limit > 0 { + size = limit + } + return SizedWaitGroup{ + Size: size, + + current: make(chan struct{}, size), + wg: sync.WaitGroup{}, + } +} + +func (s *SizedWaitGroup) Add() { + _ = s.AddWithContext(context.Background()) +} + +func (s *SizedWaitGroup) AddWithContext(ctx context.Context) error { + select { + case <-ctx.Done(): + return ctx.Err() + case s.current <- struct{}{}: + break + } + s.wg.Add(1) + return nil +} + +func (s *SizedWaitGroup) Done() { + <-s.current + s.wg.Done() +} + +func (s *SizedWaitGroup) Wait() { + s.wg.Wait() +} diff --git a/proto/zgc/council/v1/genesis.proto b/proto/zgc/council/v1/genesis.proto new file mode 100644 index 00000000..fbfcc07b --- /dev/null +++ b/proto/zgc/council/v1/genesis.proto @@ -0,0 +1,52 @@ +syntax = "proto3"; +package zgc.council.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/council/v1/types"; + +message Params { + uint64 council_size = 1; +} + +// GenesisState defines the council module's genesis state. +message GenesisState { + option (gogoproto.goproto_getters) = false; + + Params params = 1 [(gogoproto.nullable) = false]; + uint64 voting_start_height = 2; + uint64 voting_period = 3; + uint64 current_council_id = 4 [(gogoproto.customname) = "CurrentCouncilID"]; + repeated Council councils = 5 [(gogoproto.nullable) = false]; +} + +message Council { + uint64 id = 1 [(gogoproto.customname) = "ID"]; + uint64 voting_start_height = 2; + uint64 start_height = 3; + uint64 end_height = 4; + repeated Vote votes = 5 [(gogoproto.nullable) = false]; + repeated bytes members = 6 [ + (cosmos_proto.scalar) = "cosmos.AddressBytes", + (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress" + ]; +} + +message Vote { + option (gogoproto.goproto_getters) = false; + + uint64 council_id = 1 [(gogoproto.customname) = "CouncilID"]; + bytes voter = 2 [ + (cosmos_proto.scalar) = "cosmos.AddressBytes", + (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress" + ]; + repeated Ballot ballots = 3; +} + +message Ballot { + uint64 id = 1 [(gogoproto.customname) = "ID"]; + bytes content = 2; +} diff --git a/proto/zgc/council/v1/query.proto b/proto/zgc/council/v1/query.proto new file mode 100644 index 00000000..0f65b2f7 --- /dev/null +++ b/proto/zgc/council/v1/query.proto @@ -0,0 +1,34 @@ +syntax = "proto3"; +package zgc.council.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; +import "zgc/council/v1/genesis.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/council/v1/types"; +option (gogoproto.goproto_getters_all) = false; + +// Query defines the gRPC querier service for council module +service Query { + rpc CurrentCouncilID(QueryCurrentCouncilIDRequest) returns (QueryCurrentCouncilIDResponse) { + option (google.api.http).get = "/0gchain/council/v1/current-council-id"; + } + rpc RegisteredVoters(QueryRegisteredVotersRequest) returns (QueryRegisteredVotersResponse) { + option (google.api.http).get = "/0gchain/council/v1/registered-voters"; + } +} + +message QueryCurrentCouncilIDRequest {} + +message QueryCurrentCouncilIDResponse { + uint64 current_council_id = 1 [(gogoproto.customname) = "CurrentCouncilID"]; +} + +message QueryRegisteredVotersRequest {} + +message QueryRegisteredVotersResponse { + repeated string voters = 1; +} diff --git a/proto/zgc/council/v1/tx.proto b/proto/zgc/council/v1/tx.proto new file mode 100644 index 00000000..323f6fde --- /dev/null +++ b/proto/zgc/council/v1/tx.proto @@ -0,0 +1,31 @@ +syntax = "proto3"; +package zgc.council.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "zgc/council/v1/genesis.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/council/v1/types"; +option (gogoproto.goproto_getters_all) = false; + +// Msg defines the council Msg service +service Msg { + rpc Register(MsgRegister) returns (MsgRegisterResponse); + rpc Vote(MsgVote) returns (MsgVoteResponse); +} + +message MsgRegister { + string voter = 1; + bytes key = 2; +} + +message MsgRegisterResponse {} + +message MsgVote { + uint64 council_id = 1 [(gogoproto.customname) = "CouncilID"]; + string voter = 2; + repeated Ballot ballots = 3; +} + +message MsgVoteResponse {} diff --git a/proto/zgc/das/v1/genesis.proto b/proto/zgc/das/v1/genesis.proto new file mode 100644 index 00000000..9aae1faa --- /dev/null +++ b/proto/zgc/das/v1/genesis.proto @@ -0,0 +1,37 @@ +syntax = "proto3"; +package zgc.das.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/das/v1/types"; + +message Params {} + +// GenesisState defines the das module's genesis state. +message GenesisState { + option (gogoproto.goproto_getters) = false; + + Params params = 1 [(gogoproto.nullable) = false]; + uint64 next_request_id = 2 [(gogoproto.customname) = "NextRequestID"]; + repeated DASRequest requests = 3 [(gogoproto.nullable) = false]; + repeated DASResponse responses = 4 [(gogoproto.nullable) = false]; +} + +message DASRequest { + uint64 id = 1 [(gogoproto.customname) = "ID"]; + bytes stream_id = 2 [(gogoproto.customname) = "StreamID"]; + bytes batch_header_hash = 3; + uint32 num_blobs = 4; +} + +message DASResponse { + uint64 id = 1 [(gogoproto.customname) = "ID"]; + bytes sampler = 2 [ + (cosmos_proto.scalar) = "cosmos.AddressBytes", + (gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress" + ]; + repeated bool results = 3; +} diff --git a/proto/zgc/das/v1/query.proto b/proto/zgc/das/v1/query.proto new file mode 100644 index 00000000..371c50e8 --- /dev/null +++ b/proto/zgc/das/v1/query.proto @@ -0,0 +1,24 @@ +syntax = "proto3"; +package zgc.das.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/das/v1/types"; +option (gogoproto.goproto_getters_all) = false; + +// Query defines the gRPC querier service for the das module +service Query { + rpc NextRequestID(QueryNextRequestIDRequest) returns (QueryNextRequestIDResponse) { + option (google.api.http).get = "/0gchain/das/v1/next-request-id"; + } +} + +message QueryNextRequestIDRequest {} + +message QueryNextRequestIDResponse { + uint64 next_request_id = 1 [(gogoproto.customname) = "NextRequestID"]; +} diff --git a/proto/zgc/das/v1/tx.proto b/proto/zgc/das/v1/tx.proto new file mode 100644 index 00000000..482c4679 --- /dev/null +++ b/proto/zgc/das/v1/tx.proto @@ -0,0 +1,35 @@ +syntax = "proto3"; +package zgc.das.v1; + +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "zgc/das/v1/genesis.proto"; + +option go_package = "github.com/0glabs/0g-chain/x/das/v1/types"; +option (gogoproto.goproto_getters_all) = false; + +// Msg defines the das Msg service +service Msg { + rpc RequestDAS(MsgRequestDAS) returns (MsgRequestDASResponse); + rpc ReportDASResult(MsgReportDASResult) returns (MsgReportDASResultResponse); +} + +message MsgRequestDAS { + string requester = 1 [(gogoproto.moretags) = "Requester"]; + string stream_id = 2 [(gogoproto.customname) = "StreamID"]; + string batch_header_hash = 3; + uint32 num_blobs = 4; +} + +message MsgRequestDASResponse { + uint64 request_id = 1 [(gogoproto.customname) = "RequestID"]; +} + +message MsgReportDASResult { + uint64 request_id = 1 [(gogoproto.customname) = "RequestID"]; + string sampler = 2; + repeated bool results = 3; +} + +message MsgReportDASResultResponse {} diff --git a/x/council/v1/client/cli/query.go b/x/council/v1/client/cli/query.go new file mode 100644 index 00000000..50a5b14f --- /dev/null +++ b/x/council/v1/client/cli/query.go @@ -0,0 +1,87 @@ +package cli + +import ( + "context" + "fmt" + "strings" + + "github.com/spf13/cobra" + + "github.com/0glabs/0g-chain/x/council/v1/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" +) + +// GetQueryCmd returns the cli query commands for the inflation module. +func GetQueryCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: "Querying commands for the council module", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + cmd.AddCommand( + GetCurrentCouncilID(), + GetRegisteredVoters(), + ) + + return cmd +} + +func GetCurrentCouncilID() *cobra.Command { + cmd := &cobra.Command{ + Use: "current-council-id", + Short: "Query the current council ID", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryCurrentCouncilIDRequest{} + res, err := queryClient.CurrentCouncilID(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintString(fmt.Sprintf("%v\n", res.CurrentCouncilID)) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + +func GetRegisteredVoters() *cobra.Command { + cmd := &cobra.Command{ + Use: "registered-voters", + Short: "Query registered voters", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryRegisteredVotersRequest{} + res, err := queryClient.RegisteredVoters(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintString(fmt.Sprintf("%v\n", strings.Join(res.Voters, ","))) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/council/v1/client/cli/tx.go b/x/council/v1/client/cli/tx.go new file mode 100644 index 00000000..31f12d0e --- /dev/null +++ b/x/council/v1/client/cli/tx.go @@ -0,0 +1,198 @@ +package cli + +import ( + "bufio" + "bytes" + "encoding/hex" + "errors" + "fmt" + "strconv" + + sdkmath "cosmossdk.io/math" + "github.com/0glabs/0g-chain/crypto/vrf" + "github.com/0glabs/0g-chain/x/council/v1/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + sdkkr "github.com/cosmos/cosmos-sdk/crypto/keyring" + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + vrfalgo "github.com/coniks-sys/coniks-go/crypto/vrf" + "github.com/cosmos/cosmos-sdk/client/input" + "github.com/spf13/cobra" +) + +// GetTxCmd returns the transaction commands for this module +func GetTxCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: fmt.Sprintf("%s transactions subcommands", types.ModuleName), + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + cmd.AddCommand( + NewRegisterCmd(), + NewVoteCmd(), + ) + return cmd +} + +func NewRegisterCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "register", + Short: "Register a voter", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, args []string) error { + // bypass the restriction of set keyring options + ctx := client.GetClientContextFromCmd(cmd).WithKeyringOptions(vrf.VrfOption()) + client.SetCmdClientContext(cmd, ctx) + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + kr := clientCtx.Keyring + // get account name by address + accAddr := clientCtx.GetFromAddress() + accRecord, err := kr.KeyByAddress(accAddr) + if err != nil { + // not found record by address in keyring + return nil + } + + // check voter account record exists + voterAccName := accRecord.Name + "-voter" + _, err = kr.Key(voterAccName) + if err == nil { + // account exists, ask for user confirmation + response, err2 := input.GetConfirmation(fmt.Sprintf("override the existing name %s", voterAccName), bufio.NewReader(clientCtx.Input), cmd.ErrOrStderr()) + if err2 != nil { + return err2 + } + + if !response { + return errors.New("aborted") + } + + err2 = kr.Delete(voterAccName) + if err2 != nil { + return err2 + } + } + + keyringAlgos, _ := kr.SupportedAlgorithms() + algo, err := sdkkr.NewSigningAlgoFromString("vrf", keyringAlgos) + if err != nil { + return err + } + + newRecord, err := kr.NewAccount(voterAccName, "", "", "", algo) + if err != nil { + return err + } + + pubKey, err := newRecord.GetPubKey() + if err != nil { + return err + } + + valAddr, err := sdk.ValAddressFromHex(hex.EncodeToString(clientCtx.GetFromAddress().Bytes())) + if err != nil { + return err + } + + msg := &types.MsgRegister{ + Voter: valAddr.String(), + Key: pubKey.Bytes(), + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} + +func NewVoteCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "vote council-id", + Short: "Vote on a proposal", + Args: cobra.MinimumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + kr := clientCtx.Keyring + + // get account name by address + inAddr := clientCtx.GetFromAddress() + + valAddr, err := sdk.ValAddressFromHex(hex.EncodeToString(inAddr.Bytes())) + if err != nil { + return err + } + + inRecord, err := kr.KeyByAddress(inAddr) + if err != nil { + // not found record by address in keyring + return nil + } + + // check voter account record exists + voterAccName := inRecord.Name + "-voter" + voterRecord, err := kr.Key(voterAccName) + if err != nil { + // not found voter account + return err + } + sk := vrfalgo.PrivateKey(voterRecord.GetLocal().PrivKey.Value) + + councilID, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + votingStartHeight := types.DefaultVotingStartHeight + (councilID-1)*types.DefaultVotingPeriod + + rsp, err := stakingtypes.NewQueryClient(clientCtx).HistoricalInfo(cmd.Context(), &stakingtypes.QueryHistoricalInfoRequest{Height: int64(votingStartHeight)}) + if err != nil { + return err + } + + var tokens sdkmath.Int + for _, val := range rsp.Hist.Valset { + thisValAddr := val.GetOperator() + + if thisValAddr.Equals(valAddr) { + tokens = val.GetTokens() + } + } + // the denom of token is neuron, need to convert to A0GI + a0gi := tokens.Quo(sdk.NewInt(1_000_000_000_000_000_000)) + // 1_000 0AGI token / vote + numBallots := a0gi.Quo(sdk.NewInt(1_000)).Uint64() + ballots := make([]*types.Ballot, numBallots) + for i := range ballots { + ballotID := uint64(i) + ballots[i] = &types.Ballot{ + ID: ballotID, + Content: sk.Compute(bytes.Join([][]byte{rsp.Hist.Header.LastCommitHash, types.Uint64ToBytes(ballotID)}, nil)), + } + } + + msg := &types.MsgVote{ + CouncilID: councilID, + Voter: valAddr.String(), + Ballots: ballots, + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/council/v1/genesis.go b/x/council/v1/genesis.go new file mode 100644 index 00000000..03d99c3d --- /dev/null +++ b/x/council/v1/genesis.go @@ -0,0 +1,56 @@ +package council + +import ( + "fmt" + + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/0glabs/0g-chain/x/council/v1/keeper" + "github.com/0glabs/0g-chain/x/council/v1/types" +) + +// InitGenesis initializes the store state from a genesis state. +func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, gs types.GenesisState) { + if err := gs.Validate(); err != nil { + panic(fmt.Sprintf("failed to validate %s genesis state: %s", types.ModuleName, err)) + } + + params := gs.Params + err := keeper.SetParams(ctx, params) + if err != nil { + panic(errorsmod.Wrapf(err, "error setting params")) + } + + keeper.SetCurrentCouncilID(ctx, gs.CurrentCouncilID) + + for _, p := range gs.Councils { + keeper.SetCouncil(ctx, p) + } +} + +// ExportGenesis returns a GenesisState for a given context and keeper. +func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) *types.GenesisState { + startHeight, err := keeper.GetVotingStartHeight(ctx) + if err != nil { + panic(err) + } + + period, err := keeper.GetVotingPeriod(ctx) + if err != nil { + panic(err) + } + + currentID, err := keeper.GetCurrentCouncilID(ctx) + if err != nil { + panic(err) + } + + return types.NewGenesisState( + keeper.GetParams(ctx), + startHeight, + period, + currentID, + keeper.GetCouncils(ctx), + ) +} diff --git a/x/council/v1/keeper/abci.go b/x/council/v1/keeper/abci.go new file mode 100644 index 00000000..9c194722 --- /dev/null +++ b/x/council/v1/keeper/abci.go @@ -0,0 +1,72 @@ +package keeper + +import ( + "sort" + + sdk "github.com/cosmos/cosmos-sdk/types" + abci "github.com/tendermint/tendermint/abci/types" +) + +type Ballot struct { + voter sdk.ValAddress + content string +} + +func (k *Keeper) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) { + councilID, err := k.GetCurrentCouncilID(ctx) + if err != nil { + // TODO: handle the case where councilID is not available + return + } + council, bz := k.GetCouncil(ctx, councilID) + if !bz { + return + } + + if ctx.BlockHeight() >= int64(council.StartHeight) { + // We are ready to accept votes for the next council + if err := k.StoreNewCouncil(ctx, council.StartHeight); err != nil { + return + } + } + + if ctx.BlockHeight() < int64(council.EndHeight) { + return + } + + k.IncrementCurrentCouncilID(ctx) + council, bz = k.GetCouncil(ctx, councilID+1) + if !bz { + return + } + + ballots := []Ballot{} + seen := make(map[string]struct{}) + for _, vote := range council.Votes { + for _, ballot := range vote.Ballots { + ballot := Ballot{ + voter: vote.Voter, + content: string(ballot.Content), + } + if _, ok := seen[ballot.content]; ok { + continue + } + ballots = append(ballots, ballot) + seen[ballot.content] = struct{}{} + } + } + sort.Slice(ballots, func(i, j int) bool { + return ballots[i].content < ballots[j].content + }) + + councilSize := k.GetParams(ctx).CouncilSize + council.Members = make([]sdk.ValAddress, councilSize) + for i := 0; i < int(councilSize); i = i + 1 { + council.Members[i] = ballots[i].voter + } + + k.SetCouncil(ctx, council) +} + +func (k *Keeper) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) { +} diff --git a/x/council/v1/keeper/grpc_query.go b/x/council/v1/keeper/grpc_query.go new file mode 100644 index 00000000..4dd0e69d --- /dev/null +++ b/x/council/v1/keeper/grpc_query.go @@ -0,0 +1,35 @@ +package keeper + +import ( + "context" + + "github.com/0glabs/0g-chain/x/council/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var _ types.QueryServer = Keeper{} + +func (k Keeper) CurrentCouncilID( + c context.Context, + _ *types.QueryCurrentCouncilIDRequest, +) (*types.QueryCurrentCouncilIDResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + currentCouncilID, err := k.GetCurrentCouncilID(ctx) + if err != nil { + return nil, err + } + return &types.QueryCurrentCouncilIDResponse{CurrentCouncilID: currentCouncilID}, nil +} + +func (k Keeper) RegisteredVoters( + c context.Context, + _ *types.QueryRegisteredVotersRequest, +) (*types.QueryRegisteredVotersResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + voterAddrs := k.GetVoters(ctx) + voters := make([]string, len(voterAddrs)) + for i, voterAddr := range voterAddrs { + voters[i] = voterAddr.String() + } + return &types.QueryRegisteredVotersResponse{Voters: voters}, nil +} diff --git a/x/council/v1/keeper/keeper.go b/x/council/v1/keeper/keeper.go new file mode 100644 index 00000000..21ae9c8f --- /dev/null +++ b/x/council/v1/keeper/keeper.go @@ -0,0 +1,323 @@ +package keeper + +import ( + "fmt" + + errorsmod "cosmossdk.io/errors" + "github.com/coniks-sys/coniks-go/crypto/vrf" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/store/prefix" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/tendermint/tendermint/libs/log" + + "github.com/0glabs/0g-chain/x/council/v1/types" +) + +// Keeper of the inflation store +type Keeper struct { + storeKey storetypes.StoreKey + cdc codec.BinaryCodec + stakingKeeper types.StakingKeeper +} + +// NewKeeper creates a new mint Keeper instance +func NewKeeper( + storeKey storetypes.StoreKey, + cdc codec.BinaryCodec, + stakingKeeper types.StakingKeeper, +) Keeper { + return Keeper{ + storeKey: storeKey, + cdc: cdc, + stakingKeeper: stakingKeeper, + } +} + +// Logger returns a module-specific logger. +func (k Keeper) Logger(ctx sdk.Context) log.Logger { + return ctx.Logger().With("module", "x/"+types.ModuleName) +} + +// ------------------------------------------ +// Councils +// ------------------------------------------ + +func (k Keeper) SetCurrentCouncilID(ctx sdk.Context, id uint64) { + store := ctx.KVStore(k.storeKey) + store.Set(types.CurrentCouncilIDKey, types.GetKeyFromID(id)) +} + +func (k Keeper) GetCurrentCouncilID(ctx sdk.Context) (uint64, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.CurrentCouncilIDKey) + if bz == nil { + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "current council ID not set at genesis") + } + return types.Uint64FromBytes(bz), nil +} + +func (k Keeper) IncrementCurrentCouncilID(ctx sdk.Context) error { + id, err := k.GetCurrentCouncilID(ctx) + if err != nil { + return err + } + k.SetCurrentCouncilID(ctx, id+1) + return nil +} + +func (k Keeper) SetVotingStartHeight(ctx sdk.Context, votingStartHeight uint64) { + store := ctx.KVStore(k.storeKey) + store.Set(types.VotingStartHeightKey, types.GetKeyFromID(votingStartHeight)) +} + +func (k Keeper) GetVotingStartHeight(ctx sdk.Context) (uint64, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.VotingStartHeightKey) + if bz == nil { + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "voting start height not set at genesis") + } + return types.Uint64FromBytes(bz), nil +} + +func (k Keeper) SetVotingPeriod(ctx sdk.Context, votingPeriod uint64) { + store := ctx.KVStore(k.storeKey) + store.Set(types.VotingPeriodKey, types.GetKeyFromID(votingPeriod)) +} + +func (k Keeper) GetVotingPeriod(ctx sdk.Context) (uint64, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.VotingPeriodKey) + if bz == nil { + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "voting period not set at genesis") + } + return types.Uint64FromBytes(bz), nil +} + +// StoreNewCouncil stores a council, adding a new ID +func (k Keeper) StoreNewCouncil(ctx sdk.Context, votingStartHeight uint64) error { + currentCouncilID, err := k.GetCurrentCouncilID(ctx) + if err != nil { + return err + } + + votingPeriod, err := k.GetVotingPeriod(ctx) + if err != nil { + return err + } + com := types.Council{ + ID: currentCouncilID + 1, + VotingStartHeight: votingStartHeight, + StartHeight: votingStartHeight + votingPeriod, + EndHeight: votingStartHeight + votingPeriod*2, + Votes: []types.Vote{}, + Members: []sdk.ValAddress{}, + } + k.SetCouncil(ctx, com) + + return nil +} + +func (k Keeper) GetCouncil(ctx sdk.Context, councilID uint64) (types.Council, bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.CouncilKeyPrefix) + bz := store.Get(types.GetKeyFromID(councilID)) + if bz == nil { + return types.Council{}, false + } + var com types.Council + k.cdc.MustUnmarshal(bz, &com) + return com, true +} + +// SetCouncil puts a council into the store. +func (k Keeper) SetCouncil(ctx sdk.Context, council types.Council) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.CouncilKeyPrefix) + bz := k.cdc.MustMarshal(&council) + store.Set(types.GetKeyFromID(council.ID), bz) +} + +// // DeleteProposal removes a proposal from the store. +// func (k Keeper) DeleteProposal(ctx sdk.Context, proposalID uint64) { +// store := prefix.NewStore(ctx.KVStore(k.storeKey), types.ProposalKeyPrefix) +// store.Delete(types.GetKeyFromID(proposalID)) +// } + +// IterateProposals provides an iterator over all stored proposals. +// For each proposal, cb will be called. If cb returns true, the iterator will close and stop. +func (k Keeper) IterateCouncil(ctx sdk.Context, cb func(proposal types.Council) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.CouncilKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var council types.Council + k.cdc.MustUnmarshal(iterator.Value(), &council) + if cb(council) { + break + } + } +} + +func (k Keeper) GetCouncils(ctx sdk.Context) types.Councils { + results := types.Councils{} + k.IterateCouncil(ctx, func(prop types.Council) bool { + results = append(results, prop) + return false + }) + return results +} + +// // DeleteProposalAndVotes removes a proposal and its associated votes. +// func (k Keeper) DeleteProposalAndVotes(ctx sdk.Context, proposalID uint64) { +// votes := k.GetVotesByProposal(ctx, proposalID) +// k.DeleteProposal(ctx, proposalID) +// for _, v := range votes { +// k.DeleteVote(ctx, v.ProposalID, v.Voter) +// } +// } + +// ------------------------------------------ +// Votes +// ------------------------------------------ + +// GetVote gets a vote from the store. +func (k Keeper) GetVote(ctx sdk.Context, epochID uint64, voter sdk.ValAddress) (types.Vote, bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VoteKeyPrefix) + bz := store.Get(types.GetVoteKey(epochID, voter)) + if bz == nil { + return types.Vote{}, false + } + var vote types.Vote + k.cdc.MustUnmarshal(bz, &vote) + return vote, true +} + +// SetVote puts a vote into the store. +func (k Keeper) SetVote(ctx sdk.Context, vote types.Vote) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VoteKeyPrefix) + bz := k.cdc.MustMarshal(&vote) + store.Set(types.GetVoteKey(vote.CouncilID, vote.Voter), bz) +} + +// DeleteVote removes a Vote from the store. +func (k Keeper) DeleteVote(ctx sdk.Context, councilID uint64, voter sdk.ValAddress) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VoteKeyPrefix) + store.Delete(types.GetVoteKey(councilID, voter)) +} + +// IterateVotes provides an iterator over all stored votes. +// For each vote, cb will be called. If cb returns true, the iterator will close and stop. +func (k Keeper) IterateVotes(ctx sdk.Context, cb func(vote types.Vote) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.VoteKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var vote types.Vote + k.cdc.MustUnmarshal(iterator.Value(), &vote) + + if cb(vote) { + break + } + } +} + +// GetVotes returns all stored votes. +func (k Keeper) GetVotes(ctx sdk.Context) []types.Vote { + results := []types.Vote{} + k.IterateVotes(ctx, func(vote types.Vote) bool { + results = append(results, vote) + return false + }) + return results +} + +// GetVotesByProposal returns all votes for one proposal. +func (k Keeper) GetVotesByCouncil(ctx sdk.Context, councilID uint64) []types.Vote { + results := []types.Vote{} + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), append(types.VoteKeyPrefix, types.GetKeyFromID(councilID)...)) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var vote types.Vote + k.cdc.MustUnmarshal(iterator.Value(), &vote) + results = append(results, vote) + } + + return results +} + +// ------------------------------------------ +// Voters +// ------------------------------------------ + +func (k Keeper) SetVoter(ctx sdk.Context, voter sdk.ValAddress, pk vrf.PublicKey) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VoterKeyPrefix) + store.Set(types.GetVoterKey(voter), pk) + fmt.Printf("voterStoreKey: %v, publicKey: %v\n", types.GetVoterKey(voter), pk) +} + +func (k Keeper) IterateVoters(ctx sdk.Context, cb func(voter sdk.ValAddress, pk vrf.PublicKey) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.VoterKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + if cb(sdk.ValAddress(iterator.Key()[1:]), vrf.PublicKey(iterator.Value())) { + break + } + } +} + +// GetVotes returns all stored voters +func (k Keeper) GetVoters(ctx sdk.Context) []sdk.ValAddress { + results := []sdk.ValAddress{} + k.IterateVoters(ctx, func(voter sdk.ValAddress, _ vrf.PublicKey) bool { + results = append(results, voter) + return false + }) + return results +} + +func (k Keeper) AddVoter(ctx sdk.Context, voter sdk.ValAddress, key []byte) error { + if len(key) != vrf.PublicKeySize { + return types.ErrInvalidPublicKey + } + + k.SetVoter(ctx, voter, vrf.PublicKey(key)) + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeRegister, + sdk.NewAttribute(types.AttributeKeyVoter, voter.String()), + // TODO: types.AttributeKeyPublicKey + ), + ) + + return nil +} + +func (k Keeper) AddVote(ctx sdk.Context, councilID uint64, voter sdk.ValAddress, ballots []*types.Ballot) error { + // Validate + com, found := k.GetCouncil(ctx, councilID) + if !found { + return errorsmod.Wrapf(types.ErrUnknownCouncil, "%d", councilID) + } + if com.HasVotingEndedBy(ctx.BlockHeight()) { + return errorsmod.Wrapf(types.ErrProposalExpired, "%d ≥ %d", ctx.BlockHeight(), com.StartHeight) + } + + // TODO: verify if the voter is registered + // TODO: verify whether ballots are valid or not + + // Store vote, overwriting any prior vote + k.SetVote(ctx, types.NewVote(councilID, voter, ballots)) + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeVote, + sdk.NewAttribute(types.AttributeKeyCouncilID, fmt.Sprintf("%d", com.ID)), + sdk.NewAttribute(types.AttributeKeyVoter, voter.String()), + // TODO: types.AttributeKeyBallots + ), + ) + + return nil +} diff --git a/x/council/v1/keeper/msg_server.go b/x/council/v1/keeper/msg_server.go new file mode 100644 index 00000000..6dbf56f0 --- /dev/null +++ b/x/council/v1/keeper/msg_server.go @@ -0,0 +1,51 @@ +// Copyright Tharsis Labs Ltd.(Evmos) +// SPDX-License-Identifier:ENCL-1.0(https://github.com/evmos/evmos/blob/main/LICENSE) + +package keeper + +import ( + "context" + + "github.com/0glabs/0g-chain/x/council/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +var _ types.MsgServer = &Keeper{} + +// Register handles MsgRegister messages +func (k Keeper) Register(goCtx context.Context, msg *types.MsgRegister) (*types.MsgRegisterResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + valAddr, err := sdk.ValAddressFromBech32(msg.Voter) + if err != nil { + return nil, err + } + + _, found := k.stakingKeeper.GetValidator(ctx, valAddr) + if !found { + return nil, stakingtypes.ErrNoValidatorFound + } + + if err := k.AddVoter(ctx, valAddr, msg.Key); err != nil { + return nil, err + } + + return &types.MsgRegisterResponse{}, nil +} + +// Vote handles MsgVote messages +func (k Keeper) Vote(goCtx context.Context, msg *types.MsgVote) (*types.MsgVoteResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + voter, err := sdk.ValAddressFromBech32(msg.Voter) + if err != nil { + return nil, err + } + + if err := k.AddVote(ctx, msg.CouncilID, voter, msg.Ballots); err != nil { + return nil, err + } + + return &types.MsgVoteResponse{}, nil +} diff --git a/x/council/v1/keeper/params.go b/x/council/v1/keeper/params.go new file mode 100644 index 00000000..9294fc19 --- /dev/null +++ b/x/council/v1/keeper/params.go @@ -0,0 +1,29 @@ +package keeper + +import ( + "github.com/0glabs/0g-chain/x/council/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.ParamsKey) + if len(bz) == 0 { + return params + } + + k.cdc.MustUnmarshal(bz, ¶ms) + return params +} + +func (k Keeper) SetParams(ctx sdk.Context, params types.Params) error { + store := ctx.KVStore(k.storeKey) + bz, err := k.cdc.Marshal(¶ms) + if err != nil { + return err + } + + store.Set(types.ParamsKey, bz) + + return nil +} diff --git a/x/council/v1/module.go b/x/council/v1/module.go new file mode 100644 index 00000000..008d3db9 --- /dev/null +++ b/x/council/v1/module.go @@ -0,0 +1,182 @@ +package council + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + "github.com/gorilla/mux" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/spf13/cobra" + abci "github.com/tendermint/tendermint/abci/types" + + "github.com/0glabs/0g-chain/x/council/v1/client/cli" + "github.com/0glabs/0g-chain/x/council/v1/keeper" + "github.com/0glabs/0g-chain/x/council/v1/types" +) + +// consensusVersion defines the current x/council module consensus version. +const consensusVersion = 1 + +// type check to ensure the interface is properly implemented +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} + // _ module.AppModuleSimulation = AppModule{} + _ module.BeginBlockAppModule = AppModule{} + _ module.EndBlockAppModule = AppModule{} +) + +// app module Basics object +type AppModuleBasic struct{} + +// Name returns the inflation module's name. +func (AppModuleBasic) Name() string { + return types.ModuleName +} + +// RegisterLegacyAminoCodec registers the inflation module's types on the given LegacyAmino codec. +func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {} + +// ConsensusVersion returns the consensus state-breaking version for the module. +func (AppModuleBasic) ConsensusVersion() uint64 { + return consensusVersion +} + +// RegisterInterfaces registers interfaces and implementations of the incentives +// module. +func (AppModuleBasic) RegisterInterfaces(interfaceRegistry codectypes.InterfaceRegistry) { + types.RegisterInterfaces(interfaceRegistry) +} + +// DefaultGenesis returns default genesis state as raw bytes for the incentives +// module. +func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { + return cdc.MustMarshalJSON(types.DefaultGenesisState()) +} + +// ValidateGenesis performs genesis state validation for the inflation module. +func (b AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, _ client.TxEncodingConfig, bz json.RawMessage) error { + var genesisState types.GenesisState + if err := cdc.UnmarshalJSON(bz, &genesisState); err != nil { + return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) + } + + return genesisState.Validate() +} + +// RegisterRESTRoutes performs a no-op as the inflation module doesn't expose REST +// endpoints +func (AppModuleBasic) RegisterRESTRoutes(_ client.Context, _ *mux.Router) {} + +// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the inflation module. +func (b AppModuleBasic) RegisterGRPCGatewayRoutes(c client.Context, serveMux *runtime.ServeMux) { + if err := types.RegisterQueryHandlerClient(context.Background(), serveMux, types.NewQueryClient(c)); err != nil { + panic(err) + } +} + +// GetTxCmd returns the root tx command for the inflation module. +func (AppModuleBasic) GetTxCmd() *cobra.Command { return cli.GetTxCmd() } + +// GetQueryCmd returns no root query command for the inflation module. +func (AppModuleBasic) GetQueryCmd() *cobra.Command { + return cli.GetQueryCmd() +} + +// ___________________________________________________________________________ + +// AppModule implements an application module for the inflation module. +type AppModule struct { + AppModuleBasic + keeper keeper.Keeper + sk stakingkeeper.Keeper +} + +// NewAppModule creates a new AppModule Object +func NewAppModule( + k keeper.Keeper, + sk stakingkeeper.Keeper, +) AppModule { + return AppModule{ + AppModuleBasic: AppModuleBasic{}, + keeper: k, + sk: sk, + } +} + +// Name returns the inflation module's name. +func (AppModule) Name() string { + return types.ModuleName +} + +// Route returns evmutil module's message route. +func (am AppModule) Route() sdk.Route { return sdk.Route{} } + +// QuerierRoute returns evmutil module's query routing key. +func (AppModule) QuerierRoute() string { return "" } + +// LegacyQuerierHandler returns evmutil module's Querier. +func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sdk.Querier { + return nil +} + +// RegisterInvariants registers the inflation module invariants. +func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {} + +// RegisterServices registers a gRPC query service to respond to the +// module-specific gRPC queries. +func (am AppModule) RegisterServices(cfg module.Configurator) { + types.RegisterMsgServer(cfg.MsgServer(), am.keeper) + types.RegisterQueryServer(cfg.QueryServer(), am.keeper) +} + +func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) { + am.keeper.BeginBlock(ctx, req) +} + +func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate { + am.keeper.EndBlock(ctx, req) + return []abci.ValidatorUpdate{} +} + +// InitGenesis performs genesis initialization for the inflation module. It returns +// no validator updates. +func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate { + var genesisState types.GenesisState + + cdc.MustUnmarshalJSON(data, &genesisState) + InitGenesis(ctx, am.keeper, genesisState) + return []abci.ValidatorUpdate{} +} + +// ExportGenesis returns the exported genesis state as raw bytes for the inflation +// module. +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + gs := ExportGenesis(ctx, am.keeper) + return cdc.MustMarshalJSON(gs) +} + +// ___________________________________________________________________________ + +// AppModuleSimulation functions + +// GenerateGenesisState creates a randomized GenState of the inflation module. +func (am AppModule) GenerateGenesisState(_ *module.SimulationState) { +} + +// RegisterStoreDecoder registers a decoder for inflation module's types. +func (am AppModule) RegisterStoreDecoder(_ sdk.StoreDecoderRegistry) { +} + +// WeightedOperations doesn't return any inflation module operation. +func (am AppModule) WeightedOperations(_ module.SimulationState) []simtypes.WeightedOperation { + return []simtypes.WeightedOperation{} +} diff --git a/x/council/v1/types/codec.go b/x/council/v1/types/codec.go new file mode 100644 index 00000000..fd2b1071 --- /dev/null +++ b/x/council/v1/types/codec.go @@ -0,0 +1,52 @@ +package types + +import ( + "github.com/0glabs/0g-chain/crypto/vrf" + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/msgservice" +) + +var ( + amino = codec.NewLegacyAmino() + // ModuleCdc references the global evm module codec. Note, the codec should + // ONLY be used in certain instances of tests and for JSON encoding. + ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry()) + + // AminoCdc is a amino codec created to support amino JSON compatible msgs. + AminoCdc = codec.NewAminoCodec(amino) +) + +const ( + // Amino names + registerName = "evmos/council/MsgRegister" + voteName = "evmos/council/MsgVote" +) + +// NOTE: This is required for the GetSignBytes function +func init() { + RegisterLegacyAminoCodec(amino) + amino.Seal() +} + +// RegisterInterfaces register implementations +func RegisterInterfaces(registry codectypes.InterfaceRegistry) { + registry.RegisterImplementations( + (*sdk.Msg)(nil), + &MsgRegister{}, + &MsgVote{}, + ) + + registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &vrf.PubKey{}) + registry.RegisterImplementations((*cryptotypes.PrivKey)(nil), &vrf.PrivKey{}) + + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) +} + +// RegisterLegacyAminoCodec required for EIP-712 +func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgRegister{}, registerName, nil) + cdc.RegisterConcrete(&MsgVote{}, voteName, nil) +} diff --git a/x/council/v1/types/council.go b/x/council/v1/types/council.go new file mode 100644 index 00000000..b422974d --- /dev/null +++ b/x/council/v1/types/council.go @@ -0,0 +1,21 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) + +type Councils []Council +type Votes []Vote + +func (c Council) HasVotingEndedBy(height int64) bool { + return height >= int64(c.StartHeight) +} + +// NewVote instantiates a new instance of Vote +func NewVote(councilID uint64, voter sdk.ValAddress, ballots []*Ballot) Vote { + return Vote{ + CouncilID: councilID, + Voter: voter, + Ballots: ballots, + } +} diff --git a/x/council/v1/types/epoch.go b/x/council/v1/types/epoch.go new file mode 100644 index 00000000..d44612a1 --- /dev/null +++ b/x/council/v1/types/epoch.go @@ -0,0 +1,3 @@ +package types + +type Epoch struct{} diff --git a/x/council/v1/types/errors.go b/x/council/v1/types/errors.go new file mode 100644 index 00000000..75f54e93 --- /dev/null +++ b/x/council/v1/types/errors.go @@ -0,0 +1,19 @@ +package types + +import errorsmod "cosmossdk.io/errors" + +var ( + ErrUnknownCouncil = errorsmod.Register(ModuleName, 2, "council not found") + ErrInvalidCouncil = errorsmod.Register(ModuleName, 3, "invalid council") + ErrUnknownProposal = errorsmod.Register(ModuleName, 4, "proposal not found") + ErrProposalExpired = errorsmod.Register(ModuleName, 5, "proposal expired") + ErrInvalidPubProposal = errorsmod.Register(ModuleName, 6, "invalid pubproposal") + ErrUnknownVote = errorsmod.Register(ModuleName, 7, "vote not found") + ErrInvalidGenesis = errorsmod.Register(ModuleName, 8, "invalid genesis") + ErrNoProposalHandlerExists = errorsmod.Register(ModuleName, 9, "pubproposal has no corresponding handler") + ErrUnknownSubspace = errorsmod.Register(ModuleName, 10, "subspace not found") + ErrInvalidVoteType = errorsmod.Register(ModuleName, 11, "invalid vote type") + ErrNotFoundProposalTally = errorsmod.Register(ModuleName, 12, "proposal tally not found") + ErrInvalidPublicKey = errorsmod.Register(ModuleName, 13, "invalid public key") + ErrInvalidValidatorAddress = errorsmod.Register(ModuleName, 14, "invalid validator address") +) diff --git a/x/council/v1/types/events.go b/x/council/v1/types/events.go new file mode 100644 index 00000000..99485e5a --- /dev/null +++ b/x/council/v1/types/events.go @@ -0,0 +1,19 @@ +package types + +// Module event types +const ( + EventTypeRegister = "register" + EventTypeVote = "vote" + + AttributeValueCategory = "council" + AttributeKeyCouncilID = "council_id" + AttributeKeyProposalID = "proposal_id" + AttributeKeyVotingStartHeight = "voting_start_height" + AttributeKeyVotingEndHeight = "voting_end_height" + AttributeKeyProposalCloseStatus = "status" + AttributeKeyVoter = "voter" + AttributeKeyBallots = "ballots" + AttributeKeyPublicKey = "public_key" + AttributeKeyProposalOutcome = "proposal_outcome" + AttributeKeyProposalTally = "proposal_tally" +) diff --git a/x/council/v1/types/genesis.go b/x/council/v1/types/genesis.go new file mode 100644 index 00000000..ae187511 --- /dev/null +++ b/x/council/v1/types/genesis.go @@ -0,0 +1,42 @@ +package types + +const ( + DefaultVotingStartHeight = 1 + DefaultVotingPeriod = 200 +) + +// NewGenesisState returns a new genesis state object for the module. +func NewGenesisState(params Params, votingStartHeight uint64, votingPeriod uint64, currentCouncilID uint64, councils Councils) *GenesisState { + return &GenesisState{ + Params: params, + VotingStartHeight: votingStartHeight, + VotingPeriod: votingPeriod, + CurrentCouncilID: currentCouncilID, + Councils: councils, + } +} + +// DefaultGenesisState returns the default genesis state for the module. +func DefaultGenesisState() *GenesisState { + return NewGenesisState( + Params{ + CouncilSize: 1, + }, + DefaultVotingStartHeight, + DefaultVotingPeriod, + 1, + []Council{ + { + ID: 1, + VotingStartHeight: DefaultVotingStartHeight, + StartHeight: DefaultVotingStartHeight + DefaultVotingPeriod, + EndHeight: DefaultVotingStartHeight + DefaultVotingPeriod*2, + Votes: Votes{}, + }}, + ) +} + +// Validate performs basic validation of genesis data. +func (gs GenesisState) Validate() error { + return nil +} diff --git a/x/council/v1/types/genesis.pb.go b/x/council/v1/types/genesis.pb.go new file mode 100644 index 00000000..4001ae52 --- /dev/null +++ b/x/council/v1/types/genesis.pb.go @@ -0,0 +1,1467 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgc/council/v1/genesis.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Params struct { + CouncilSize uint64 `protobuf:"varint,1,opt,name=council_size,json=councilSize,proto3" json:"council_size,omitempty"` +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_35f7661c22f951dd, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +func (m *Params) GetCouncilSize() uint64 { + if m != nil { + return m.CouncilSize + } + return 0 +} + +// GenesisState defines the council module's genesis state. +type GenesisState struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + VotingStartHeight uint64 `protobuf:"varint,2,opt,name=voting_start_height,json=votingStartHeight,proto3" json:"voting_start_height,omitempty"` + VotingPeriod uint64 `protobuf:"varint,3,opt,name=voting_period,json=votingPeriod,proto3" json:"voting_period,omitempty"` + CurrentCouncilID uint64 `protobuf:"varint,4,opt,name=current_council_id,json=currentCouncilId,proto3" json:"current_council_id,omitempty"` + Councils []Council `protobuf:"bytes,5,rep,name=councils,proto3" json:"councils"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_35f7661c22f951dd, []int{1} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +type Council struct { + ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + VotingStartHeight uint64 `protobuf:"varint,2,opt,name=voting_start_height,json=votingStartHeight,proto3" json:"voting_start_height,omitempty"` + StartHeight uint64 `protobuf:"varint,3,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` + EndHeight uint64 `protobuf:"varint,4,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"` + Votes []Vote `protobuf:"bytes,5,rep,name=votes,proto3" json:"votes"` + Members []github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,6,rep,name=members,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"members,omitempty"` +} + +func (m *Council) Reset() { *m = Council{} } +func (m *Council) String() string { return proto.CompactTextString(m) } +func (*Council) ProtoMessage() {} +func (*Council) Descriptor() ([]byte, []int) { + return fileDescriptor_35f7661c22f951dd, []int{2} +} +func (m *Council) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Council) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Council.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 *Council) XXX_Merge(src proto.Message) { + xxx_messageInfo_Council.Merge(m, src) +} +func (m *Council) XXX_Size() int { + return m.Size() +} +func (m *Council) XXX_DiscardUnknown() { + xxx_messageInfo_Council.DiscardUnknown(m) +} + +var xxx_messageInfo_Council proto.InternalMessageInfo + +func (m *Council) GetID() uint64 { + if m != nil { + return m.ID + } + return 0 +} + +func (m *Council) GetVotingStartHeight() uint64 { + if m != nil { + return m.VotingStartHeight + } + return 0 +} + +func (m *Council) GetStartHeight() uint64 { + if m != nil { + return m.StartHeight + } + return 0 +} + +func (m *Council) GetEndHeight() uint64 { + if m != nil { + return m.EndHeight + } + return 0 +} + +func (m *Council) GetVotes() []Vote { + if m != nil { + return m.Votes + } + return nil +} + +func (m *Council) GetMembers() []github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.Members + } + return nil +} + +type Vote struct { + CouncilID uint64 `protobuf:"varint,1,opt,name=council_id,json=councilId,proto3" json:"council_id,omitempty"` + Voter github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=voter,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"voter,omitempty"` + Ballots []*Ballot `protobuf:"bytes,3,rep,name=ballots,proto3" json:"ballots,omitempty"` +} + +func (m *Vote) Reset() { *m = Vote{} } +func (m *Vote) String() string { return proto.CompactTextString(m) } +func (*Vote) ProtoMessage() {} +func (*Vote) Descriptor() ([]byte, []int) { + return fileDescriptor_35f7661c22f951dd, []int{3} +} +func (m *Vote) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Vote.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 *Vote) XXX_Merge(src proto.Message) { + xxx_messageInfo_Vote.Merge(m, src) +} +func (m *Vote) XXX_Size() int { + return m.Size() +} +func (m *Vote) XXX_DiscardUnknown() { + xxx_messageInfo_Vote.DiscardUnknown(m) +} + +var xxx_messageInfo_Vote proto.InternalMessageInfo + +type Ballot struct { + ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` +} + +func (m *Ballot) Reset() { *m = Ballot{} } +func (m *Ballot) String() string { return proto.CompactTextString(m) } +func (*Ballot) ProtoMessage() {} +func (*Ballot) Descriptor() ([]byte, []int) { + return fileDescriptor_35f7661c22f951dd, []int{4} +} +func (m *Ballot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Ballot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Ballot.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 *Ballot) XXX_Merge(src proto.Message) { + xxx_messageInfo_Ballot.Merge(m, src) +} +func (m *Ballot) XXX_Size() int { + return m.Size() +} +func (m *Ballot) XXX_DiscardUnknown() { + xxx_messageInfo_Ballot.DiscardUnknown(m) +} + +var xxx_messageInfo_Ballot proto.InternalMessageInfo + +func (m *Ballot) GetID() uint64 { + if m != nil { + return m.ID + } + return 0 +} + +func (m *Ballot) GetContent() []byte { + if m != nil { + return m.Content + } + return nil +} + +func init() { + proto.RegisterType((*Params)(nil), "zgc.council.v1.Params") + proto.RegisterType((*GenesisState)(nil), "zgc.council.v1.GenesisState") + proto.RegisterType((*Council)(nil), "zgc.council.v1.Council") + proto.RegisterType((*Vote)(nil), "zgc.council.v1.Vote") + proto.RegisterType((*Ballot)(nil), "zgc.council.v1.Ballot") +} + +func init() { proto.RegisterFile("zgc/council/v1/genesis.proto", fileDescriptor_35f7661c22f951dd) } + +var fileDescriptor_35f7661c22f951dd = []byte{ + // 594 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x3f, 0x6f, 0xd3, 0x4e, + 0x1c, 0xc6, 0x63, 0x27, 0x75, 0x7e, 0xbd, 0xb8, 0x3f, 0x95, 0x6b, 0x55, 0xdc, 0x0a, 0xec, 0x36, + 0x2c, 0x95, 0x20, 0x76, 0x5a, 0x58, 0xe8, 0x86, 0x5b, 0xa9, 0xed, 0x56, 0xb9, 0x52, 0x07, 0x06, + 0x22, 0xff, 0x39, 0x2e, 0x27, 0x6c, 0x5f, 0xe4, 0xbb, 0x44, 0x34, 0xaf, 0x80, 0x91, 0x57, 0x80, + 0x58, 0xd9, 0x79, 0x11, 0x1d, 0x18, 0x2a, 0x26, 0xa6, 0x08, 0x39, 0xef, 0x82, 0x09, 0xe5, 0xee, + 0x5c, 0x92, 0x20, 0x06, 0x24, 0x26, 0xfb, 0x9e, 0xe7, 0x73, 0x7f, 0x9e, 0xef, 0xf7, 0x6c, 0xf0, + 0x60, 0x8c, 0x63, 0x2f, 0xa6, 0xc3, 0x3c, 0x26, 0xa9, 0x37, 0x3a, 0xf0, 0x30, 0xca, 0x11, 0x23, + 0xcc, 0x1d, 0x14, 0x94, 0x53, 0xf8, 0xff, 0x18, 0xc7, 0xae, 0x72, 0xdd, 0xd1, 0xc1, 0xce, 0x76, + 0x4c, 0x59, 0x46, 0x59, 0x4f, 0xb8, 0x9e, 0x1c, 0x48, 0x74, 0x67, 0x13, 0x53, 0x4c, 0xa5, 0x3e, + 0x7b, 0x53, 0xea, 0x36, 0xa6, 0x14, 0xa7, 0xc8, 0x13, 0xa3, 0x68, 0xf8, 0xda, 0x0b, 0xf3, 0x6b, + 0x65, 0x39, 0xcb, 0x16, 0x27, 0x19, 0x62, 0x3c, 0xcc, 0x06, 0x12, 0x68, 0x3f, 0x06, 0xc6, 0x45, + 0x58, 0x84, 0x19, 0x83, 0x7b, 0xc0, 0x54, 0x87, 0xe8, 0x31, 0x32, 0x46, 0x96, 0xb6, 0xab, 0xed, + 0x37, 0x82, 0x96, 0xd2, 0x2e, 0xc9, 0x18, 0xb5, 0x3f, 0xe8, 0xc0, 0x3c, 0x95, 0x67, 0xbf, 0xe4, + 0x21, 0x47, 0xf0, 0x19, 0x30, 0x06, 0x62, 0xb6, 0xa0, 0x5b, 0x87, 0x5b, 0xee, 0x62, 0x16, 0x57, + 0xae, 0xed, 0x37, 0x6e, 0x26, 0x4e, 0x2d, 0x50, 0x2c, 0x74, 0xc1, 0xc6, 0x88, 0x72, 0x92, 0xe3, + 0x1e, 0xe3, 0x61, 0xc1, 0x7b, 0x7d, 0x44, 0x70, 0x9f, 0x5b, 0xba, 0xd8, 0xf0, 0x9e, 0xb4, 0x2e, + 0x67, 0xce, 0x99, 0x30, 0xe0, 0x23, 0xb0, 0xa6, 0xf8, 0x01, 0x2a, 0x08, 0x4d, 0xac, 0xba, 0x20, + 0x4d, 0x29, 0x5e, 0x08, 0x0d, 0xfa, 0x00, 0xc6, 0xc3, 0xa2, 0x40, 0x39, 0xef, 0x55, 0x31, 0x48, + 0x62, 0x35, 0x66, 0xa4, 0xbf, 0x59, 0x4e, 0x9c, 0xf5, 0x63, 0xe9, 0x1e, 0x4b, 0xf3, 0xfc, 0x24, + 0x58, 0x8f, 0x17, 0x95, 0x04, 0x3e, 0x07, 0xff, 0xa9, 0xb9, 0xcc, 0x5a, 0xd9, 0xad, 0xef, 0xb7, + 0x0e, 0xef, 0x2f, 0x07, 0x52, 0xb0, 0x4a, 0x74, 0x87, 0x1f, 0x35, 0xde, 0x7d, 0x74, 0x6a, 0xed, + 0x4f, 0x3a, 0x68, 0x2a, 0x02, 0x6e, 0x01, 0x9d, 0x24, 0xb2, 0x8a, 0xbe, 0x51, 0x4e, 0x1c, 0xfd, + 0xfc, 0x24, 0xd0, 0x49, 0xf2, 0xd7, 0xe9, 0xf7, 0x80, 0xb9, 0x00, 0xca, 0xf0, 0x2d, 0x36, 0x87, + 0x3c, 0x04, 0x00, 0xe5, 0x49, 0x05, 0x88, 0xcc, 0xc1, 0x2a, 0xca, 0x13, 0x65, 0x77, 0xc1, 0xca, + 0x88, 0x72, 0x54, 0x65, 0xda, 0x5c, 0xce, 0x74, 0x45, 0x39, 0x52, 0x81, 0x24, 0x08, 0x23, 0xd0, + 0xcc, 0x50, 0x16, 0xa1, 0x82, 0x59, 0xc6, 0x6e, 0x7d, 0xdf, 0xf4, 0xcf, 0x7e, 0x4c, 0x9c, 0x0e, + 0x26, 0xbc, 0x3f, 0x8c, 0xdc, 0x98, 0x66, 0xea, 0x56, 0xaa, 0x47, 0x87, 0x25, 0x6f, 0x3c, 0x7e, + 0x3d, 0x40, 0xcc, 0xbd, 0x0a, 0xd3, 0x17, 0x49, 0x52, 0x20, 0xc6, 0xbe, 0x7e, 0xee, 0x6c, 0xa8, + 0xbb, 0xab, 0x14, 0xff, 0x9a, 0x23, 0x16, 0x54, 0x0b, 0xb7, 0xbf, 0x68, 0xa0, 0x31, 0xdb, 0x19, + 0x3e, 0x01, 0x60, 0xae, 0x63, 0xb2, 0x60, 0x6b, 0xe5, 0xc4, 0x59, 0xfd, 0xd5, 0xaa, 0xd5, 0xf8, + 0xae, 0x47, 0xaf, 0x64, 0x98, 0x42, 0x14, 0xec, 0x5f, 0x1e, 0x4c, 0x2e, 0x0b, 0xbb, 0xa0, 0x19, + 0x85, 0x69, 0x4a, 0x39, 0xb3, 0xea, 0xa2, 0x5c, 0xbf, 0xdd, 0x69, 0x5f, 0xd8, 0x41, 0x85, 0xa9, + 0xd6, 0x1f, 0x01, 0x43, 0x1a, 0x7f, 0x6c, 0xbc, 0x05, 0x9a, 0x31, 0xcd, 0x39, 0xca, 0x65, 0xb3, + 0xcd, 0xa0, 0x1a, 0xfa, 0xa7, 0x37, 0xa5, 0xad, 0xdd, 0x96, 0xb6, 0xf6, 0xbd, 0xb4, 0xb5, 0xf7, + 0x53, 0xbb, 0x76, 0x3b, 0xb5, 0x6b, 0xdf, 0xa6, 0x76, 0xed, 0xe5, 0x7c, 0xb4, 0x2e, 0x4e, 0xc3, + 0x88, 0x79, 0x5d, 0xdc, 0x89, 0xfb, 0x21, 0xc9, 0xbd, 0xb7, 0xf3, 0xbf, 0x14, 0x91, 0x32, 0x32, + 0xc4, 0x47, 0xfd, 0xf4, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x57, 0x4d, 0xc7, 0xe0, 0x71, 0x04, + 0x00, 0x00, +} + +func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CouncilSize != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.CouncilSize)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Councils) > 0 { + for iNdEx := len(m.Councils) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Councils[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.CurrentCouncilID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.CurrentCouncilID)) + i-- + dAtA[i] = 0x20 + } + if m.VotingPeriod != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.VotingPeriod)) + i-- + dAtA[i] = 0x18 + } + if m.VotingStartHeight != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.VotingStartHeight)) + i-- + dAtA[i] = 0x10 + } + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Council) 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 *Council) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Council) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Members) > 0 { + for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Members[iNdEx]) + copy(dAtA[i:], m.Members[iNdEx]) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Members[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(m.Votes) > 0 { + for iNdEx := len(m.Votes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Votes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.EndHeight != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.EndHeight)) + i-- + dAtA[i] = 0x20 + } + if m.StartHeight != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.StartHeight)) + i-- + dAtA[i] = 0x18 + } + if m.VotingStartHeight != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.VotingStartHeight)) + i-- + dAtA[i] = 0x10 + } + if m.ID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Vote) 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 *Vote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ballots) > 0 { + for iNdEx := len(m.Ballots) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ballots[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Voter) > 0 { + i -= len(m.Voter) + copy(dAtA[i:], m.Voter) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Voter))) + i-- + dAtA[i] = 0x12 + } + if m.CouncilID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.CouncilID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Ballot) 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 *Ballot) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Ballot) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Content) > 0 { + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0x12 + } + if m.ID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CouncilSize != 0 { + n += 1 + sovGenesis(uint64(m.CouncilSize)) + } + return n +} + +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + if m.VotingStartHeight != 0 { + n += 1 + sovGenesis(uint64(m.VotingStartHeight)) + } + if m.VotingPeriod != 0 { + n += 1 + sovGenesis(uint64(m.VotingPeriod)) + } + if m.CurrentCouncilID != 0 { + n += 1 + sovGenesis(uint64(m.CurrentCouncilID)) + } + if len(m.Councils) > 0 { + for _, e := range m.Councils { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *Council) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovGenesis(uint64(m.ID)) + } + if m.VotingStartHeight != 0 { + n += 1 + sovGenesis(uint64(m.VotingStartHeight)) + } + if m.StartHeight != 0 { + n += 1 + sovGenesis(uint64(m.StartHeight)) + } + if m.EndHeight != 0 { + n += 1 + sovGenesis(uint64(m.EndHeight)) + } + if len(m.Votes) > 0 { + for _, e := range m.Votes { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.Members) > 0 { + for _, b := range m.Members { + l = len(b) + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *Vote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CouncilID != 0 { + n += 1 + sovGenesis(uint64(m.CouncilID)) + } + l = len(m.Voter) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + if len(m.Ballots) > 0 { + for _, e := range m.Ballots { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *Ballot) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovGenesis(uint64(m.ID)) + } + l = len(m.Content) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) 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 ErrIntOverflowGenesis + } + 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: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CouncilSize", wireType) + } + m.CouncilSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CouncilSize |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisState) 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 ErrIntOverflowGenesis + } + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingStartHeight", wireType) + } + m.VotingStartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VotingStartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingPeriod", wireType) + } + m.VotingPeriod = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VotingPeriod |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentCouncilID", wireType) + } + m.CurrentCouncilID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CurrentCouncilID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Councils", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Councils = append(m.Councils, Council{}) + if err := m.Councils[len(m.Councils)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Council) 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 ErrIntOverflowGenesis + } + 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: Council: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Council: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingStartHeight", wireType) + } + m.VotingStartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VotingStartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType) + } + m.StartHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndHeight", wireType) + } + m.EndHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Votes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Votes = append(m.Votes, Vote{}) + if err := m.Votes[len(m.Votes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Members = append(m.Members, make([]byte, postIndex-iNdEx)) + copy(m.Members[len(m.Members)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Vote) 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 ErrIntOverflowGenesis + } + 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: Vote: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CouncilID", wireType) + } + m.CouncilID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CouncilID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Voter = append(m.Voter[:0], dAtA[iNdEx:postIndex]...) + if m.Voter == nil { + m.Voter = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ballots", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ballots = append(m.Ballots, &Ballot{}) + if err := m.Ballots[len(m.Ballots)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Ballot) 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 ErrIntOverflowGenesis + } + 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: Ballot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Ballot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...) + if m.Content == nil { + m.Content = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenesis(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/council/v1/types/interfaces.go b/x/council/v1/types/interfaces.go new file mode 100644 index 00000000..c48ad7f0 --- /dev/null +++ b/x/council/v1/types/interfaces.go @@ -0,0 +1,23 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +// AccountKeeper defines the expected account keeper +type AccountKeeper interface { + GetAccount(sdk.Context, sdk.AccAddress) authtypes.AccountI +} + +// BankKeeper defines the expected bank keeper interface +type BankKeeper interface { + GetSupply(ctx sdk.Context, denom string) sdk.Coin + GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Coin +} + +type StakingKeeper interface { + BondDenom(ctx sdk.Context) (res string) + GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator stakingtypes.Validator, found bool) +} diff --git a/x/council/v1/types/keys.go b/x/council/v1/types/keys.go new file mode 100644 index 00000000..a5e3c18e --- /dev/null +++ b/x/council/v1/types/keys.go @@ -0,0 +1,52 @@ +package types + +import ( + "encoding/binary" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +const ( + // ModuleName The name that will be used throughout the module + ModuleName = "council" + + // StoreKey Top level store key where all module items will be stored + StoreKey = ModuleName +) + +// Key prefixes +var ( + CouncilKeyPrefix = []byte{0x00} // prefix for keys that store councils + VoteKeyPrefix = []byte{0x01} // prefix for keys that store votes + VoterKeyPrefix = []byte{0x02} // prefix for keys that store voters + + ParamsKey = []byte{0x03} + VotingStartHeightKey = []byte{0x04} + VotingPeriodKey = []byte{0x05} + CurrentCouncilIDKey = []byte{0x06} +) + +// GetKeyFromID returns the bytes to use as a key for a uint64 id +func GetKeyFromID(id uint64) []byte { + return Uint64ToBytes(id) +} + +func GetVoteKey(councilID uint64, voter sdk.ValAddress) []byte { + return append(GetKeyFromID(councilID), voter.Bytes()...) +} + +func GetVoterKey(voter sdk.ValAddress) []byte { + return voter.Bytes() +} + +// Uint64ToBytes converts a uint64 into fixed length bytes for use in store keys. +func Uint64ToBytes(id uint64) []byte { + bz := make([]byte, 8) + binary.BigEndian.PutUint64(bz, uint64(id)) + return bz +} + +// Uint64FromBytes converts some fixed length bytes back into a uint64. +func Uint64FromBytes(bz []byte) uint64 { + return binary.BigEndian.Uint64(bz) +} diff --git a/x/council/v1/types/msg.go b/x/council/v1/types/msg.go new file mode 100644 index 00000000..640cdf6f --- /dev/null +++ b/x/council/v1/types/msg.go @@ -0,0 +1,65 @@ +package types + +import ( + "encoding/hex" + + "github.com/coniks-sys/coniks-go/crypto/vrf" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var _, _ sdk.Msg = &MsgRegister{}, &MsgVote{} + +// GetSigners returns the expected signers for a MsgRegister message. +func (msg *MsgRegister) GetSigners() []sdk.AccAddress { + valAddr, err := sdk.ValAddressFromBech32(msg.Voter) + if err != nil { + panic(err) + } + accAddr, err := sdk.AccAddressFromHexUnsafe(hex.EncodeToString(valAddr.Bytes())) + if err != nil { + panic(err) + } + return []sdk.AccAddress{accAddr} +} + +// ValidateBasic does a sanity check of the provided data +func (msg *MsgRegister) ValidateBasic() error { + if _, err := sdk.ValAddressFromBech32(msg.Voter); err != nil { + return ErrInvalidValidatorAddress + } + if len(msg.Key) != vrf.PublicKeySize { + return ErrInvalidPublicKey + } + return nil +} + +// GetSignBytes implements the LegacyMsg interface. +func (msg MsgRegister) GetSignBytes() []byte { + return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg)) +} + +// GetSigners returns the expected signers for a MsgVote message. +func (msg *MsgVote) GetSigners() []sdk.AccAddress { + valAddr, err := sdk.ValAddressFromBech32(msg.Voter) + if err != nil { + panic(err) + } + accAddr, err := sdk.AccAddressFromHexUnsafe(hex.EncodeToString(valAddr.Bytes())) + if err != nil { + panic(err) + } + return []sdk.AccAddress{accAddr} +} + +// ValidateBasic does a sanity check of the provided data +func (msg *MsgVote) ValidateBasic() error { + if _, err := sdk.ValAddressFromBech32(msg.Voter); err != nil { + return ErrInvalidValidatorAddress + } + return nil +} + +// GetSignBytes implements the LegacyMsg interface. +func (msg MsgVote) GetSignBytes() []byte { + return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg)) +} diff --git a/x/council/v1/types/query.pb.go b/x/council/v1/types/query.pb.go new file mode 100644 index 00000000..3b85bc6f --- /dev/null +++ b/x/council/v1/types/query.pb.go @@ -0,0 +1,839 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgc/council/v1/query.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type QueryCurrentCouncilIDRequest struct { +} + +func (m *QueryCurrentCouncilIDRequest) Reset() { *m = QueryCurrentCouncilIDRequest{} } +func (m *QueryCurrentCouncilIDRequest) String() string { return proto.CompactTextString(m) } +func (*QueryCurrentCouncilIDRequest) ProtoMessage() {} +func (*QueryCurrentCouncilIDRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_eb373abb48fc6ce6, []int{0} +} +func (m *QueryCurrentCouncilIDRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryCurrentCouncilIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryCurrentCouncilIDRequest.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 *QueryCurrentCouncilIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryCurrentCouncilIDRequest.Merge(m, src) +} +func (m *QueryCurrentCouncilIDRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryCurrentCouncilIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryCurrentCouncilIDRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryCurrentCouncilIDRequest proto.InternalMessageInfo + +type QueryCurrentCouncilIDResponse struct { + CurrentCouncilID uint64 `protobuf:"varint,1,opt,name=current_council_id,json=currentCouncilId,proto3" json:"current_council_id,omitempty"` +} + +func (m *QueryCurrentCouncilIDResponse) Reset() { *m = QueryCurrentCouncilIDResponse{} } +func (m *QueryCurrentCouncilIDResponse) String() string { return proto.CompactTextString(m) } +func (*QueryCurrentCouncilIDResponse) ProtoMessage() {} +func (*QueryCurrentCouncilIDResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_eb373abb48fc6ce6, []int{1} +} +func (m *QueryCurrentCouncilIDResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryCurrentCouncilIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryCurrentCouncilIDResponse.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 *QueryCurrentCouncilIDResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryCurrentCouncilIDResponse.Merge(m, src) +} +func (m *QueryCurrentCouncilIDResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryCurrentCouncilIDResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryCurrentCouncilIDResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryCurrentCouncilIDResponse proto.InternalMessageInfo + +type QueryRegisteredVotersRequest struct { +} + +func (m *QueryRegisteredVotersRequest) Reset() { *m = QueryRegisteredVotersRequest{} } +func (m *QueryRegisteredVotersRequest) String() string { return proto.CompactTextString(m) } +func (*QueryRegisteredVotersRequest) ProtoMessage() {} +func (*QueryRegisteredVotersRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_eb373abb48fc6ce6, []int{2} +} +func (m *QueryRegisteredVotersRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryRegisteredVotersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryRegisteredVotersRequest.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 *QueryRegisteredVotersRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRegisteredVotersRequest.Merge(m, src) +} +func (m *QueryRegisteredVotersRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryRegisteredVotersRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRegisteredVotersRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRegisteredVotersRequest proto.InternalMessageInfo + +type QueryRegisteredVotersResponse struct { + Voters []string `protobuf:"bytes,1,rep,name=voters,proto3" json:"voters,omitempty"` +} + +func (m *QueryRegisteredVotersResponse) Reset() { *m = QueryRegisteredVotersResponse{} } +func (m *QueryRegisteredVotersResponse) String() string { return proto.CompactTextString(m) } +func (*QueryRegisteredVotersResponse) ProtoMessage() {} +func (*QueryRegisteredVotersResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_eb373abb48fc6ce6, []int{3} +} +func (m *QueryRegisteredVotersResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryRegisteredVotersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryRegisteredVotersResponse.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 *QueryRegisteredVotersResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRegisteredVotersResponse.Merge(m, src) +} +func (m *QueryRegisteredVotersResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryRegisteredVotersResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRegisteredVotersResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRegisteredVotersResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*QueryCurrentCouncilIDRequest)(nil), "zgc.council.v1.QueryCurrentCouncilIDRequest") + proto.RegisterType((*QueryCurrentCouncilIDResponse)(nil), "zgc.council.v1.QueryCurrentCouncilIDResponse") + proto.RegisterType((*QueryRegisteredVotersRequest)(nil), "zgc.council.v1.QueryRegisteredVotersRequest") + proto.RegisterType((*QueryRegisteredVotersResponse)(nil), "zgc.council.v1.QueryRegisteredVotersResponse") +} + +func init() { proto.RegisterFile("zgc/council/v1/query.proto", fileDescriptor_eb373abb48fc6ce6) } + +var fileDescriptor_eb373abb48fc6ce6 = []byte{ + // 418 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x3f, 0x8f, 0xd3, 0x30, + 0x18, 0xc6, 0xe3, 0x03, 0x4e, 0xc2, 0x03, 0xaa, 0xac, 0x13, 0xba, 0x8b, 0x0e, 0x5f, 0x15, 0x09, + 0xe8, 0x40, 0xe2, 0x16, 0x06, 0xf6, 0x96, 0x05, 0x31, 0xd1, 0x81, 0x81, 0xa5, 0x4a, 0x1c, 0xe3, + 0x5a, 0x6a, 0xec, 0x34, 0x76, 0x2a, 0xda, 0x91, 0x4f, 0x80, 0xc4, 0x0e, 0x5f, 0xa7, 0x62, 0xaa, + 0xc4, 0xc2, 0x84, 0x20, 0xe5, 0x83, 0xa0, 0xc6, 0x6e, 0xd5, 0x3f, 0x04, 0xb1, 0xe5, 0x7d, 0x9e, + 0xf7, 0x7d, 0xfd, 0xf3, 0xe3, 0x40, 0x7f, 0xc1, 0x29, 0xa1, 0xaa, 0x94, 0x54, 0x4c, 0xc8, 0xac, + 0x47, 0xa6, 0x25, 0x2b, 0xe6, 0x51, 0x5e, 0x28, 0xa3, 0xd0, 0xbd, 0x05, 0xa7, 0x91, 0xf3, 0xa2, + 0x59, 0xcf, 0xbf, 0xa2, 0x4a, 0x67, 0x4a, 0x8f, 0x6a, 0x97, 0xd8, 0xc2, 0xb6, 0xfa, 0x17, 0x5c, + 0x71, 0x65, 0xf5, 0xcd, 0x97, 0x53, 0xaf, 0xb9, 0x52, 0x7c, 0xc2, 0x48, 0x9c, 0x0b, 0x12, 0x4b, + 0xa9, 0x4c, 0x6c, 0x84, 0x92, 0xdb, 0x99, 0x2b, 0xe7, 0xd6, 0x55, 0x52, 0xbe, 0x23, 0xb1, 0x74, + 0x27, 0xfb, 0x37, 0xc7, 0x96, 0x11, 0x19, 0xd3, 0x26, 0xce, 0xf2, 0xed, 0xe6, 0x23, 0x6c, 0xce, + 0x24, 0xd3, 0xc2, 0x6d, 0x0e, 0x30, 0xbc, 0x7e, 0xbd, 0xb9, 0xc7, 0xa0, 0x2c, 0x0a, 0x26, 0xcd, + 0xc0, 0xf6, 0xbd, 0x7c, 0x31, 0x64, 0xd3, 0x92, 0x69, 0x13, 0x50, 0xf8, 0xa0, 0xc1, 0xd7, 0xb9, + 0x92, 0x9a, 0xa1, 0x3e, 0x44, 0xd4, 0x7a, 0x23, 0x77, 0xc8, 0x48, 0xa4, 0x97, 0xa0, 0x0d, 0x3a, + 0xb7, 0xfb, 0x17, 0xd5, 0x8f, 0x9b, 0xd6, 0xc9, 0x64, 0x8b, 0x1e, 0x2a, 0xe9, 0x0e, 0x62, 0xc8, + 0xb8, 0xd0, 0x86, 0x15, 0x2c, 0x7d, 0xa3, 0x0c, 0x2b, 0xf4, 0x16, 0xe2, 0xb9, 0x83, 0x38, 0xf5, + 0x1d, 0xc4, 0x7d, 0x78, 0x3e, 0xab, 0x95, 0x4b, 0xd0, 0xbe, 0xd5, 0xb9, 0x3b, 0x74, 0xd5, 0xd3, + 0xaf, 0x67, 0xf0, 0x4e, 0x3d, 0x89, 0xbe, 0x00, 0x78, 0x42, 0x82, 0x9e, 0x44, 0x87, 0xcf, 0x16, + 0xfd, 0x2b, 0x0a, 0x3f, 0xfc, 0xcf, 0x6e, 0xcb, 0x14, 0x44, 0x1f, 0xbe, 0xfd, 0xfe, 0x74, 0xd6, + 0x41, 0x8f, 0x48, 0x97, 0xd3, 0x71, 0x2c, 0xe4, 0xfe, 0x23, 0xb8, 0x08, 0x42, 0x27, 0x85, 0x22, + 0x45, 0x9f, 0x01, 0x6c, 0x1d, 0x5f, 0xb0, 0x81, 0xb0, 0x21, 0xa7, 0x06, 0xc2, 0xa6, 0xd4, 0x82, + 0xb0, 0x26, 0x7c, 0x8c, 0x1e, 0xfe, 0x8d, 0xb0, 0xd8, 0x4d, 0x85, 0x36, 0xcc, 0xfe, 0xab, 0xe5, + 0x2f, 0xec, 0x2d, 0x2b, 0x0c, 0x56, 0x15, 0x06, 0x3f, 0x2b, 0x0c, 0x3e, 0xae, 0xb1, 0xb7, 0x5a, + 0x63, 0xef, 0xfb, 0x1a, 0x7b, 0x6f, 0x43, 0x2e, 0xcc, 0xb8, 0x4c, 0x22, 0xaa, 0x32, 0xd2, 0xe5, + 0x93, 0x38, 0xd1, 0xa4, 0xcb, 0x43, 0xbb, 0xf6, 0xfd, 0xfe, 0x62, 0x33, 0xcf, 0x99, 0x4e, 0xce, + 0xeb, 0xdf, 0xef, 0xd9, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6f, 0x29, 0x40, 0xb9, 0x55, 0x03, + 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// 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 { + CurrentCouncilID(ctx context.Context, in *QueryCurrentCouncilIDRequest, opts ...grpc.CallOption) (*QueryCurrentCouncilIDResponse, error) + RegisteredVoters(ctx context.Context, in *QueryRegisteredVotersRequest, opts ...grpc.CallOption) (*QueryRegisteredVotersResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) CurrentCouncilID(ctx context.Context, in *QueryCurrentCouncilIDRequest, opts ...grpc.CallOption) (*QueryCurrentCouncilIDResponse, error) { + out := new(QueryCurrentCouncilIDResponse) + err := c.cc.Invoke(ctx, "/zgc.council.v1.Query/CurrentCouncilID", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) RegisteredVoters(ctx context.Context, in *QueryRegisteredVotersRequest, opts ...grpc.CallOption) (*QueryRegisteredVotersResponse, error) { + out := new(QueryRegisteredVotersResponse) + err := c.cc.Invoke(ctx, "/zgc.council.v1.Query/RegisteredVoters", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + CurrentCouncilID(context.Context, *QueryCurrentCouncilIDRequest) (*QueryCurrentCouncilIDResponse, error) + RegisteredVoters(context.Context, *QueryRegisteredVotersRequest) (*QueryRegisteredVotersResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) CurrentCouncilID(ctx context.Context, req *QueryCurrentCouncilIDRequest) (*QueryCurrentCouncilIDResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CurrentCouncilID not implemented") +} +func (*UnimplementedQueryServer) RegisteredVoters(ctx context.Context, req *QueryRegisteredVotersRequest) (*QueryRegisteredVotersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RegisteredVoters not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_CurrentCouncilID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryCurrentCouncilIDRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).CurrentCouncilID(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgc.council.v1.Query/CurrentCouncilID", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).CurrentCouncilID(ctx, req.(*QueryCurrentCouncilIDRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_RegisteredVoters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryRegisteredVotersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).RegisteredVoters(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgc.council.v1.Query/RegisteredVoters", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).RegisteredVoters(ctx, req.(*QueryRegisteredVotersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "zgc.council.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CurrentCouncilID", + Handler: _Query_CurrentCouncilID_Handler, + }, + { + MethodName: "RegisteredVoters", + Handler: _Query_RegisteredVoters_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "zgc/council/v1/query.proto", +} + +func (m *QueryCurrentCouncilIDRequest) 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 *QueryCurrentCouncilIDRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryCurrentCouncilIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryCurrentCouncilIDResponse) 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 *QueryCurrentCouncilIDResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryCurrentCouncilIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CurrentCouncilID != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.CurrentCouncilID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *QueryRegisteredVotersRequest) 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 *QueryRegisteredVotersRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryRegisteredVotersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryRegisteredVotersResponse) 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 *QueryRegisteredVotersResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryRegisteredVotersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Voters) > 0 { + for iNdEx := len(m.Voters) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Voters[iNdEx]) + copy(dAtA[i:], m.Voters[iNdEx]) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Voters[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryCurrentCouncilIDRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryCurrentCouncilIDResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CurrentCouncilID != 0 { + n += 1 + sovQuery(uint64(m.CurrentCouncilID)) + } + return n +} + +func (m *QueryRegisteredVotersRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryRegisteredVotersResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Voters) > 0 { + for _, s := range m.Voters { + l = len(s) + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryCurrentCouncilIDRequest) 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: QueryCurrentCouncilIDRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryCurrentCouncilIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryCurrentCouncilIDResponse) 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: QueryCurrentCouncilIDResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryCurrentCouncilIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentCouncilID", wireType) + } + m.CurrentCouncilID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CurrentCouncilID |= 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 *QueryRegisteredVotersRequest) 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: QueryRegisteredVotersRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryRegisteredVotersRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryRegisteredVotersResponse) 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: QueryRegisteredVotersResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryRegisteredVotersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voters", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Voters = append(m.Voters, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/council/v1/types/query.pb.gw.go b/x/council/v1/types/query.pb.gw.go new file mode 100644 index 00000000..1e237961 --- /dev/null +++ b/x/council/v1/types/query.pb.gw.go @@ -0,0 +1,218 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: zgc/council/v1/query.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage +var _ = metadata.Join + +func request_Query_CurrentCouncilID_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryCurrentCouncilIDRequest + var metadata runtime.ServerMetadata + + msg, err := client.CurrentCouncilID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_CurrentCouncilID_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryCurrentCouncilIDRequest + var metadata runtime.ServerMetadata + + msg, err := server.CurrentCouncilID(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_RegisteredVoters_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryRegisteredVotersRequest + var metadata runtime.ServerMetadata + + msg, err := client.RegisteredVoters(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_RegisteredVoters_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryRegisteredVotersRequest + var metadata runtime.ServerMetadata + + msg, err := server.RegisteredVoters(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_CurrentCouncilID_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_CurrentCouncilID_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_CurrentCouncilID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_RegisteredVoters_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_RegisteredVoters_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_RegisteredVoters_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_CurrentCouncilID_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_CurrentCouncilID_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_CurrentCouncilID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_RegisteredVoters_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_RegisteredVoters_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_RegisteredVoters_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_CurrentCouncilID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0gchain", "council", "v1", "current-council-id"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_RegisteredVoters_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0gchain", "council", "v1", "registered-voters"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_CurrentCouncilID_0 = runtime.ForwardResponseMessage + + forward_Query_RegisteredVoters_0 = runtime.ForwardResponseMessage +) diff --git a/x/council/v1/types/tx.pb.go b/x/council/v1/types/tx.pb.go new file mode 100644 index 00000000..7547fa6c --- /dev/null +++ b/x/council/v1/types/tx.pb.go @@ -0,0 +1,975 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgc/council/v1/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type MsgRegister struct { + Voter string `protobuf:"bytes,1,opt,name=voter,proto3" json:"voter,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *MsgRegister) Reset() { *m = MsgRegister{} } +func (m *MsgRegister) String() string { return proto.CompactTextString(m) } +func (*MsgRegister) ProtoMessage() {} +func (*MsgRegister) Descriptor() ([]byte, []int) { + return fileDescriptor_3783c1e1bc40f3a1, []int{0} +} +func (m *MsgRegister) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRegister) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRegister.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 *MsgRegister) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRegister.Merge(m, src) +} +func (m *MsgRegister) XXX_Size() int { + return m.Size() +} +func (m *MsgRegister) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRegister.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRegister proto.InternalMessageInfo + +type MsgRegisterResponse struct { +} + +func (m *MsgRegisterResponse) Reset() { *m = MsgRegisterResponse{} } +func (m *MsgRegisterResponse) String() string { return proto.CompactTextString(m) } +func (*MsgRegisterResponse) ProtoMessage() {} +func (*MsgRegisterResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3783c1e1bc40f3a1, []int{1} +} +func (m *MsgRegisterResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRegisterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRegisterResponse.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 *MsgRegisterResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRegisterResponse.Merge(m, src) +} +func (m *MsgRegisterResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgRegisterResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRegisterResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRegisterResponse proto.InternalMessageInfo + +type MsgVote struct { + CouncilID uint64 `protobuf:"varint,1,opt,name=council_id,json=councilId,proto3" json:"council_id,omitempty"` + Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"` + Ballots []*Ballot `protobuf:"bytes,3,rep,name=ballots,proto3" json:"ballots,omitempty"` +} + +func (m *MsgVote) Reset() { *m = MsgVote{} } +func (m *MsgVote) String() string { return proto.CompactTextString(m) } +func (*MsgVote) ProtoMessage() {} +func (*MsgVote) Descriptor() ([]byte, []int) { + return fileDescriptor_3783c1e1bc40f3a1, []int{2} +} +func (m *MsgVote) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgVote.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 *MsgVote) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgVote.Merge(m, src) +} +func (m *MsgVote) XXX_Size() int { + return m.Size() +} +func (m *MsgVote) XXX_DiscardUnknown() { + xxx_messageInfo_MsgVote.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgVote proto.InternalMessageInfo + +type MsgVoteResponse struct { +} + +func (m *MsgVoteResponse) Reset() { *m = MsgVoteResponse{} } +func (m *MsgVoteResponse) String() string { return proto.CompactTextString(m) } +func (*MsgVoteResponse) ProtoMessage() {} +func (*MsgVoteResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3783c1e1bc40f3a1, []int{3} +} +func (m *MsgVoteResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgVoteResponse.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 *MsgVoteResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgVoteResponse.Merge(m, src) +} +func (m *MsgVoteResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgVoteResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgVoteResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgVoteResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgRegister)(nil), "zgc.council.v1.MsgRegister") + proto.RegisterType((*MsgRegisterResponse)(nil), "zgc.council.v1.MsgRegisterResponse") + proto.RegisterType((*MsgVote)(nil), "zgc.council.v1.MsgVote") + proto.RegisterType((*MsgVoteResponse)(nil), "zgc.council.v1.MsgVoteResponse") +} + +func init() { proto.RegisterFile("zgc/council/v1/tx.proto", fileDescriptor_3783c1e1bc40f3a1) } + +var fileDescriptor_3783c1e1bc40f3a1 = []byte{ + // 375 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xbf, 0x52, 0xea, 0x40, + 0x14, 0xc6, 0x13, 0xc2, 0xbd, 0x5c, 0x96, 0xeb, 0xbf, 0x88, 0x02, 0xd1, 0x09, 0x4c, 0x6c, 0x28, + 0x24, 0x0b, 0x38, 0xf6, 0x0e, 0xda, 0x30, 0x4a, 0x93, 0xc2, 0xc2, 0x86, 0x49, 0xc2, 0xba, 0x64, + 0x0c, 0x39, 0x0c, 0x1b, 0x18, 0xa0, 0xf1, 0x15, 0x6c, 0x7c, 0x27, 0x4a, 0x4a, 0x2b, 0x47, 0xc3, + 0x8b, 0x38, 0x24, 0x1b, 0x05, 0x46, 0xed, 0xce, 0x39, 0xbf, 0x2f, 0xdf, 0x77, 0x4e, 0x12, 0x94, + 0x9b, 0x52, 0x1b, 0xdb, 0x30, 0xf4, 0x6c, 0xc7, 0xc5, 0xa3, 0x1a, 0xf6, 0xc7, 0x7a, 0x7f, 0x00, + 0x3e, 0xc8, 0xdb, 0x53, 0x6a, 0xeb, 0x1c, 0xe8, 0xa3, 0x9a, 0x52, 0xb0, 0x81, 0xf5, 0x80, 0xb5, + 0x43, 0x8a, 0xa3, 0x26, 0x92, 0x2a, 0x59, 0x0a, 0x14, 0xa2, 0xf9, 0xb2, 0xe2, 0xd3, 0x02, 0x05, + 0xa0, 0x2e, 0xc1, 0x61, 0x67, 0x0d, 0xef, 0xb1, 0xe9, 0x4d, 0x38, 0x3a, 0xde, 0x08, 0xa5, 0xc4, + 0x23, 0xcc, 0xe1, 0x76, 0xda, 0x39, 0xca, 0xb4, 0x18, 0x35, 0x08, 0x75, 0x98, 0x4f, 0x06, 0x72, + 0x16, 0xfd, 0x19, 0x81, 0x4f, 0x06, 0x79, 0xb1, 0x24, 0x96, 0xd3, 0x46, 0xd4, 0xc8, 0xbb, 0x48, + 0x7a, 0x20, 0x93, 0x7c, 0xa2, 0x24, 0x96, 0xff, 0x1b, 0xcb, 0x52, 0x3b, 0x40, 0xfb, 0x2b, 0x8f, + 0x19, 0x84, 0xf5, 0xc1, 0x63, 0x44, 0x7b, 0x44, 0xa9, 0x16, 0xa3, 0xb7, 0xe0, 0x13, 0xf9, 0x14, + 0x21, 0x1e, 0xda, 0x76, 0x3a, 0xa1, 0x5d, 0xb2, 0xb1, 0x15, 0xbc, 0x16, 0xd3, 0x97, 0xd1, 0xb4, + 0x79, 0x65, 0xa4, 0xb9, 0xa0, 0xd9, 0xf9, 0xca, 0x4d, 0xac, 0xe6, 0x56, 0x51, 0xca, 0x32, 0x5d, + 0x17, 0x7c, 0x96, 0x97, 0x4a, 0x52, 0x39, 0x53, 0x3f, 0xd4, 0xd7, 0x5f, 0x94, 0xde, 0x08, 0xb1, + 0x11, 0xcb, 0xb4, 0x3d, 0xb4, 0xc3, 0x17, 0x88, 0x77, 0xaa, 0x3f, 0x8b, 0x48, 0x6a, 0x31, 0x2a, + 0xdf, 0xa0, 0x7f, 0x9f, 0x67, 0x1e, 0x6d, 0xfa, 0xac, 0x1c, 0xa3, 0x9c, 0xfc, 0x02, 0x63, 0x57, + 0xf9, 0x02, 0x25, 0xc3, 0x33, 0x73, 0xdf, 0x88, 0x97, 0x40, 0x29, 0xfe, 0x00, 0x62, 0x87, 0xc6, + 0xf5, 0xec, 0x5d, 0x15, 0x66, 0x81, 0x2a, 0xce, 0x03, 0x55, 0x7c, 0x0b, 0x54, 0xf1, 0x69, 0xa1, + 0x0a, 0xf3, 0x85, 0x2a, 0xbc, 0x2c, 0x54, 0xe1, 0xae, 0x42, 0x1d, 0xbf, 0x3b, 0xb4, 0x74, 0x1b, + 0x7a, 0xb8, 0x4a, 0x5d, 0xd3, 0x62, 0xb8, 0x4a, 0x2b, 0x76, 0xd7, 0x74, 0x3c, 0x3c, 0x5e, 0xfb, + 0x87, 0x26, 0x7d, 0xc2, 0xac, 0xbf, 0xe1, 0xd7, 0x3c, 0xfb, 0x08, 0x00, 0x00, 0xff, 0xff, 0x2a, + 0xc2, 0x71, 0x36, 0x62, 0x02, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + Register(ctx context.Context, in *MsgRegister, opts ...grpc.CallOption) (*MsgRegisterResponse, error) + Vote(ctx context.Context, in *MsgVote, opts ...grpc.CallOption) (*MsgVoteResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) Register(ctx context.Context, in *MsgRegister, opts ...grpc.CallOption) (*MsgRegisterResponse, error) { + out := new(MsgRegisterResponse) + err := c.cc.Invoke(ctx, "/zgc.council.v1.Msg/Register", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) Vote(ctx context.Context, in *MsgVote, opts ...grpc.CallOption) (*MsgVoteResponse, error) { + out := new(MsgVoteResponse) + err := c.cc.Invoke(ctx, "/zgc.council.v1.Msg/Vote", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + Register(context.Context, *MsgRegister) (*MsgRegisterResponse, error) + Vote(context.Context, *MsgVote) (*MsgVoteResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) Register(ctx context.Context, req *MsgRegister) (*MsgRegisterResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Register not implemented") +} +func (*UnimplementedMsgServer) Vote(ctx context.Context, req *MsgVote) (*MsgVoteResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Vote not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRegister) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).Register(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgc.council.v1.Msg/Register", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Register(ctx, req.(*MsgRegister)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_Vote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgVote) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).Vote(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgc.council.v1.Msg/Vote", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Vote(ctx, req.(*MsgVote)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "zgc.council.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Register", + Handler: _Msg_Register_Handler, + }, + { + MethodName: "Vote", + Handler: _Msg_Vote_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "zgc/council/v1/tx.proto", +} + +func (m *MsgRegister) 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 *MsgRegister) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRegister) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintTx(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if len(m.Voter) > 0 { + i -= len(m.Voter) + copy(dAtA[i:], m.Voter) + i = encodeVarintTx(dAtA, i, uint64(len(m.Voter))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRegisterResponse) 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 *MsgRegisterResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRegisterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgVote) 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 *MsgVote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ballots) > 0 { + for iNdEx := len(m.Ballots) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ballots[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.Voter) > 0 { + i -= len(m.Voter) + copy(dAtA[i:], m.Voter) + i = encodeVarintTx(dAtA, i, uint64(len(m.Voter))) + i-- + dAtA[i] = 0x12 + } + if m.CouncilID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CouncilID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgVoteResponse) 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 *MsgVoteResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgVoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgRegister) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Voter) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgRegisterResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgVote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CouncilID != 0 { + n += 1 + sovTx(uint64(m.CouncilID)) + } + l = len(m.Voter) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Ballots) > 0 { + for _, e := range m.Ballots { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgVoteResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgRegister) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRegister: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRegister: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Voter = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRegisterResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRegisterResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRegisterResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgVote) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgVote: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgVote: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CouncilID", wireType) + } + m.CouncilID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CouncilID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Voter = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ballots", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ballots = append(m.Ballots, &Ballot{}) + if err := m.Ballots[len(m.Ballots)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgVoteResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgVoteResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgVoteResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/das/v1/client/cli/query.go b/x/das/v1/client/cli/query.go new file mode 100644 index 00000000..b7a715e3 --- /dev/null +++ b/x/das/v1/client/cli/query.go @@ -0,0 +1,57 @@ +package cli + +import ( + "context" + "fmt" + + "github.com/spf13/cobra" + + "github.com/0glabs/0g-chain/x/das/v1/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" +) + +// GetQueryCmd returns the cli query commands for the inflation module. +func GetQueryCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: "Querying commands for the das module", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + cmd.AddCommand( + GetNextRequestID(), + ) + + return cmd +} + +func GetNextRequestID() *cobra.Command { + cmd := &cobra.Command{ + Use: "next-request-id", + Short: "Query the next request ID", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryNextRequestIDRequest{} + res, err := queryClient.NextRequestID(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintString(fmt.Sprintf("%v\n", res.NextRequestID)) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/das/v1/client/cli/tx.go b/x/das/v1/client/cli/tx.go new file mode 100644 index 00000000..1a97c959 --- /dev/null +++ b/x/das/v1/client/cli/tx.go @@ -0,0 +1,103 @@ +package cli + +import ( + "encoding/hex" + "fmt" + "strconv" + + "github.com/0glabs/0g-chain/x/das/v1/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/spf13/cobra" +) + +// GetTxCmd returns the transaction commands for this module +func GetTxCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: types.ModuleName, + Short: fmt.Sprintf("%s transactions subcommands", types.ModuleName), + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + cmd.AddCommand( + NewRequestDASCmd(), + NewReportDASResultCmd(), + ) + return cmd +} + +func NewRequestDASCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "request-das steram-id batch-header-hash num-blobs", + Short: "Request data-availability-sampling", + Args: cobra.ExactArgs(3), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + numBlobs, err := strconv.Atoi(args[2]) + if err != nil { + return err + } + + msg := types.NewMsgRequestDAS(clientCtx.GetFromAddress(), args[0], args[1], uint32(numBlobs)) + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd + +} + +func NewReportDASResultCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "report-das-result request-id results", + Short: "Report data-availability-sampling result", + Args: cobra.MinimumNArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + requestID, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + n := len(args) - 1 + results := make([]bool, n) + for i := 0; i < n; i++ { + var err error + results[i], err = strconv.ParseBool(args[i+1]) + if err != nil { + return err + } + } + + // get account name by address + accAddr := clientCtx.GetFromAddress() + + samplerAddr, err := sdk.ValAddressFromHex(hex.EncodeToString(accAddr.Bytes())) + if err != nil { + return err + } + + msg := &types.MsgReportDASResult{ + RequestID: requestID, + Sampler: samplerAddr.String(), + Results: results, + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/das/v1/genesis.go b/x/das/v1/genesis.go new file mode 100644 index 00000000..4780b693 --- /dev/null +++ b/x/das/v1/genesis.go @@ -0,0 +1,39 @@ +package das + +import ( + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/0glabs/0g-chain/x/das/v1/keeper" + "github.com/0glabs/0g-chain/x/das/v1/types" +) + +// InitGenesis initializes the store state from a genesis state. +func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, gs types.GenesisState) { + if err := gs.Validate(); err != nil { + panic(fmt.Sprintf("failed to validate %s genesis state: %s", types.ModuleName, err)) + } + + keeper.SetNextRequestID(ctx, gs.NextRequestID) + for _, req := range gs.Requests { + keeper.SetDASRequest(ctx, req) + } + for _, resp := range gs.Responses { + keeper.SetDASResponse(ctx, resp) + } +} + +// ExportGenesis returns a GenesisState for a given context and keeper. +func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) *types.GenesisState { + nextRequestID, err := keeper.GetNextRequestID(ctx) + if err != nil { + panic(err) + } + + return types.NewGenesisState( + nextRequestID, + keeper.GetDASRequests(ctx), + keeper.GetDASResponses(ctx), + ) +} diff --git a/x/das/v1/keeper/grpc_query.go b/x/das/v1/keeper/grpc_query.go new file mode 100644 index 00000000..e4fddea2 --- /dev/null +++ b/x/das/v1/keeper/grpc_query.go @@ -0,0 +1,22 @@ +package keeper + +import ( + "context" + + "github.com/0glabs/0g-chain/x/das/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var _ types.QueryServer = Keeper{} + +func (k Keeper) NextRequestID( + c context.Context, + _ *types.QueryNextRequestIDRequest, +) (*types.QueryNextRequestIDResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + nextRequestID, err := k.GetNextRequestID(ctx) + if err != nil { + return nil, err + } + return &types.QueryNextRequestIDResponse{NextRequestID: nextRequestID}, nil +} diff --git a/x/das/v1/keeper/keeper.go b/x/das/v1/keeper/keeper.go new file mode 100644 index 00000000..52e515fa --- /dev/null +++ b/x/das/v1/keeper/keeper.go @@ -0,0 +1,198 @@ +package keeper + +import ( + "encoding/hex" + "strconv" + + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/store/prefix" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/tendermint/tendermint/libs/log" + + "github.com/0glabs/0g-chain/x/das/v1/types" +) + +type Keeper struct { + storeKey storetypes.StoreKey + cdc codec.BinaryCodec + stakingKeeperRef types.StakingKeeperRef +} + +// NewKeeper creates a new das Keeper instance +func NewKeeper( + storeKey storetypes.StoreKey, + cdc codec.BinaryCodec, + stakingKeeper types.StakingKeeperRef, +) Keeper { + return Keeper{ + storeKey: storeKey, + cdc: cdc, + stakingKeeperRef: stakingKeeper, + } +} + +// Logger returns a module-specific logger. +func (k Keeper) Logger(ctx sdk.Context) log.Logger { + return ctx.Logger().With("module", "x/"+types.ModuleName) +} + +func (k Keeper) SetNextRequestID(ctx sdk.Context, id uint64) { + store := ctx.KVStore(k.storeKey) + store.Set(types.NextRequestIDKey, types.GetKeyFromID(id)) +} + +func (k Keeper) GetNextRequestID(ctx sdk.Context) (uint64, error) { + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.NextRequestIDKey) + if bz == nil { + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "next request ID not set at genesis") + } + return types.Uint64FromBytes(bz), nil +} + +func (k Keeper) IncrementNextRequestID(ctx sdk.Context) error { + id, err := k.GetNextRequestID(ctx) + if err != nil { + return err + } + k.SetNextRequestID(ctx, id+1) + return nil +} + +func (k Keeper) GetDASRequest(ctx sdk.Context, requestID uint64) (types.DASRequest, bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.RequestKeyPrefix) + bz := store.Get(types.GetKeyFromID(requestID)) + if bz == nil { + return types.DASRequest{}, false + } + var req types.DASRequest + k.cdc.MustUnmarshal(bz, &req) + return req, true +} + +func (k Keeper) SetDASRequest(ctx sdk.Context, req types.DASRequest) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.RequestKeyPrefix) + bz := k.cdc.MustMarshal(&req) + store.Set(types.GetKeyFromID(req.ID), bz) +} + +func (k Keeper) IterateDASRequest(ctx sdk.Context, cb func(req types.DASRequest) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.RequestKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var req types.DASRequest + k.cdc.MustUnmarshal(iterator.Value(), &req) + if cb(req) { + break + } + } +} + +func (k Keeper) GetDASRequests(ctx sdk.Context) []types.DASRequest { + results := []types.DASRequest{} + k.IterateDASRequest(ctx, func(req types.DASRequest) bool { + results = append(results, req) + return false + }) + return results +} + +func (k Keeper) StoreNewDASRequest( + ctx sdk.Context, + streamIDHexStr string, + batchHeaderHashHexStr string, + numBlobs uint32) (uint64, error) { + requestID, err := k.GetNextRequestID(ctx) + if err != nil { + return 0, err + } + + streamID, err := hex.DecodeString(streamIDHexStr) + if err != nil { + return 0, err + } + + batchHeaderHash, err := hex.DecodeString(batchHeaderHashHexStr) + if err != nil { + return 0, err + } + + req := types.DASRequest{ + ID: requestID, + StreamID: streamID, + BatchHeaderHash: batchHeaderHash, + NumBlobs: numBlobs, + } + k.SetDASRequest(ctx, req) + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeDASRequest, + sdk.NewAttribute(types.AttributeKeyRequestID, strconv.FormatUint(requestID, 10)), + sdk.NewAttribute(types.AttributeKeyStreamID, streamIDHexStr), + sdk.NewAttribute(types.AttributeKeyBatchHeaderHash, batchHeaderHashHexStr), + sdk.NewAttribute(types.AttributeKeyNumBlobs, strconv.FormatUint(uint64(numBlobs), 10)), + ), + ) + + return requestID, nil +} + +func (k Keeper) GetDASResponse( + ctx sdk.Context, requestID uint64, sampler sdk.ValAddress, +) (types.DASResponse, bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.ResponseKeyPrefix) + bz := store.Get(types.GetResponseKey(requestID, sampler)) + if bz == nil { + return types.DASResponse{}, false + } + var vote types.DASResponse + k.cdc.MustUnmarshal(bz, &vote) + return vote, true +} + +func (k Keeper) SetDASResponse(ctx sdk.Context, resp types.DASResponse) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.ResponseKeyPrefix) + bz := k.cdc.MustMarshal(&resp) + store.Set(types.GetResponseKey(resp.ID, resp.Sampler), bz) +} + +func (k Keeper) IterateDASResponse(ctx sdk.Context, cb func(resp types.DASResponse) (stop bool)) { + iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.ResponseKeyPrefix) + + defer iterator.Close() + for ; iterator.Valid(); iterator.Next() { + var resp types.DASResponse + k.cdc.MustUnmarshal(iterator.Value(), &resp) + if cb(resp) { + break + } + } +} + +func (k Keeper) GetDASResponses(ctx sdk.Context) []types.DASResponse { + results := []types.DASResponse{} + k.IterateDASResponse(ctx, func(resp types.DASResponse) bool { + results = append(results, resp) + return false + }) + return results +} + +func (k Keeper) StoreNewDASResponse( + ctx sdk.Context, requestID uint64, sampler sdk.ValAddress, results []bool) error { + if _, found := k.GetDASRequest(ctx, requestID); !found { + return errorsmod.Wrapf(types.ErrUnknownRequest, "%d", requestID) + } + + k.SetDASResponse(ctx, types.DASResponse{ + ID: requestID, + Sampler: sampler, + Results: results, + }) + + return nil +} diff --git a/x/das/v1/keeper/msg_server.go b/x/das/v1/keeper/msg_server.go new file mode 100644 index 00000000..4109f90a --- /dev/null +++ b/x/das/v1/keeper/msg_server.go @@ -0,0 +1,49 @@ +package keeper + +import ( + "context" + + "github.com/0glabs/0g-chain/x/das/v1/types" + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +var _ types.MsgServer = &Keeper{} + +// RequestDAS handles MsgRequestDAS messages +func (k Keeper) RequestDAS( + goCtx context.Context, msg *types.MsgRequestDAS, +) (*types.MsgRequestDASResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + requestID, err := k.StoreNewDASRequest(ctx, msg.StreamID, msg.BatchHeaderHash, msg.NumBlobs) + if err != nil { + return nil, err + } + k.IncrementNextRequestID(ctx) + return &types.MsgRequestDASResponse{ + RequestID: requestID, + }, nil +} + +// ReportDASResult handles MsgReportDASResult messages +func (k Keeper) ReportDASResult( + goCtx context.Context, msg *types.MsgReportDASResult, +) (*types.MsgReportDASResultResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + sampler, err := sdk.ValAddressFromBech32(msg.Sampler) + if err != nil { + return nil, err + } + + if _, found := k.stakingKeeperRef.GetValidator(ctx, sampler); !found { + return nil, stakingtypes.ErrNoValidatorFound + } + + if err := k.StoreNewDASResponse(ctx, msg.RequestID, sampler, msg.Results); err != nil { + return nil, err + } + + return &types.MsgReportDASResultResponse{}, nil +} diff --git a/x/das/v1/module.go b/x/das/v1/module.go new file mode 100644 index 00000000..03d8c644 --- /dev/null +++ b/x/das/v1/module.go @@ -0,0 +1,180 @@ +package das + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + "github.com/gorilla/mux" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/spf13/cobra" + abci "github.com/tendermint/tendermint/abci/types" + + "github.com/0glabs/0g-chain/x/das/v1/client/cli" + "github.com/0glabs/0g-chain/x/das/v1/keeper" + "github.com/0glabs/0g-chain/x/das/v1/types" +) + +// consensusVersion defines the current x/council module consensus version. +const consensusVersion = 1 + +// type check to ensure the interface is properly implemented +var ( + _ module.AppModule = AppModule{} + _ module.AppModuleBasic = AppModuleBasic{} + // _ module.AppModuleSimulation = AppModule{} + _ module.BeginBlockAppModule = AppModule{} + _ module.EndBlockAppModule = AppModule{} +) + +// app module Basics object +type AppModuleBasic struct{} + +// Name returns the inflation module's name. +func (AppModuleBasic) Name() string { + return types.ModuleName +} + +// RegisterLegacyAminoCodec registers the inflation module's types on the given LegacyAmino codec. +func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {} + +// ConsensusVersion returns the consensus state-breaking version for the module. +func (AppModuleBasic) ConsensusVersion() uint64 { + return consensusVersion +} + +// RegisterInterfaces registers interfaces and implementations of the incentives +// module. +func (AppModuleBasic) RegisterInterfaces(interfaceRegistry codectypes.InterfaceRegistry) { + types.RegisterInterfaces(interfaceRegistry) +} + +// DefaultGenesis returns default genesis state as raw bytes for the incentives +// module. +func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { + return cdc.MustMarshalJSON(types.DefaultGenesisState()) +} + +// ValidateGenesis performs genesis state validation for the inflation module. +func (b AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, _ client.TxEncodingConfig, bz json.RawMessage) error { + var genesisState types.GenesisState + if err := cdc.UnmarshalJSON(bz, &genesisState); err != nil { + return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) + } + + return genesisState.Validate() +} + +// RegisterRESTRoutes performs a no-op as the inflation module doesn't expose REST +// endpoints +func (AppModuleBasic) RegisterRESTRoutes(_ client.Context, _ *mux.Router) {} + +// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the inflation module. +func (b AppModuleBasic) RegisterGRPCGatewayRoutes(c client.Context, serveMux *runtime.ServeMux) { + if err := types.RegisterQueryHandlerClient(context.Background(), serveMux, types.NewQueryClient(c)); err != nil { + panic(err) + } +} + +// GetTxCmd returns the root tx command for the inflation module. +func (AppModuleBasic) GetTxCmd() *cobra.Command { + return cli.GetTxCmd() +} + +// GetQueryCmd returns no root query command for the inflation module. +func (AppModuleBasic) GetQueryCmd() *cobra.Command { + return cli.GetQueryCmd() +} + +// ___________________________________________________________________________ + +// AppModule implements an application module for the inflation module. +type AppModule struct { + AppModuleBasic + keeper keeper.Keeper +} + +// NewAppModule creates a new AppModule Object +func NewAppModule( + k keeper.Keeper, +) AppModule { + return AppModule{ + AppModuleBasic: AppModuleBasic{}, + keeper: k, + } +} + +// Name returns the inflation module's name. +func (AppModule) Name() string { + return types.ModuleName +} + +// Route returns evmutil module's message route. +func (am AppModule) Route() sdk.Route { return sdk.Route{} } + +// QuerierRoute returns evmutil module's query routing key. +func (AppModule) QuerierRoute() string { return "" } + +// LegacyQuerierHandler returns evmutil module's Querier. +func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sdk.Querier { + return nil +} + +// RegisterInvariants registers the inflation module invariants. +func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {} + +// RegisterServices registers a gRPC query service to respond to the +// module-specific gRPC queries. +func (am AppModule) RegisterServices(cfg module.Configurator) { + types.RegisterMsgServer(cfg.MsgServer(), am.keeper) + types.RegisterQueryServer(cfg.QueryServer(), am.keeper) +} + +func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) { + // am.keeper.BeginBlock(ctx, req) +} + +func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate { + // am.keeper.EndBlock(ctx, req) + return []abci.ValidatorUpdate{} +} + +// InitGenesis performs genesis initialization for the inflation module. It returns +// no validator updates. +func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate { + var genesisState types.GenesisState + + cdc.MustUnmarshalJSON(data, &genesisState) + InitGenesis(ctx, am.keeper, genesisState) + return []abci.ValidatorUpdate{} +} + +// ExportGenesis returns the exported genesis state as raw bytes for the inflation +// module. +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + gs := ExportGenesis(ctx, am.keeper) + return cdc.MustMarshalJSON(gs) +} + +// ___________________________________________________________________________ + +// AppModuleSimulation functions + +// GenerateGenesisState creates a randomized GenState of the inflation module. +func (am AppModule) GenerateGenesisState(_ *module.SimulationState) { +} + +// RegisterStoreDecoder registers a decoder for inflation module's types. +func (am AppModule) RegisterStoreDecoder(_ sdk.StoreDecoderRegistry) { +} + +// WeightedOperations doesn't return any inflation module operation. +func (am AppModule) WeightedOperations(_ module.SimulationState) []simtypes.WeightedOperation { + return []simtypes.WeightedOperation{} +} diff --git a/x/das/v1/types/codec.go b/x/das/v1/types/codec.go new file mode 100644 index 00000000..883a699e --- /dev/null +++ b/x/das/v1/types/codec.go @@ -0,0 +1,47 @@ +package types + +import ( + "github.com/cosmos/cosmos-sdk/codec" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/msgservice" +) + +var ( + amino = codec.NewLegacyAmino() + // ModuleCdc references the global evm module codec. Note, the codec should + // ONLY be used in certain instances of tests and for JSON encoding. + ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry()) + + // AminoCdc is a amino codec created to support amino JSON compatible msgs. + AminoCdc = codec.NewAminoCodec(amino) +) + +const ( + // Amino names + requestDASName = "evmos/das/MsgRequestDAS" + reportDASResultName = "evmos/das/MsgReportDASResult" +) + +// NOTE: This is required for the GetSignBytes function +func init() { + RegisterLegacyAminoCodec(amino) + amino.Seal() +} + +// RegisterInterfaces register implementations +func RegisterInterfaces(registry codectypes.InterfaceRegistry) { + registry.RegisterImplementations( + (*sdk.Msg)(nil), + &MsgRequestDAS{}, + &MsgReportDASResult{}, + ) + + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) +} + +// RegisterLegacyAminoCodec required for EIP-712 +func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(&MsgRequestDAS{}, requestDASName, nil) + cdc.RegisterConcrete(&MsgReportDASResult{}, reportDASResultName, nil) +} diff --git a/x/das/v1/types/errors.go b/x/das/v1/types/errors.go new file mode 100644 index 00000000..77469e4a --- /dev/null +++ b/x/das/v1/types/errors.go @@ -0,0 +1,8 @@ +package types + +import errorsmod "cosmossdk.io/errors" + +var ( + ErrUnknownRequest = errorsmod.Register(ModuleName, 0, "request not found") + ErrInvalidGenesis = errorsmod.Register(ModuleName, 1, "invalid genesis") +) diff --git a/x/das/v1/types/events.go b/x/das/v1/types/events.go new file mode 100644 index 00000000..3a7159a4 --- /dev/null +++ b/x/das/v1/types/events.go @@ -0,0 +1,11 @@ +package types + +// Module event types +const ( + EventTypeDASRequest = "das_request" + + AttributeKeyRequestID = "request_id" + AttributeKeyStreamID = "stream_id" + AttributeKeyBatchHeaderHash = "batch_header_hash" + AttributeKeyNumBlobs = "num_blobs" +) diff --git a/x/das/v1/types/genesis.go b/x/das/v1/types/genesis.go new file mode 100644 index 00000000..fd0c6fde --- /dev/null +++ b/x/das/v1/types/genesis.go @@ -0,0 +1,28 @@ +package types + +const ( + DefaultNextRequestID = 0 +) + +// NewGenesisState returns a new genesis state object for the module. +func NewGenesisState(nextRequestID uint64, requests []DASRequest, responses []DASResponse) *GenesisState { + return &GenesisState{ + NextRequestID: nextRequestID, + Requests: requests, + Responses: responses, + } +} + +// DefaultGenesisState returns the default genesis state for the module. +func DefaultGenesisState() *GenesisState { + return NewGenesisState( + DefaultNextRequestID, + []DASRequest{}, + []DASResponse{}, + ) +} + +// Validate performs basic validation of genesis data. +func (gs GenesisState) Validate() error { + return nil +} diff --git a/x/das/v1/types/genesis.pb.go b/x/das/v1/types/genesis.pb.go new file mode 100644 index 00000000..6ebee372 --- /dev/null +++ b/x/das/v1/types/genesis.pb.go @@ -0,0 +1,1191 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgc/das/v1/genesis.proto + +package types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Params struct { +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_3f8b8b164973ed21, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +// GenesisState defines the das module's genesis state. +type GenesisState struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + NextRequestID uint64 `protobuf:"varint,2,opt,name=next_request_id,json=nextRequestId,proto3" json:"next_request_id,omitempty"` + Requests []DASRequest `protobuf:"bytes,3,rep,name=requests,proto3" json:"requests"` + Responses []DASResponse `protobuf:"bytes,4,rep,name=responses,proto3" json:"responses"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_3f8b8b164973ed21, []int{1} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +type DASRequest struct { + ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + StreamID []byte `protobuf:"bytes,2,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"` + BatchHeaderHash []byte `protobuf:"bytes,3,opt,name=batch_header_hash,json=batchHeaderHash,proto3" json:"batch_header_hash,omitempty"` + NumBlobs uint32 `protobuf:"varint,4,opt,name=num_blobs,json=numBlobs,proto3" json:"num_blobs,omitempty"` +} + +func (m *DASRequest) Reset() { *m = DASRequest{} } +func (m *DASRequest) String() string { return proto.CompactTextString(m) } +func (*DASRequest) ProtoMessage() {} +func (*DASRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_3f8b8b164973ed21, []int{2} +} +func (m *DASRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DASRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DASRequest.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 *DASRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DASRequest.Merge(m, src) +} +func (m *DASRequest) XXX_Size() int { + return m.Size() +} +func (m *DASRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DASRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DASRequest proto.InternalMessageInfo + +func (m *DASRequest) GetID() uint64 { + if m != nil { + return m.ID + } + return 0 +} + +func (m *DASRequest) GetStreamID() []byte { + if m != nil { + return m.StreamID + } + return nil +} + +func (m *DASRequest) GetBatchHeaderHash() []byte { + if m != nil { + return m.BatchHeaderHash + } + return nil +} + +func (m *DASRequest) GetNumBlobs() uint32 { + if m != nil { + return m.NumBlobs + } + return 0 +} + +type DASResponse struct { + ID uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Sampler github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=sampler,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"sampler,omitempty"` + Results []bool `protobuf:"varint,3,rep,packed,name=results,proto3" json:"results,omitempty"` +} + +func (m *DASResponse) Reset() { *m = DASResponse{} } +func (m *DASResponse) String() string { return proto.CompactTextString(m) } +func (*DASResponse) ProtoMessage() {} +func (*DASResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3f8b8b164973ed21, []int{3} +} +func (m *DASResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DASResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DASResponse.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 *DASResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DASResponse.Merge(m, src) +} +func (m *DASResponse) XXX_Size() int { + return m.Size() +} +func (m *DASResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DASResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DASResponse proto.InternalMessageInfo + +func (m *DASResponse) GetID() uint64 { + if m != nil { + return m.ID + } + return 0 +} + +func (m *DASResponse) GetSampler() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.Sampler + } + return nil +} + +func (m *DASResponse) GetResults() []bool { + if m != nil { + return m.Results + } + return nil +} + +func init() { + proto.RegisterType((*Params)(nil), "zgc.das.v1.Params") + proto.RegisterType((*GenesisState)(nil), "zgc.das.v1.GenesisState") + proto.RegisterType((*DASRequest)(nil), "zgc.das.v1.DASRequest") + proto.RegisterType((*DASResponse)(nil), "zgc.das.v1.DASResponse") +} + +func init() { proto.RegisterFile("zgc/das/v1/genesis.proto", fileDescriptor_3f8b8b164973ed21) } + +var fileDescriptor_3f8b8b164973ed21 = []byte{ + // 521 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x53, 0xbd, 0x6e, 0xd3, 0x50, + 0x14, 0x8e, 0x93, 0x28, 0x75, 0x6e, 0x12, 0x55, 0x35, 0xa8, 0xb8, 0x45, 0xb2, 0xa3, 0x4c, 0x29, + 0x52, 0xec, 0xb4, 0x2c, 0xfc, 0x4c, 0x35, 0x91, 0x48, 0x16, 0x84, 0x1c, 0x89, 0x81, 0xc5, 0xba, + 0xf6, 0xbd, 0xd8, 0x16, 0xb6, 0xaf, 0xf1, 0xb9, 0xae, 0x92, 0x3e, 0x01, 0x23, 0x23, 0x23, 0x12, + 0xaf, 0xc0, 0x43, 0x74, 0xac, 0x98, 0x98, 0x22, 0xe4, 0xbc, 0x04, 0x62, 0x42, 0xb1, 0x6f, 0x48, + 0x04, 0xea, 0x94, 0x7c, 0x7f, 0x3e, 0xdf, 0x91, 0x8f, 0x91, 0x7a, 0xed, 0x7b, 0x26, 0xc1, 0x60, + 0x5e, 0x9d, 0x9b, 0x3e, 0x4d, 0x28, 0x84, 0x60, 0xa4, 0x19, 0xe3, 0x4c, 0x41, 0xd7, 0xbe, 0x67, + 0x10, 0x0c, 0xc6, 0xd5, 0xf9, 0xe9, 0x89, 0xc7, 0x20, 0x66, 0xe0, 0x94, 0x8a, 0x59, 0x81, 0xca, + 0x76, 0x7a, 0xdf, 0x67, 0x3e, 0xab, 0xf8, 0xcd, 0x3f, 0xc1, 0x9e, 0xf8, 0x8c, 0xf9, 0x11, 0x35, + 0x4b, 0xe4, 0xe6, 0xef, 0x4c, 0x9c, 0x2c, 0x85, 0xa4, 0xff, 0x2b, 0xf1, 0x30, 0xa6, 0xc0, 0x71, + 0x9c, 0x56, 0x86, 0x81, 0x8c, 0x5a, 0xaf, 0x71, 0x86, 0x63, 0x18, 0xfc, 0x92, 0x50, 0xf7, 0x65, + 0x55, 0x6a, 0xce, 0x31, 0xa7, 0xca, 0x18, 0xb5, 0xd2, 0x52, 0x52, 0xa5, 0xbe, 0x34, 0xec, 0x5c, + 0x28, 0xc6, 0xae, 0xa4, 0x51, 0x85, 0xac, 0xe6, 0xcd, 0x4a, 0xaf, 0xd9, 0xc2, 0xa7, 0x3c, 0x45, + 0x87, 0x09, 0x5d, 0x70, 0x27, 0xa3, 0x1f, 0x72, 0x0a, 0xdc, 0x09, 0x89, 0x5a, 0xef, 0x4b, 0xc3, + 0xa6, 0x75, 0x54, 0xac, 0xf4, 0xde, 0x2b, 0xba, 0xe0, 0x76, 0xa5, 0xcc, 0x26, 0x76, 0x2f, 0xd9, + 0x83, 0x44, 0x79, 0x82, 0x64, 0x91, 0x02, 0xb5, 0xd1, 0x6f, 0x0c, 0x3b, 0x17, 0xc7, 0xfb, 0xe3, + 0x26, 0x97, 0x73, 0xe1, 0x15, 0x23, 0xff, 0xba, 0x95, 0xe7, 0xa8, 0x9d, 0x51, 0x48, 0x59, 0x02, + 0x14, 0xd4, 0x66, 0x19, 0x7d, 0xf0, 0x5f, 0xb4, 0xd2, 0x45, 0x76, 0xe7, 0x7f, 0xd6, 0xfc, 0xf8, + 0x45, 0xaf, 0x0d, 0x3e, 0x4b, 0x08, 0xed, 0x26, 0x28, 0xc7, 0xa8, 0x1e, 0x92, 0x72, 0xe9, 0xa6, + 0xd5, 0x2a, 0x56, 0x7a, 0x7d, 0x36, 0xb1, 0xeb, 0x21, 0x51, 0xce, 0x50, 0x1b, 0x78, 0x46, 0x71, + 0xbc, 0x5d, 0xac, 0x6b, 0x75, 0x8b, 0x95, 0x2e, 0xcf, 0x4b, 0x72, 0x36, 0xb1, 0xe5, 0x4a, 0x9e, + 0x11, 0xe5, 0x11, 0x3a, 0x72, 0x31, 0xf7, 0x02, 0x27, 0xa0, 0x98, 0xd0, 0xcc, 0x09, 0x30, 0x04, + 0x6a, 0x63, 0x13, 0xb1, 0x0f, 0x4b, 0x61, 0x5a, 0xf2, 0x53, 0x0c, 0x81, 0xf2, 0x10, 0xb5, 0x93, + 0x3c, 0x76, 0xdc, 0x88, 0xb9, 0x9b, 0x05, 0xa4, 0x61, 0xcf, 0x96, 0x93, 0x3c, 0xb6, 0x36, 0x78, + 0xf0, 0x55, 0x42, 0x9d, 0xbd, 0x0d, 0xee, 0xec, 0xe6, 0xa2, 0x03, 0xc0, 0x71, 0x1a, 0xd1, 0x4c, + 0x34, 0x9b, 0xfe, 0x5e, 0xe9, 0x23, 0x3f, 0xe4, 0x41, 0xee, 0x1a, 0x1e, 0x8b, 0xc5, 0x1d, 0x89, + 0x9f, 0x11, 0x90, 0xf7, 0x26, 0x5f, 0xa6, 0x14, 0x8c, 0x37, 0x38, 0xba, 0x24, 0x24, 0xa3, 0x00, + 0xdf, 0xbf, 0x8d, 0xee, 0x89, 0x6b, 0x13, 0x8c, 0xb5, 0xe4, 0x14, 0xec, 0xed, 0x83, 0x15, 0x15, + 0x1d, 0x64, 0x14, 0xf2, 0x48, 0xbc, 0x22, 0xd9, 0xde, 0x42, 0xeb, 0xc5, 0x4d, 0xa1, 0x49, 0xb7, + 0x85, 0x26, 0xfd, 0x2c, 0x34, 0xe9, 0xd3, 0x5a, 0xab, 0xdd, 0xae, 0xb5, 0xda, 0x8f, 0xb5, 0x56, + 0x7b, 0x7b, 0xb6, 0x57, 0x61, 0xec, 0x47, 0xd8, 0x05, 0x73, 0xec, 0x8f, 0xbc, 0x00, 0x87, 0x89, + 0xb9, 0xd8, 0x7e, 0x0b, 0x65, 0x13, 0xb7, 0x55, 0x5e, 0xe4, 0xe3, 0x3f, 0x01, 0x00, 0x00, 0xff, + 0xff, 0x5b, 0x0e, 0xfc, 0x0d, 0x26, 0x03, 0x00, 0x00, +} + +func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Responses) > 0 { + for iNdEx := len(m.Responses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Responses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.Requests) > 0 { + for iNdEx := len(m.Requests) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Requests[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if m.NextRequestID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.NextRequestID)) + i-- + dAtA[i] = 0x10 + } + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *DASRequest) 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 *DASRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DASRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NumBlobs != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.NumBlobs)) + i-- + dAtA[i] = 0x20 + } + if len(m.BatchHeaderHash) > 0 { + i -= len(m.BatchHeaderHash) + copy(dAtA[i:], m.BatchHeaderHash) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.BatchHeaderHash))) + i-- + dAtA[i] = 0x1a + } + if len(m.StreamID) > 0 { + i -= len(m.StreamID) + copy(dAtA[i:], m.StreamID) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.StreamID))) + i-- + dAtA[i] = 0x12 + } + if m.ID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *DASResponse) 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 *DASResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DASResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Results) > 0 { + for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- { + i-- + if m.Results[iNdEx] { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + } + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Results))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sampler) > 0 { + i -= len(m.Sampler) + copy(dAtA[i:], m.Sampler) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Sampler))) + i-- + dAtA[i] = 0x12 + } + if m.ID != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.ID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + if m.NextRequestID != 0 { + n += 1 + sovGenesis(uint64(m.NextRequestID)) + } + if len(m.Requests) > 0 { + for _, e := range m.Requests { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if len(m.Responses) > 0 { + for _, e := range m.Responses { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *DASRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovGenesis(uint64(m.ID)) + } + l = len(m.StreamID) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + l = len(m.BatchHeaderHash) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + if m.NumBlobs != 0 { + n += 1 + sovGenesis(uint64(m.NumBlobs)) + } + return n +} + +func (m *DASResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ID != 0 { + n += 1 + sovGenesis(uint64(m.ID)) + } + l = len(m.Sampler) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + if len(m.Results) > 0 { + n += 1 + sovGenesis(uint64(len(m.Results))) + len(m.Results)*1 + } + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) 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 ErrIntOverflowGenesis + } + 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: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenesisState) 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 ErrIntOverflowGenesis + } + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NextRequestID", wireType) + } + m.NextRequestID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NextRequestID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Requests = append(m.Requests, DASRequest{}) + if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Responses = append(m.Responses, DASResponse{}) + if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DASRequest) 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 ErrIntOverflowGenesis + } + 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: DASRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DASRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StreamID", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StreamID = append(m.StreamID[:0], dAtA[iNdEx:postIndex]...) + if m.StreamID == nil { + m.StreamID = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BatchHeaderHash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BatchHeaderHash = append(m.BatchHeaderHash[:0], dAtA[iNdEx:postIndex]...) + if m.BatchHeaderHash == nil { + m.BatchHeaderHash = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NumBlobs", wireType) + } + m.NumBlobs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NumBlobs |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DASResponse) 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 ErrIntOverflowGenesis + } + 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: DASResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DASResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + m.ID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sampler", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sampler = append(m.Sampler[:0], dAtA[iNdEx:postIndex]...) + if m.Sampler == nil { + m.Sampler = []byte{} + } + iNdEx = postIndex + case 3: + if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + elementCount = packedLen + if elementCount != 0 && len(m.Results) == 0 { + m.Results = make([]bool, 0, elementCount) + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenesis(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/das/v1/types/interfaces.go b/x/das/v1/types/interfaces.go new file mode 100644 index 00000000..ff56b322 --- /dev/null +++ b/x/das/v1/types/interfaces.go @@ -0,0 +1,10 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +type StakingKeeperRef interface { + GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator stakingtypes.Validator, found bool) +} diff --git a/x/das/v1/types/keys.go b/x/das/v1/types/keys.go new file mode 100644 index 00000000..06846cb9 --- /dev/null +++ b/x/das/v1/types/keys.go @@ -0,0 +1,44 @@ +package types + +import ( + "encoding/binary" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +const ( + // ModuleName The name that will be used throughout the module + ModuleName = "das" + + // StoreKey Top level store key where all module items will be stored + StoreKey = ModuleName +) + +// Key prefixes +var ( + RequestKeyPrefix = []byte{0x00} // prefix for keys that store requests + ResponseKeyPrefix = []byte{0x01} // prefix for keys that store responses + + NextRequestIDKey = []byte{0x02} +) + +// GetKeyFromID returns the bytes to use as a key for a uint64 id +func GetKeyFromID(id uint64) []byte { + return Uint64ToBytes(id) +} + +func GetResponseKey(requestID uint64, sampler sdk.ValAddress) []byte { + return append(GetKeyFromID(requestID), sampler.Bytes()...) +} + +// Uint64ToBytes converts a uint64 into fixed length bytes for use in store keys. +func Uint64ToBytes(id uint64) []byte { + bz := make([]byte, 8) + binary.BigEndian.PutUint64(bz, uint64(id)) + return bz +} + +// Uint64FromBytes converts some fixed length bytes back into a uint64. +func Uint64FromBytes(bz []byte) uint64 { + return binary.BigEndian.Uint64(bz) +} diff --git a/x/das/v1/types/msg.go b/x/das/v1/types/msg.go new file mode 100644 index 00000000..f1c07ce4 --- /dev/null +++ b/x/das/v1/types/msg.go @@ -0,0 +1,57 @@ +package types + +import ( + "encoding/hex" + + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +var _, _ sdk.Msg = &MsgRequestDAS{}, &MsgReportDASResult{} + +func NewMsgRequestDAS(fromAddr sdk.AccAddress, streamID, hash string, numBlobs uint32) *MsgRequestDAS { + return &MsgRequestDAS{ + Requester: fromAddr.String(), + StreamID: streamID, + BatchHeaderHash: hash, + NumBlobs: numBlobs, + } +} + +func (msg MsgRequestDAS) GetSigners() []sdk.AccAddress { + from, err := sdk.AccAddressFromBech32(msg.Requester) + if err != nil { + panic(err) + } + return []sdk.AccAddress{from} +} + +func (msg MsgRequestDAS) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Requester) + if err != nil { + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid requester account address (%s)", err) + } + + return nil +} + +func (msg *MsgReportDASResult) GetSigners() []sdk.AccAddress { + samplerValAddr, err := sdk.ValAddressFromBech32(msg.Sampler) + if err != nil { + panic(err) + } + accAddr, err := sdk.AccAddressFromHexUnsafe(hex.EncodeToString(samplerValAddr.Bytes())) + if err != nil { + panic(err) + } + return []sdk.AccAddress{accAddr} +} + +func (msg *MsgReportDASResult) ValidateBasic() error { + _, err := sdk.ValAddressFromBech32(msg.Sampler) + if err != nil { + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sampler validator address (%s)", err) + } + return nil +} diff --git a/x/das/v1/types/query.pb.go b/x/das/v1/types/query.pb.go new file mode 100644 index 00000000..76f8bfd9 --- /dev/null +++ b/x/das/v1/types/query.pb.go @@ -0,0 +1,511 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgc/das/v1/query.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type QueryNextRequestIDRequest struct { +} + +func (m *QueryNextRequestIDRequest) Reset() { *m = QueryNextRequestIDRequest{} } +func (m *QueryNextRequestIDRequest) String() string { return proto.CompactTextString(m) } +func (*QueryNextRequestIDRequest) ProtoMessage() {} +func (*QueryNextRequestIDRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d404c1962bca645f, []int{0} +} +func (m *QueryNextRequestIDRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryNextRequestIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryNextRequestIDRequest.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 *QueryNextRequestIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryNextRequestIDRequest.Merge(m, src) +} +func (m *QueryNextRequestIDRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryNextRequestIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryNextRequestIDRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryNextRequestIDRequest proto.InternalMessageInfo + +type QueryNextRequestIDResponse struct { + NextRequestID uint64 `protobuf:"varint,1,opt,name=next_request_id,json=nextRequestId,proto3" json:"next_request_id,omitempty"` +} + +func (m *QueryNextRequestIDResponse) Reset() { *m = QueryNextRequestIDResponse{} } +func (m *QueryNextRequestIDResponse) String() string { return proto.CompactTextString(m) } +func (*QueryNextRequestIDResponse) ProtoMessage() {} +func (*QueryNextRequestIDResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d404c1962bca645f, []int{1} +} +func (m *QueryNextRequestIDResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryNextRequestIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryNextRequestIDResponse.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 *QueryNextRequestIDResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryNextRequestIDResponse.Merge(m, src) +} +func (m *QueryNextRequestIDResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryNextRequestIDResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryNextRequestIDResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryNextRequestIDResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*QueryNextRequestIDRequest)(nil), "zgc.das.v1.QueryNextRequestIDRequest") + proto.RegisterType((*QueryNextRequestIDResponse)(nil), "zgc.das.v1.QueryNextRequestIDResponse") +} + +func init() { proto.RegisterFile("zgc/das/v1/query.proto", fileDescriptor_d404c1962bca645f) } + +var fileDescriptor_d404c1962bca645f = []byte{ + // 334 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xbf, 0x4b, 0x03, 0x31, + 0x14, 0xc7, 0x2f, 0xa2, 0x0e, 0x81, 0x22, 0x1e, 0x22, 0xf6, 0x94, 0x54, 0x0b, 0xfe, 0x1a, 0x9a, + 0xb4, 0x3a, 0xb9, 0x16, 0x41, 0x5c, 0x04, 0x5d, 0x04, 0x97, 0x92, 0xbb, 0x8b, 0x69, 0xa0, 0x97, + 0x5c, 0x9b, 0x5c, 0x69, 0x3b, 0xba, 0xb8, 0x2a, 0xfe, 0x53, 0x1d, 0x0b, 0x2e, 0x4e, 0xa2, 0x57, + 0xff, 0x10, 0xe9, 0xe5, 0x0e, 0xad, 0x28, 0x6e, 0xef, 0xbd, 0xef, 0xf7, 0x7d, 0xf3, 0xe1, 0x05, + 0xae, 0x8f, 0x78, 0x40, 0x42, 0xaa, 0x49, 0xbf, 0x41, 0xba, 0x09, 0xeb, 0x0d, 0x71, 0xdc, 0x53, + 0x46, 0xb9, 0x70, 0xc4, 0x03, 0x1c, 0x52, 0x8d, 0xfb, 0x0d, 0xaf, 0x1c, 0x28, 0x1d, 0x29, 0xdd, + 0xca, 0x14, 0x62, 0x1b, 0x6b, 0xf3, 0xd6, 0xb8, 0xe2, 0xca, 0xce, 0x67, 0x55, 0x3e, 0xdd, 0xe2, + 0x4a, 0xf1, 0x0e, 0x23, 0x34, 0x16, 0x84, 0x4a, 0xa9, 0x0c, 0x35, 0x42, 0xc9, 0x62, 0xa7, 0x9c, + 0xab, 0x59, 0xe7, 0x27, 0xb7, 0x84, 0xca, 0xfc, 0x55, 0xaf, 0xf2, 0x53, 0x32, 0x22, 0x62, 0xda, + 0xd0, 0x28, 0xb6, 0x86, 0xea, 0x26, 0x2c, 0x5f, 0xce, 0x28, 0x2f, 0xd8, 0xc0, 0x5c, 0xb1, 0x6e, + 0xc2, 0xb4, 0x39, 0x3f, 0xcd, 0x8b, 0xea, 0x35, 0xf4, 0x7e, 0x13, 0x75, 0xac, 0xa4, 0x66, 0xee, + 0x09, 0x5c, 0x91, 0x6c, 0x60, 0x5a, 0x3d, 0xab, 0xb4, 0x44, 0xb8, 0x01, 0xb6, 0xc1, 0xc1, 0x62, + 0x73, 0x35, 0x7d, 0xad, 0x94, 0xe6, 0x77, 0x4a, 0xf2, 0x5b, 0x1b, 0x1e, 0x3d, 0x02, 0xb8, 0x94, + 0x25, 0xbb, 0xf7, 0x00, 0xce, 0x5b, 0xdd, 0x5d, 0xfc, 0x75, 0x29, 0xfc, 0x27, 0x9b, 0xb7, 0xf7, + 0x9f, 0xcd, 0x52, 0x56, 0xf7, 0xef, 0x9e, 0x3f, 0x9e, 0x16, 0x76, 0xdc, 0x0a, 0xa9, 0xf3, 0xa0, + 0x4d, 0x85, 0x2c, 0x3e, 0x67, 0x46, 0x54, 0xcb, 0xd9, 0x6b, 0x22, 0x6c, 0x9e, 0x8d, 0xdf, 0x91, + 0x33, 0x4e, 0x11, 0x98, 0xa4, 0x08, 0xbc, 0xa5, 0x08, 0x3c, 0x4c, 0x91, 0x33, 0x99, 0x22, 0xe7, + 0x65, 0x8a, 0x9c, 0x9b, 0x43, 0x2e, 0x4c, 0x3b, 0xf1, 0x71, 0xa0, 0x22, 0x52, 0xe7, 0x1d, 0xea, + 0x6b, 0x52, 0xe7, 0x35, 0x1b, 0x38, 0x28, 0x22, 0xcd, 0x30, 0x66, 0xda, 0x5f, 0xce, 0x2e, 0x7b, + 0xfc, 0x19, 0x00, 0x00, 0xff, 0xff, 0xd5, 0x9e, 0xd6, 0x49, 0x0a, 0x02, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// 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 { + NextRequestID(ctx context.Context, in *QueryNextRequestIDRequest, opts ...grpc.CallOption) (*QueryNextRequestIDResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) NextRequestID(ctx context.Context, in *QueryNextRequestIDRequest, opts ...grpc.CallOption) (*QueryNextRequestIDResponse, error) { + out := new(QueryNextRequestIDResponse) + err := c.cc.Invoke(ctx, "/zgc.das.v1.Query/NextRequestID", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + NextRequestID(context.Context, *QueryNextRequestIDRequest) (*QueryNextRequestIDResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) NextRequestID(ctx context.Context, req *QueryNextRequestIDRequest) (*QueryNextRequestIDResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method NextRequestID not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_NextRequestID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryNextRequestIDRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).NextRequestID(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgc.das.v1.Query/NextRequestID", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).NextRequestID(ctx, req.(*QueryNextRequestIDRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "zgc.das.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "NextRequestID", + Handler: _Query_NextRequestID_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "zgc/das/v1/query.proto", +} + +func (m *QueryNextRequestIDRequest) 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 *QueryNextRequestIDRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryNextRequestIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryNextRequestIDResponse) 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 *QueryNextRequestIDResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryNextRequestIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NextRequestID != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.NextRequestID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryNextRequestIDRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryNextRequestIDResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NextRequestID != 0 { + n += 1 + sovQuery(uint64(m.NextRequestID)) + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryNextRequestIDRequest) 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: QueryNextRequestIDRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryNextRequestIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryNextRequestIDResponse) 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: QueryNextRequestIDResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryNextRequestIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NextRequestID", wireType) + } + m.NextRequestID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NextRequestID |= 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 skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/das/v1/types/query.pb.gw.go b/x/das/v1/types/query.pb.gw.go new file mode 100644 index 00000000..5567645e --- /dev/null +++ b/x/das/v1/types/query.pb.gw.go @@ -0,0 +1,153 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: zgc/das/v1/query.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage +var _ = metadata.Join + +func request_Query_NextRequestID_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryNextRequestIDRequest + var metadata runtime.ServerMetadata + + msg, err := client.NextRequestID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_NextRequestID_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryNextRequestIDRequest + var metadata runtime.ServerMetadata + + msg, err := server.NextRequestID(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_NextRequestID_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_NextRequestID_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_NextRequestID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_NextRequestID_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_NextRequestID_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_NextRequestID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_NextRequestID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0gchain", "das", "v1", "next-request-id"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_NextRequestID_0 = runtime.ForwardResponseMessage +) diff --git a/x/das/v1/types/tx.pb.go b/x/das/v1/types/tx.pb.go new file mode 100644 index 00000000..9b814acb --- /dev/null +++ b/x/das/v1/types/tx.pb.go @@ -0,0 +1,1110 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: zgc/das/v1/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/codec/types" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type MsgRequestDAS struct { + Requester string `protobuf:"bytes,1,opt,name=requester,proto3" json:"requester,omitempty" Requester` + StreamID string `protobuf:"bytes,2,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"` + BatchHeaderHash string `protobuf:"bytes,3,opt,name=batch_header_hash,json=batchHeaderHash,proto3" json:"batch_header_hash,omitempty"` + NumBlobs uint32 `protobuf:"varint,4,opt,name=num_blobs,json=numBlobs,proto3" json:"num_blobs,omitempty"` +} + +func (m *MsgRequestDAS) Reset() { *m = MsgRequestDAS{} } +func (m *MsgRequestDAS) String() string { return proto.CompactTextString(m) } +func (*MsgRequestDAS) ProtoMessage() {} +func (*MsgRequestDAS) Descriptor() ([]byte, []int) { + return fileDescriptor_030259cfeac21931, []int{0} +} +func (m *MsgRequestDAS) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRequestDAS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRequestDAS.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 *MsgRequestDAS) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRequestDAS.Merge(m, src) +} +func (m *MsgRequestDAS) XXX_Size() int { + return m.Size() +} +func (m *MsgRequestDAS) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRequestDAS.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRequestDAS proto.InternalMessageInfo + +type MsgRequestDASResponse struct { + RequestID uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` +} + +func (m *MsgRequestDASResponse) Reset() { *m = MsgRequestDASResponse{} } +func (m *MsgRequestDASResponse) String() string { return proto.CompactTextString(m) } +func (*MsgRequestDASResponse) ProtoMessage() {} +func (*MsgRequestDASResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_030259cfeac21931, []int{1} +} +func (m *MsgRequestDASResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRequestDASResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRequestDASResponse.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 *MsgRequestDASResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRequestDASResponse.Merge(m, src) +} +func (m *MsgRequestDASResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgRequestDASResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRequestDASResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRequestDASResponse proto.InternalMessageInfo + +type MsgReportDASResult struct { + RequestID uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + Sampler string `protobuf:"bytes,2,opt,name=sampler,proto3" json:"sampler,omitempty"` + Results []bool `protobuf:"varint,3,rep,packed,name=results,proto3" json:"results,omitempty"` +} + +func (m *MsgReportDASResult) Reset() { *m = MsgReportDASResult{} } +func (m *MsgReportDASResult) String() string { return proto.CompactTextString(m) } +func (*MsgReportDASResult) ProtoMessage() {} +func (*MsgReportDASResult) Descriptor() ([]byte, []int) { + return fileDescriptor_030259cfeac21931, []int{2} +} +func (m *MsgReportDASResult) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgReportDASResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgReportDASResult.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 *MsgReportDASResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgReportDASResult.Merge(m, src) +} +func (m *MsgReportDASResult) XXX_Size() int { + return m.Size() +} +func (m *MsgReportDASResult) XXX_DiscardUnknown() { + xxx_messageInfo_MsgReportDASResult.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgReportDASResult proto.InternalMessageInfo + +type MsgReportDASResultResponse struct { +} + +func (m *MsgReportDASResultResponse) Reset() { *m = MsgReportDASResultResponse{} } +func (m *MsgReportDASResultResponse) String() string { return proto.CompactTextString(m) } +func (*MsgReportDASResultResponse) ProtoMessage() {} +func (*MsgReportDASResultResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_030259cfeac21931, []int{3} +} +func (m *MsgReportDASResultResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgReportDASResultResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgReportDASResultResponse.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 *MsgReportDASResultResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgReportDASResultResponse.Merge(m, src) +} +func (m *MsgReportDASResultResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgReportDASResultResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgReportDASResultResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgReportDASResultResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgRequestDAS)(nil), "zgc.das.v1.MsgRequestDAS") + proto.RegisterType((*MsgRequestDASResponse)(nil), "zgc.das.v1.MsgRequestDASResponse") + proto.RegisterType((*MsgReportDASResult)(nil), "zgc.das.v1.MsgReportDASResult") + proto.RegisterType((*MsgReportDASResultResponse)(nil), "zgc.das.v1.MsgReportDASResultResponse") +} + +func init() { proto.RegisterFile("zgc/das/v1/tx.proto", fileDescriptor_030259cfeac21931) } + +var fileDescriptor_030259cfeac21931 = []byte{ + // 452 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x4f, 0x6e, 0xd3, 0x40, + 0x14, 0xc6, 0x63, 0x52, 0x41, 0xf2, 0x44, 0x54, 0x31, 0x80, 0xe4, 0x18, 0xe4, 0x86, 0x2c, 0x50, + 0xca, 0x1f, 0x4f, 0x0b, 0x27, 0x20, 0x0a, 0xa2, 0x41, 0xea, 0x66, 0xba, 0x82, 0x8d, 0x35, 0xb6, + 0x87, 0x71, 0x24, 0xdb, 0x63, 0xfc, 0xec, 0xa8, 0xed, 0x29, 0x38, 0x08, 0x0b, 0x8e, 0xd1, 0x65, + 0x97, 0xac, 0x2a, 0x70, 0x6e, 0xc0, 0x09, 0x90, 0xc7, 0x76, 0xd2, 0x50, 0x81, 0xc4, 0x2e, 0xdf, + 0xf7, 0x9b, 0xf9, 0xe6, 0x7b, 0xf1, 0x83, 0xfb, 0xe7, 0xd2, 0xa7, 0x01, 0x47, 0xba, 0x3c, 0xa4, + 0xf9, 0xa9, 0x93, 0x66, 0x2a, 0x57, 0x04, 0xce, 0xa5, 0xef, 0x04, 0x1c, 0x9d, 0xe5, 0xa1, 0x35, + 0xf4, 0x15, 0xc6, 0x0a, 0x5d, 0x4d, 0x68, 0x2d, 0xea, 0x63, 0xd6, 0x03, 0xa9, 0xa4, 0xaa, 0xfd, + 0xea, 0x57, 0xe3, 0x0e, 0xa5, 0x52, 0x32, 0x12, 0x54, 0x2b, 0xaf, 0xf8, 0x44, 0x79, 0x72, 0xd6, + 0x20, 0xf3, 0xda, 0x63, 0x52, 0x24, 0x02, 0x17, 0x4d, 0xd4, 0xf8, 0x9b, 0x01, 0x83, 0x63, 0x94, + 0x4c, 0x7c, 0x2e, 0x04, 0xe6, 0xb3, 0x37, 0x27, 0xe4, 0x39, 0xf4, 0xb3, 0x5a, 0x89, 0xcc, 0x34, + 0x46, 0xc6, 0xa4, 0x3f, 0x1d, 0xfc, 0xba, 0xda, 0xeb, 0xb3, 0xd6, 0x64, 0x1b, 0x4e, 0xf6, 0xa1, + 0x8f, 0x79, 0x26, 0x78, 0xec, 0x2e, 0x02, 0xf3, 0x96, 0x3e, 0x7c, 0xb7, 0xbc, 0xda, 0xeb, 0x9d, + 0x68, 0x73, 0x3e, 0x63, 0xbd, 0x1a, 0xcf, 0x03, 0xf2, 0x0c, 0xee, 0x79, 0x3c, 0xf7, 0x43, 0x37, + 0x14, 0x3c, 0x10, 0x99, 0x1b, 0x72, 0x0c, 0xcd, 0x6e, 0x75, 0x85, 0xed, 0x6a, 0x70, 0xa4, 0xfd, + 0x23, 0x8e, 0x21, 0x79, 0x04, 0xfd, 0xa4, 0x88, 0x5d, 0x2f, 0x52, 0x1e, 0x9a, 0x3b, 0x23, 0x63, + 0x32, 0x60, 0xbd, 0xa4, 0x88, 0xa7, 0x95, 0x1e, 0xbf, 0x85, 0x87, 0x5b, 0x8d, 0x99, 0xc0, 0x54, + 0x25, 0x28, 0xc8, 0x0b, 0x80, 0xa6, 0x59, 0xd5, 0xa6, 0xaa, 0xbe, 0x33, 0x1d, 0x94, 0x9b, 0xea, + 0xf3, 0xd9, 0xba, 0xfa, 0x3c, 0x18, 0x2f, 0x81, 0xe8, 0x98, 0x54, 0x65, 0x4d, 0x4a, 0x11, 0xe5, + 0xff, 0x97, 0x41, 0x4c, 0xb8, 0x83, 0x3c, 0x4e, 0x23, 0x91, 0xd5, 0xc3, 0xb3, 0x56, 0x56, 0x24, + 0xd3, 0x89, 0x68, 0x76, 0x47, 0xdd, 0x49, 0x8f, 0xb5, 0x72, 0xfc, 0x18, 0xac, 0x9b, 0xef, 0xb6, + 0x33, 0xbc, 0xfa, 0x6a, 0x40, 0xf7, 0x18, 0x25, 0x79, 0x0f, 0x70, 0xed, 0x9b, 0x0c, 0x9d, 0xcd, + 0x62, 0x38, 0x5b, 0xc3, 0x5b, 0x4f, 0xfe, 0x8a, 0xd6, 0xff, 0xcb, 0x07, 0xd8, 0xfd, 0x73, 0x4c, + 0xfb, 0xc6, 0xad, 0x2d, 0x6e, 0x3d, 0xfd, 0x37, 0x6f, 0xa3, 0xa7, 0xef, 0x2e, 0x7e, 0xda, 0x9d, + 0x8b, 0xd2, 0x36, 0x2e, 0x4b, 0xdb, 0xf8, 0x51, 0xda, 0xc6, 0x97, 0x95, 0xdd, 0xb9, 0x5c, 0xd9, + 0x9d, 0xef, 0x2b, 0xbb, 0xf3, 0x71, 0x5f, 0x2e, 0xf2, 0xb0, 0xf0, 0x1c, 0x5f, 0xc5, 0xf4, 0x40, + 0x46, 0xdc, 0x43, 0x7a, 0x20, 0x5f, 0xfa, 0x21, 0x5f, 0x24, 0xf4, 0x74, 0xbd, 0xfc, 0x67, 0xa9, + 0x40, 0xef, 0xb6, 0x5e, 0xc7, 0xd7, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc2, 0xba, 0x08, 0x98, + 0x17, 0x03, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + RequestDAS(ctx context.Context, in *MsgRequestDAS, opts ...grpc.CallOption) (*MsgRequestDASResponse, error) + ReportDASResult(ctx context.Context, in *MsgReportDASResult, opts ...grpc.CallOption) (*MsgReportDASResultResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) RequestDAS(ctx context.Context, in *MsgRequestDAS, opts ...grpc.CallOption) (*MsgRequestDASResponse, error) { + out := new(MsgRequestDASResponse) + err := c.cc.Invoke(ctx, "/zgc.das.v1.Msg/RequestDAS", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) ReportDASResult(ctx context.Context, in *MsgReportDASResult, opts ...grpc.CallOption) (*MsgReportDASResultResponse, error) { + out := new(MsgReportDASResultResponse) + err := c.cc.Invoke(ctx, "/zgc.das.v1.Msg/ReportDASResult", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + RequestDAS(context.Context, *MsgRequestDAS) (*MsgRequestDASResponse, error) + ReportDASResult(context.Context, *MsgReportDASResult) (*MsgReportDASResultResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) RequestDAS(ctx context.Context, req *MsgRequestDAS) (*MsgRequestDASResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RequestDAS not implemented") +} +func (*UnimplementedMsgServer) ReportDASResult(ctx context.Context, req *MsgReportDASResult) (*MsgReportDASResultResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReportDASResult not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_RequestDAS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRequestDAS) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RequestDAS(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgc.das.v1.Msg/RequestDAS", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RequestDAS(ctx, req.(*MsgRequestDAS)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_ReportDASResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgReportDASResult) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).ReportDASResult(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zgc.das.v1.Msg/ReportDASResult", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ReportDASResult(ctx, req.(*MsgReportDASResult)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "zgc.das.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "RequestDAS", + Handler: _Msg_RequestDAS_Handler, + }, + { + MethodName: "ReportDASResult", + Handler: _Msg_ReportDASResult_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "zgc/das/v1/tx.proto", +} + +func (m *MsgRequestDAS) 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 *MsgRequestDAS) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRequestDAS) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NumBlobs != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.NumBlobs)) + i-- + dAtA[i] = 0x20 + } + if len(m.BatchHeaderHash) > 0 { + i -= len(m.BatchHeaderHash) + copy(dAtA[i:], m.BatchHeaderHash) + i = encodeVarintTx(dAtA, i, uint64(len(m.BatchHeaderHash))) + i-- + dAtA[i] = 0x1a + } + if len(m.StreamID) > 0 { + i -= len(m.StreamID) + copy(dAtA[i:], m.StreamID) + i = encodeVarintTx(dAtA, i, uint64(len(m.StreamID))) + i-- + dAtA[i] = 0x12 + } + if len(m.Requester) > 0 { + i -= len(m.Requester) + copy(dAtA[i:], m.Requester) + i = encodeVarintTx(dAtA, i, uint64(len(m.Requester))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRequestDASResponse) 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 *MsgRequestDASResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRequestDASResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RequestID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.RequestID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgReportDASResult) 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 *MsgReportDASResult) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgReportDASResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Results) > 0 { + for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- { + i-- + if m.Results[iNdEx] { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + } + i = encodeVarintTx(dAtA, i, uint64(len(m.Results))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sampler) > 0 { + i -= len(m.Sampler) + copy(dAtA[i:], m.Sampler) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sampler))) + i-- + dAtA[i] = 0x12 + } + if m.RequestID != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.RequestID)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgReportDASResultResponse) 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 *MsgReportDASResultResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgReportDASResultResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgRequestDAS) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Requester) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.StreamID) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.BatchHeaderHash) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.NumBlobs != 0 { + n += 1 + sovTx(uint64(m.NumBlobs)) + } + return n +} + +func (m *MsgRequestDASResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestID != 0 { + n += 1 + sovTx(uint64(m.RequestID)) + } + return n +} + +func (m *MsgReportDASResult) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestID != 0 { + n += 1 + sovTx(uint64(m.RequestID)) + } + l = len(m.Sampler) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Results) > 0 { + n += 1 + sovTx(uint64(len(m.Results))) + len(m.Results)*1 + } + return n +} + +func (m *MsgReportDASResultResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgRequestDAS) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRequestDAS: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRequestDAS: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Requester = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StreamID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StreamID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BatchHeaderHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BatchHeaderHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NumBlobs", wireType) + } + m.NumBlobs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NumBlobs |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRequestDASResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRequestDASResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRequestDASResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestID", wireType) + } + m.RequestID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgReportDASResult) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgReportDASResult: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgReportDASResult: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestID", wireType) + } + m.RequestID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestID |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sampler", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sampler = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + elementCount = packedLen + if elementCount != 0 && len(m.Results) == 0 { + m.Results = make([]bool, 0, elementCount) + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgReportDASResultResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgReportDASResultResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgReportDASResultResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +)