diff --git a/app/tier1.go b/app/tier1.go index 47cd811e5..9393556b8 100644 --- a/app/tier1.go +++ b/app/tier1.go @@ -6,14 +6,15 @@ import ( "fmt" "net/url" "os" + "strings" "time" - "connectrpc.com/connect" + connectrpc "connectrpc.com/connect" "github.com/streamingfast/bstream" "github.com/streamingfast/bstream/blockstream" "github.com/streamingfast/bstream/hub" pbbstream "github.com/streamingfast/bstream/pb/sf/bstream/v1" - dauth "github.com/streamingfast/dauth" + "github.com/streamingfast/dauth" "github.com/streamingfast/dmetrics" "github.com/streamingfast/dsession" "github.com/streamingfast/dstore" @@ -21,11 +22,12 @@ import ( "github.com/streamingfast/shutter" "github.com/streamingfast/substreams/client" "github.com/streamingfast/substreams/metrics" - pbsubstreamsrpcv2connect "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2/pbsubstreamsrpcv2connect" + pbsubstreamsrpcv2 "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2" + "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2/pbsubstreamsrpcv2connect" "github.com/streamingfast/substreams/reqctx" "github.com/streamingfast/substreams/service" + "github.com/streamingfast/substreams/service/connect" "github.com/streamingfast/substreams/wasm" - _ "github.com/streamingfast/substreams/wasm/wasmtime" "github.com/streamingfast/substreams/wasm/wazero" "go.uber.org/atomic" @@ -86,7 +88,8 @@ type Tier1Config struct { SubrequestsInsecure bool SubrequestsPlaintext bool - SharedCacheSize uint64 + SharedCacheSize uint64 + OutputBundleSize uint64 WASMExtensions wasm.WASMExtensioner Tracing bool @@ -249,7 +252,7 @@ func (a *Tier1App) Run() error { FoundationalStoreEndpoints: foundationalStoreEndpoints, } - svc, err := service.NewTier1( + tier1Service, err := service.NewTier1( a.logger, mergedBlocksStore, forkedBlocksStore, @@ -267,6 +270,7 @@ func (a *Tier1App) Run() error { a.config.ActiveRequestsSoftLimit, a.config.ActiveRequestsHardLimit, a.config.SharedCacheSize, + a.config.OutputBundleSize, a.modules.SessionPool, foundationalStoreEndpoints, opts..., @@ -275,14 +279,16 @@ func (a *Tier1App) Run() error { return err } + tier1ServiceConnect := connect.NewService(tier1Service) + a.OnTerminating(func(err error) { metrics.AppReadinessTier1.SetNotReady() - svc.Shutdown(err) + tier1Service.Shutdown(err) }) go func() { - var infoServer pbsubstreamsrpcv2connect.EndpointInfoHandler + var infoServer pbsubstreamsrpcv2.EndpointInfoServer if a.modules.InfoServer != nil { a.logger.Info("waiting until info server is ready") infoServer = &InfoServerWrapper{a.modules.InfoServer} @@ -292,6 +298,12 @@ func (a *Tier1App) Run() error { } } + var infoServerConnect pbsubstreamsrpcv2connect.EndpointInfoHandler + if a.modules.InfoServer != nil { + infoServerConnect = &InfoServerConnectWrapper{a.modules.InfoServer} + a.logger.Info("info server ready") + } + if withLive { a.logger.Info("waiting until hub is real-time synced") select { @@ -305,7 +317,12 @@ func (a *Tier1App) Run() error { a.logger.Info("launching gRPC server", zap.Bool("live_support", withLive)) a.setIsReady(true) - err := service.ListenTier1(a.config.GRPCListenAddr, svc, infoServer, a.modules.Authenticator, a.logger, a.HealthCheck) + addresses := strings.Split(a.config.GRPCListenAddr, ",") + if len(addresses) == 0 { + a.logger.Error("no gRPC listen addresses provided") + return + } + err := service.ListenTier1(addresses, tier1Service, tier1ServiceConnect, infoServer, infoServerConnect, a.modules.Authenticator, a.logger, a.HealthCheck, a.config.EnforceCompression) a.Shutdown(err) }() @@ -349,17 +366,29 @@ func (config *Tier1Config) Validate() error { return nil } -var _ pbsubstreamsrpcv2connect.EndpointInfoHandler = (*InfoServerWrapper)(nil) +var _ pbsubstreamsrpcv2.EndpointInfoServer = (*InfoServerWrapper)(nil) type InfoServerWrapper struct { - rpcInfoServer InfoServer + rpcInfoServer pbsubstreamsrpcv2.EndpointInfoServer } // Info implements pbsubstreamsrpcconnect.EndpointInfoHandler. -func (i *InfoServerWrapper) Info(ctx context.Context, req *connect.Request[pbfirehose.InfoRequest]) (*connect.Response[pbfirehose.InfoResponse], error) { +func (i *InfoServerWrapper) Info(ctx context.Context, req *pbfirehose.InfoRequest) (*pbfirehose.InfoResponse, error) { + resp, err := i.rpcInfoServer.Info(ctx, req) + if err != nil { + return nil, err + } + return resp, nil +} + +type InfoServerConnectWrapper struct { + rpcInfoServer pbsubstreamsrpcv2.EndpointInfoServer +} + +func (i *InfoServerConnectWrapper) Info(ctx context.Context, req *connectrpc.Request[pbfirehose.InfoRequest]) (*connectrpc.Response[pbfirehose.InfoResponse], error) { resp, err := i.rpcInfoServer.Info(ctx, req.Msg) if err != nil { return nil, err } - return connect.NewResponse(resp), nil + return connectrpc.NewResponse(resp), nil } diff --git a/app/tier2.go b/app/tier2.go index 1ad734ca7..f2e7dcb2b 100644 --- a/app/tier2.go +++ b/app/tier2.go @@ -124,7 +124,7 @@ func (a *Tier2App) Run() error { a.logger.Info("launching gRPC server") a.setIsReady(true) - err := service.ListenTier2(a.config.GRPCListenAddr, a.config.ServiceDiscoveryURL, svc, trustAuth, a.logger, a.HealthCheck) + err := service.ListenTier2(a.config.GRPCListenAddr, a.config.ServiceDiscoveryURL, svc, trustAuth, a.logger, a.HealthCheck, false) a.Shutdown(err) }() diff --git a/buf.gen.yaml b/buf.gen.yaml index b9445963e..298213374 100644 --- a/buf.gen.yaml +++ b/buf.gen.yaml @@ -19,6 +19,15 @@ plugins: - Msf/substreams/foundational-store/model/v2/model.proto=github.com/streamingfast/substreams/pb/sf/substreams/foundational-store/model/v2;pbmodel - Msf/substreams/foundational-store/service/v2/service.proto=github.com/streamingfast/substreams/pb/sf/substreams/foundational-store/service/v2;pbservice - Msf/substreams/foundational-store/service/v1/service.proto=github.com/streamingfast/substreams/pb/sf/substreams/foundational-store/service/v1;pbstore + - remote: buf.build/community/planetscale-vtprotobuf:v0.6.0 + out: pb + opt: + - paths=source_relative + - features=marshal+unmarshal+size+equal+clone + - Msf/codegen/conversation/v1/conversation.proto=github.com/streamingfast/substreams/pb/sf/codegen/conversation/v1;pbconvo + - Msf/substreams/foundational-store/model/v2/model.proto=github.com/streamingfast/substreams/pb/sf/substreams/foundational-store/model/v2;pbmodel + - Msf/substreams/foundational-store/service/v2/service.proto=github.com/streamingfast/substreams/pb/sf/substreams/foundational-store/service/v2;pbservice + - Msf/substreams/foundational-store/service/v1/service.proto=github.com/streamingfast/substreams/pb/sf/substreams/foundational-store/service/v1;pbstore - remote: buf.build/connectrpc/go:v1.15.0 out: pb opt: diff --git a/client/client.go b/client/client.go index 2525ba7d7..d10463552 100644 --- a/client/client.go +++ b/client/client.go @@ -1,17 +1,22 @@ package client import ( + "context" "crypto/tls" "fmt" "log" "net/url" "os" "regexp" + "time" + "github.com/dustin/go-humanize" + "github.com/mostynb/go-grpc-compression/experimental/s2" "github.com/streamingfast/dgrpc" networks "github.com/streamingfast/firehose-networks" + "github.com/streamingfast/logging/zapx" pbssinternal "github.com/streamingfast/substreams/pb/sf/substreams/intern/v2" - "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc" + "github.com/streamingfast/substreams/protodecode" "go.uber.org/zap" "go.uber.org/zap/zapcore" "golang.org/x/oauth2" @@ -20,10 +25,16 @@ import ( "google.golang.org/grpc/credentials/insecure" "google.golang.org/grpc/credentials/oauth" xdscreds "google.golang.org/grpc/credentials/xds" - "google.golang.org/grpc/encoding/gzip" + "google.golang.org/grpc/encoding" + _ "google.golang.org/grpc/encoding/gzip" + stats "google.golang.org/grpc/stats" _ "google.golang.org/grpc/xds" ) +func init() { + encoding.RegisterCodec(protodecode.PreferredVTCodec{}) +} + type AuthType int const ( @@ -162,6 +173,70 @@ func (c *SubstreamsClientConfig) MarshalLogObject(encoder zapcore.ObjectEncoder) return nil } +type sizeLoggingHandler struct { + messageCount int + timeStart time.Time + + uncompressedBytes int + compressedBytes int + wireBytes int + lastReceivedTime time.Time + waitToReceive time.Duration +} + +func (h *sizeLoggingHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context { + zlog.Info("gRPC client RPC started", zap.String("method", info.FullMethodName)) + return ctx +} + +func (h *sizeLoggingHandler) HandleRPC(ctx context.Context, rs stats.RPCStats) { + //fmt.Println("handle rpc:", h.messageCount) + if inPayload, ok := rs.(*stats.InPayload); ok && inPayload != nil { + if h.messageCount == 0 { + h.timeStart = time.Now() + } + h.waitToReceive += time.Since(h.lastReceivedTime) + h.lastReceivedTime = time.Now() + h.messageCount++ + h.uncompressedBytes += inPayload.Length + h.compressedBytes += inPayload.CompressedLength + h.wireBytes += inPayload.WireLength + + if h.messageCount == 10000 { + secs := time.Since(h.timeStart).Seconds() + messagesPerSecond := float64(h.messageCount) / secs + compressedPercentage := 100.0 - (float64(h.compressedBytes) / float64(h.uncompressedBytes) * 100.0) + + zlog.Info( + "grpc io stats", + zap.Float64("msg_sec", messagesPerSecond), + zapx.HumanDuration("duration", time.Since(h.timeStart)), + zapx.HumanDuration("wait_to_receive", h.waitToReceive), + zap.String("compression_ratio", fmt.Sprintf("%.2f%%", compressedPercentage)), + zap.String("uncompressed", humanize.Bytes(uint64(h.uncompressedBytes))), + zap.String("compressed", humanize.Bytes(uint64(h.compressedBytes))), + zap.Int("uncompressed_bytes", h.uncompressedBytes), + zap.Int("compressed_bytes", h.compressedBytes), + zap.Bool("keep", false), + ) + + h.timeStart = time.Now() + h.messageCount = 0 + h.uncompressedBytes = 0 + h.compressedBytes = 0 + h.wireBytes = 0 + h.waitToReceive = 0 + } + } +} + +func (h *sizeLoggingHandler) TagConn(ctx context.Context, cti *stats.ConnTagInfo) context.Context { + return ctx +} + +func (h *sizeLoggingHandler) HandleConn(ctx context.Context, cs stats.ConnStats) { +} + type InternalClientFactory = func() (cli pbssinternal.SubstreamsClient, closeFunc func() error, callOpts []grpc.CallOption, headers Headers, err error) // NewSubstreamsClientConfig creates a new SubstreamsClientConfig using the provided options. @@ -243,6 +318,9 @@ func NewInternalClientFactory(config *SubstreamsClientConfig) InternalClientFact noop := func() error { return nil } cli, _, callOpts, headers, err := NewSubstreamsInternalClient(config) + if err != nil { + zlog.Error("failed to create substreams client", zap.Error(err)) + } return func() (pbssinternal.SubstreamsClient, func() error, []grpc.CallOption, Headers, error) { return cli, noop, callOpts, headers, err } @@ -285,7 +363,8 @@ func NewSubstreamsInternalClient(config *SubstreamsClientConfig) (cli pbssintern } } - dialOptions = append(dialOptions, grpc.WithStatsHandler(otelgrpc.NewClientHandler())) + sizeHandler := &sizeLoggingHandler{} + dialOptions = append(dialOptions, grpc.WithStatsHandler(sizeHandler)) zlog.Debug("getting connection", zap.String("endpoint", endpoint)) conn, err := dgrpc.NewExternalClientConn(endpoint, dialOptions...) @@ -354,12 +433,22 @@ func newConnection(config *SubstreamsClientConfig) (conn *grpc.ClientConn, close } } - dialOptions = append(dialOptions, grpc.WithStatsHandler(otelgrpc.NewClientHandler())) - dialOptions = append(dialOptions, grpc.WithDefaultCallOptions(grpc.UseCompressor(gzip.Name))) + sizeHandler := &sizeLoggingHandler{} + dialOptions = append(dialOptions, grpc.WithStatsHandler(sizeHandler)) + + //compressor := os.Getenv("GRPC_COMPRESSOR") + //switch compressor { + //case "gzip": + //dialOptions = append(dialOptions, grpc.WithDefaultCallOptions(grpc.UseCompressor(gzip.Name))) + //case "s2": + dialOptions = append(dialOptions, grpc.WithDefaultCallOptions(grpc.UseCompressor(s2.Name))) + //} + dialOptions = append(dialOptions, grpc.WithUserAgent(config.agent)) zlog.Debug("getting connection", zap.String("endpoint", endpoint)) conn, err = dgrpc.NewExternalClient(endpoint, dialOptions...) + if err != nil { return nil, nil, nil, nil, fmt.Errorf("unable to create external gRPC client: %w", err) } diff --git a/go.mod b/go.mod index b7da28c30..5ea5788ad 100644 --- a/go.mod +++ b/go.mod @@ -9,12 +9,12 @@ require ( github.com/jhump/protoreflect v1.14.0 github.com/spf13/cobra v1.7.0 github.com/spf13/pflag v1.0.5 - github.com/streamingfast/bstream v0.0.2-0.20260206144138-e9341a23a897 + github.com/streamingfast/bstream v0.0.2-0.20260211203220-e95f72b706fa github.com/streamingfast/cli v0.0.4-0.20250815192146-d8a233ec3d0b github.com/streamingfast/dauth v0.0.0-20251218134044-fb716c7172b4 github.com/streamingfast/dbin v0.9.1-0.20231117225723-59790c798e2c github.com/streamingfast/derr v0.0.0-20250814163534-bd7407bd89d7 - github.com/streamingfast/dgrpc v0.0.0-20251218142640-027692a12722 + github.com/streamingfast/dgrpc v0.0.0-20260211171202-db61f19b4ebd github.com/streamingfast/dhttp v0.1.3-0.20251218140957-6d46b8f12eb1 github.com/streamingfast/dstore v0.1.3-0.20260113210117-94d66eda2027 github.com/streamingfast/logging v0.0.0-20260108192805-38f96de0a641 @@ -55,6 +55,7 @@ require ( github.com/lithammer/dedent v1.1.0 github.com/mattn/go-isatty v0.0.20 github.com/mitchellh/go-testing-interface v1.14.1 + github.com/mostynb/go-grpc-compression v1.2.3 github.com/muesli/reflow v0.3.0 github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a github.com/orcaman/concurrent-map/v2 v2.0.1 @@ -145,7 +146,6 @@ require ( github.com/manifoldco/promptui v0.9.0 // indirect github.com/minio/minlz v1.0.1 // indirect github.com/mitchellh/hashstructure/v2 v2.0.2 // indirect - github.com/mostynb/go-grpc-compression v1.2.3 // indirect github.com/mschoch/smat v0.2.0 // indirect github.com/parquet-go/parquet-go v0.23.0 // indirect github.com/pelletier/go-toml/v2 v2.0.6 // indirect diff --git a/go.sum b/go.sum index e76d96e58..18dcec036 100644 --- a/go.sum +++ b/go.sum @@ -549,8 +549,8 @@ github.com/spf13/viper v1.15.0 h1:js3yy885G8xwJa6iOISGFwd+qlUo5AvyXb7CiihdtiU= github.com/spf13/viper v1.15.0/go.mod h1:fFcTBJxvhhzSJiZy8n+PeW6t8l+KeT/uTARa0jHOQLA= github.com/spiffe/go-spiffe/v2 v2.6.0 h1:l+DolpxNWYgruGQVV0xsfeya3CsC7m8iBzDnMpsbLuo= github.com/spiffe/go-spiffe/v2 v2.6.0/go.mod h1:gm2SeUoMZEtpnzPNs2Csc0D/gX33k1xIx7lEzqblHEs= -github.com/streamingfast/bstream v0.0.2-0.20260206144138-e9341a23a897 h1:s79Lfp3mtO2oKJ9lLtWywDbJc5B2RDNaiqRetwvaZ2w= -github.com/streamingfast/bstream v0.0.2-0.20260206144138-e9341a23a897/go.mod h1:0sed+gw+d62tBsGl5omaB1m14Gmfvb3YAs4epHuL1YU= +github.com/streamingfast/bstream v0.0.2-0.20260211203220-e95f72b706fa h1:ih8oxMICJfr/WVoowKeyATHvZ0lbU8+tQCDCgkwJMGU= +github.com/streamingfast/bstream v0.0.2-0.20260211203220-e95f72b706fa/go.mod h1:9NVnl3l3Wljoll+cQb8sccVa078E1m1CgBCFzttGha0= github.com/streamingfast/cli v0.0.4-0.20250815192146-d8a233ec3d0b h1:ztYeX3/5rg2tV2EU7edcrcHzMz6wUbdJB+LqCrP5W8s= github.com/streamingfast/cli v0.0.4-0.20250815192146-d8a233ec3d0b/go.mod h1:o9R/tjNON01X2mgWL5qirl2MV6xQ4EZI5D504ST3K/M= github.com/streamingfast/dauth v0.0.0-20251218134044-fb716c7172b4 h1:qJmiXzqs3T7124+FXEnhPgK/3fbSjqjQuBTdIrUk4Oc= @@ -559,8 +559,8 @@ github.com/streamingfast/dbin v0.9.1-0.20231117225723-59790c798e2c h1:6WjE2yInE+ github.com/streamingfast/dbin v0.9.1-0.20231117225723-59790c798e2c/go.mod h1:dbfiy9ORrL8c6ldSq+L0H9pg8TOqqu/FsghsgUEWK54= github.com/streamingfast/derr v0.0.0-20250814163534-bd7407bd89d7 h1:KeyhmbdPhEzot+On1XrHSAOmRoeyIRiM0EkGQAqnVxI= github.com/streamingfast/derr v0.0.0-20250814163534-bd7407bd89d7/go.mod h1:QSm/AfaDsE0k1xBYi0lW580YJ/WDV/FKZI628tkZR0Y= -github.com/streamingfast/dgrpc v0.0.0-20251218142640-027692a12722 h1:gZcPR64H5aWs49bLDoNTjhsedTfva7fAIei891LL0C8= -github.com/streamingfast/dgrpc v0.0.0-20251218142640-027692a12722/go.mod h1:NbkvenEHfjQpUBRHTCp/tp0Ayjp5hDzzkv/Ve9Uka1I= +github.com/streamingfast/dgrpc v0.0.0-20260211171202-db61f19b4ebd h1:LRu2q7HnzkU/G+K3/m1VrXDszUS8G47v9qAuDI56BXQ= +github.com/streamingfast/dgrpc v0.0.0-20260211171202-db61f19b4ebd/go.mod h1:NQH6mtw4wGmYanNywYMbmTZcMbvJCVYX/7pFwiiGinI= github.com/streamingfast/dhammer v0.0.0-20220506192416-3797a7906da2 h1:/mcLVdwy6NeHWfJwuh2GD4+FMfPa59fkfM15sl8Jejk= github.com/streamingfast/dhammer v0.0.0-20220506192416-3797a7906da2/go.mod h1:MyG3U4ABuf7ANS8tix+e8UUevN7B9juhEnAbslS/X3M= github.com/streamingfast/dhttp v0.1.3-0.20251218140957-6d46b8f12eb1 h1:V9oSpY69/OZKTptZEPzJFaC8RS0Y8kffknNTDSZwpME= diff --git a/go.work.sum b/go.work.sum index 40713e8c9..2905e0cbb 100644 --- a/go.work.sum +++ b/go.work.sum @@ -434,14 +434,21 @@ contrib.go.opencensus.io/exporter/zipkin v0.1.1/go.mod h1:GMvdSl3eJ2gapOaLKzTKE3 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9 h1:VpgP7xuJadIUuKccphEpTJnWhS2jkQyMt6Y7pJCD7fY= git.sr.ht/~sbinet/gg v0.6.0 h1:RIzgkizAk+9r7uPzf/VfbJHBMKUr0F5hRFxTUGMnt38= git.sr.ht/~sbinet/gg v0.6.0/go.mod h1:uucygbfC9wVPQIfrmwM2et0imr8L7KQWywX0xpFMm94= +github.com/Azure/azure-pipeline-go v0.2.3 h1:7U9HBg1JFK3jHl5qmo4CTZKFTVgMwdFHMVtCdfBE21U= github.com/Azure/azure-pipeline-go v0.2.3/go.mod h1:x841ezTBIMG6O3lAcl8ATHnsOPVl2bqk7S3ta6S6u4k= +github.com/Azure/azure-storage-blob-go v0.14.0 h1:1BCg74AmVdYwO3dlKwtFU1V0wU2PZdREkXvAmZJRUlM= github.com/Azure/azure-storage-blob-go v0.14.0/go.mod h1:SMqIBi+SuiQH32bvyjngEewEeXoPfKMgWlBDaYf6fck= +github.com/Azure/go-autorest v14.2.0+incompatible h1:V5VMDjClD3GiElqLWO7mz2MxNAK/vTfRHdAubSIPRgs= github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24= +github.com/Azure/go-autorest/autorest/adal v0.9.13 h1:Mp5hbtOePIzM8pJVRa3YLrWWmZtoxRXqUEzCfJt3+/Q= github.com/Azure/go-autorest/autorest/adal v0.9.13/go.mod h1:W/MM4U6nLxnIskrw4UwWzlHfGjwUS50aOsc/I3yuU8M= +github.com/Azure/go-autorest/autorest/date v0.3.0 h1:7gUk1U5M/CQbp9WoqinNzJar+8KY+LPI6wiWrP/myHw= github.com/Azure/go-autorest/autorest/date v0.3.0/go.mod h1:BI0uouVdmngYNUzGWeSYnokU+TrmwEsOqdt8Y6sso74= github.com/Azure/go-autorest/autorest/mocks v0.4.1 h1:K0laFcLE6VLTOwNgSxaGbUcLPuGXlNkbVvq4cW4nIHk= github.com/Azure/go-autorest/autorest/mocks v0.4.1/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k= +github.com/Azure/go-autorest/logger v0.2.1 h1:IG7i4p/mDa2Ce4TRyAO8IHnVhAVF3RFU+ZtXWSmf4Tg= github.com/Azure/go-autorest/logger v0.2.1/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8= +github.com/Azure/go-autorest/tracing v0.6.0 h1:TYi4+3m5t6K48TGI9AUdb+IzbnSxvnvUMfuitfgcfuo= github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU= github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802 h1:1BDTz0u9nC3//pOCMdNH+CiXJVYJh5UQNCOBG7jbELc= @@ -504,6 +511,7 @@ github.com/armon/go-metrics v0.4.0/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+ github.com/aws/aws-sdk-go v1.25.43/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go v1.37.0/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro= github.com/aws/aws-sdk-go v1.44.233/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= +github.com/aws/aws-sdk-go v1.49.6 h1:yNldzF5kzLBRvKlKz1S0bkvc2+04R1kt13KfBWQBfFA= github.com/aws/aws-sdk-go v1.49.6/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= github.com/aws/aws-sdk-go-v2 v1.36.3 h1:mJoei2CxPutQVxaATCzDUjcZEjVRdpsiiXi2o38yqWM= github.com/aws/aws-sdk-go-v2 v1.36.3/go.mod h1:LLXuLpgzEbD766Z5ECcRmi8AzSwfZItDtmABVkRLGzg= @@ -609,6 +617,7 @@ github.com/envoyproxy/protoc-gen-validate v1.0.4/go.mod h1:qys6tmnRsYrQqIhm2bvKZ github.com/envoyproxy/protoc-gen-validate v1.1.0/go.mod h1:sXRDRVmzEbkM7CVcM06s9shE/m23dg3wzjl0UWqJ2q4= github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w= github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/form3tech-oss/jwt-go v3.2.2+incompatible h1:TcekIExNqud5crz4xD2pavyTgWiPvpYe4Xau31I0PRk= github.com/form3tech-oss/jwt-go v3.2.2+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k= github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= @@ -792,7 +801,9 @@ github.com/jhump/gopoet v0.1.0 h1:gYjOPnzHd2nzB37xYQZxj4EIQNpBrBskRqQQ3q4ZgSg= github.com/jhump/goprotoc v0.5.0 h1:Y1UgUX+txUznfqcGdDef8ZOVlyQvnV0pKWZH08RmZuo= github.com/jimsmart/schema v0.2.0 h1:CZw+580ED3lkh5XR3JxFN/ZxPq8BdCVwlgAjnRlPkvM= github.com/jimsmart/schema v0.2.0/go.mod h1:v457lgfQ/WPwEWCnetnCNXLYXGDKHceLIWVENhq89rA= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= github.com/josephburnett/jd v1.7.1/go.mod h1:R8ZnZnLt2D4rhW4NvBc/USTo6mzyNT6fYNIIWOJA9GY= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= @@ -848,6 +859,7 @@ github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40= github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= +github.com/mattn/go-ieproxy v0.0.1 h1:qiyop7gCflfhwCzGyeT0gro3sF9AIg9HU98JORTkqfI= github.com/mattn/go-ieproxy v0.0.1/go.mod h1:pYabZ6IHcRpFh7vIaLfK7rdcWgFEb3SFJ6/gNWuh88E= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/melbahja/goph v1.4.0 h1:z0PgDbBFe66lRYl3v5dGb9aFgPy0kotuQ37QOwSQFqs= @@ -975,11 +987,14 @@ github.com/streamingfast/atm v0.0.0-20220131151839-18c87005e680 h1:fGJnUx0shX9Y3 github.com/streamingfast/atm v0.0.0-20220131151839-18c87005e680/go.mod h1:iISPGAstbUsPgyC3auLLi7PYUTi9lHv5z0COam0OPOY= github.com/streamingfast/bstream v0.0.2-0.20231207142002-6844e8db9e20/go.mod h1:08GVb+DXyz6jVNIsbf+2zlaC81UeEGu5o1h49KrSR3Y= github.com/streamingfast/bstream v0.0.2-0.20251218133631-a5f5c59a7c05/go.mod h1:desuTzXOKd0zUbOLKnvhLc1ucQhl454KIdl1KmRw7WY= +github.com/streamingfast/bstream v0.0.2-0.20260112182417-be2bce62fabe/go.mod h1:0sed+gw+d62tBsGl5omaB1m14Gmfvb3YAs4epHuL1YU= github.com/streamingfast/bstream v0.0.2-0.20260127202638-27d286c7156a/go.mod h1:0sed+gw+d62tBsGl5omaB1m14Gmfvb3YAs4epHuL1YU= github.com/streamingfast/bstream v0.0.2-0.20260129145732-573f7c50a243/go.mod h1:0sed+gw+d62tBsGl5omaB1m14Gmfvb3YAs4epHuL1YU= github.com/streamingfast/derr v0.0.0-20210811180100-9138d738bcec/go.mod h1:ulVfui/yGXmPBbt9aAqCWdAjM7YxnZkYHzvQktLfw3M= github.com/streamingfast/dgrpc v0.0.0-20250227145723-9bc2e4941b4e/go.mod h1:qdcskj9WmO+nDjgxyafc5oMCftTZolOk693p2ZFUdO8= github.com/streamingfast/dgrpc v0.0.0-20251218133127-15b36e02a74f/go.mod h1:B+RAf6/idk6Kz41wEAEeQH1PW3Bk6WQkmvuRhdTEgKg= +github.com/streamingfast/dgrpc v0.0.0-20260211152336-d4e7023003dd h1:w/K/23PASRF0jXPDcbjuboA/Q+AGVlikmdqLfHW4fSo= +github.com/streamingfast/dgrpc v0.0.0-20260211152336-d4e7023003dd/go.mod h1:NQH6mtw4wGmYanNywYMbmTZcMbvJCVYX/7pFwiiGinI= github.com/streamingfast/dhammer v0.0.0-20230125192823-c34bbd561bd4/go.mod h1:ehPytv7E4rI65iLcrwTes4rNGGqPPiugnH+20nDQyp4= github.com/streamingfast/dmetrics v0.0.0-20210811180524-8494aeb34447/go.mod h1:VLdQY/FwczmC/flqWkcsBbqXO4BhU4zQDSK7GMrpcjY= github.com/streamingfast/dmetrics v0.0.0-20250711072030-f023e918a175/go.mod h1:JbxEDbzWRG1dHdNIPrYfuPllEkktZMgm40AwVIBENcw= diff --git a/orchestrator/execout/execout_walker.go b/orchestrator/execout/execout_walker.go index c31329192..8cdaaa06b 100644 --- a/orchestrator/execout/execout_walker.go +++ b/orchestrator/execout/execout_walker.go @@ -10,9 +10,6 @@ import ( "github.com/streamingfast/bstream" "github.com/streamingfast/dstore" - "go.uber.org/zap" - "google.golang.org/protobuf/types/known/anypb" - "github.com/streamingfast/substreams/block" "github.com/streamingfast/substreams/orchestrator/loop" "github.com/streamingfast/substreams/orchestrator/response" @@ -21,6 +18,8 @@ import ( "github.com/streamingfast/substreams/reqctx" "github.com/streamingfast/substreams/storage/execout" pboutput "github.com/streamingfast/substreams/storage/execout/pb" + "go.uber.org/zap" + "google.golang.org/protobuf/types/known/anypb" ) type Walker struct { @@ -33,6 +32,7 @@ type Walker struct { working bool workingAt time.Time // Timestamp when working was set to true noopMode bool + buffer *MessageBuffer } func NewWalker( @@ -42,6 +42,7 @@ func NewWalker( walkRange *block.Range, stream *response.Stream, noopMode bool, + bufferSize int, ) *Walker { logger := reqctx.Logger(ctx).Named("execout_walker") return &Walker{ @@ -52,6 +53,12 @@ func NewWalker( streamOut: stream, noopMode: noopMode, logger: logger, + buffer: NewMessageBuffer(func() int { + if bufferSize <= 0 { + return 100 + } + return bufferSize + }()), } } @@ -227,6 +234,12 @@ func (r *Walker) sendItems(reader execout.FileReader) error { itemCount := 0 for item, err := range reader.Iter() { if err != nil { + if err == io.EOF { + err := r.buffer.Flush(r.streamOut) + if err != nil { + return fmt.Errorf("flushing buffer on eof: %w", err) + } + } return err } if item.BlockNum < r.StartBlock { @@ -246,6 +259,13 @@ func (r *Walker) sendItems(reader execout.FileReader) error { return fmt.Errorf("converting to block scoped data: %w", err) } + r.buffer.Append(blockScopedData) + if r.buffer.ShouldFlush() { + err := r.buffer.Flush(r.streamOut) + if err != nil { + return fmt.Errorf("flushing buffer: %w", err) + } + } if err = r.streamOut.BlockScopedData(blockScopedData); err != nil { return fmt.Errorf("calling response func: %w", err) } diff --git a/orchestrator/execout/message_buffer.go b/orchestrator/execout/message_buffer.go new file mode 100644 index 000000000..55d2a3231 --- /dev/null +++ b/orchestrator/execout/message_buffer.go @@ -0,0 +1,73 @@ +package execout + +import ( + "fmt" + "sync" + "time" + + "github.com/streamingfast/substreams/orchestrator/response" + pbsubstreamsrpcv2 "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2" +) + +type MessageBuffer struct { + mut sync.RWMutex + buf *pbsubstreamsrpcv2.BlockScopedDatas + lastFlush time.Time + maxBufferedMessage int +} + +func NewMessageBuffer(maxBufferedMessage int) *MessageBuffer { + return &MessageBuffer{ + buf: &pbsubstreamsrpcv2.BlockScopedDatas{Items: []*pbsubstreamsrpcv2.BlockScopedData{}}, + maxBufferedMessage: maxBufferedMessage, + } +} + +func (b *MessageBuffer) Len() int { + b.mut.Lock() + defer b.mut.Unlock() + + return len(b.buf.Items) +} + +func (b *MessageBuffer) Append(msg *pbsubstreamsrpcv2.BlockScopedData) { + b.mut.Lock() + defer b.mut.Unlock() + + b.buf.Items = append(b.buf.Items, msg) +} + +func (b *MessageBuffer) ShouldFlush() bool { + b.mut.Lock() + defer b.mut.Unlock() + + if len(b.buf.Items) > b.maxBufferedMessage { + return true + } + + return false +} + +func (b *MessageBuffer) Flush(streamSrv *response.Stream) error { + b.mut.Lock() + defer b.mut.Unlock() + + if b.maxBufferedMessage > 2 { + for _, msg := range b.buf.Items { + err := streamSrv.BlockScopedData(msg) + if err != nil { + return fmt.Errorf("flushing single block scope data: %w", err) + } + } + } + + err := streamSrv.BlockScopedDatas(b.buf) + if err != nil { + return fmt.Errorf("flushing buffer: %w", err) + } + + b.lastFlush = time.Now() + b.buf = &pbsubstreamsrpcv2.BlockScopedDatas{Items: []*pbsubstreamsrpcv2.BlockScopedData{}} + + return nil +} diff --git a/orchestrator/parallelprocessor.go b/orchestrator/parallelprocessor.go index 617bf7a42..9f1f27c68 100644 --- a/orchestrator/parallelprocessor.go +++ b/orchestrator/parallelprocessor.go @@ -33,6 +33,7 @@ func BuildParallelProcessor( respFunc func(resp substreams.ResponseFromAnyTier) error, storeConfigs store.ConfigMap, noopMode bool, + bufferSize int, ) (*ParallelProcessor, error) { // FIXME: Are all the progress messages properly sent? When we skip some stores and mark them complete, @@ -68,6 +69,7 @@ func BuildParallelProcessor( reqPlan.ReadExecOut, stream, noopMode, + bufferSize, ) } } diff --git a/orchestrator/response/stream.go b/orchestrator/response/stream.go index 7800a7c98..187b18e46 100644 --- a/orchestrator/response/stream.go +++ b/orchestrator/response/stream.go @@ -19,6 +19,10 @@ func (s *Stream) BlockScopedData(in *pbsubstreamsrpc.BlockScopedData) error { return s.respFunc(substreams.NewBlockScopedDataResponse(in)) } +func (s *Stream) BlockScopedDatas(in *pbsubstreamsrpc.BlockScopedDatas) error { + return s.respFunc(substreams.NewBlockScopedDatasResponse(in)) +} + func (s *Stream) SendModulesStats(stats []*pbsubstreamsrpc.ModuleStats, stages []*pbsubstreamsrpc.Stage, jobs []*pbsubstreamsrpc.Job, bytesRead, bytesWritten, blocksProcessed uint64) error { return s.respFunc(&pbsubstreamsrpc.Response{ Message: &pbsubstreamsrpc.Response_Progress{ diff --git a/orchestrator/scheduler/scheduler.go b/orchestrator/scheduler/scheduler.go index 27eac0b9e..c9a1a6f2d 100644 --- a/orchestrator/scheduler/scheduler.go +++ b/orchestrator/scheduler/scheduler.go @@ -385,7 +385,7 @@ func (s *Scheduler) cmdShutdownWhenComplete() loop.Cmd { ) } - s.logger.Info("waiting for output stream to complete, stores ready", fields...) + s.logger.Info("`waiting for output stream to complete, stores ready", fields...) } if s.outputStreamCompleted && !s.storesSyncCompleted { s.logger.Info("waiting for stores to complete, output stream completed") diff --git a/pb/sf/codegen/conversation/v1/conversation_grpc.pb.go b/pb/sf/codegen/conversation/v1/conversation_grpc.pb.go index c32558e36..91cf95a6e 100644 --- a/pb/sf/codegen/conversation/v1/conversation_grpc.pb.go +++ b/pb/sf/codegen/conversation/v1/conversation_grpc.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.6.0 +// - protoc-gen-go-grpc v1.5.1 // - protoc (unknown) // source: sf/codegen/conversation/v1/conversation.proto @@ -78,10 +78,10 @@ type ConversationServiceServer interface { type UnimplementedConversationServiceServer struct{} func (UnimplementedConversationServiceServer) Converse(grpc.BidiStreamingServer[UserInput, SystemOutput]) error { - return status.Error(codes.Unimplemented, "method Converse not implemented") + return status.Errorf(codes.Unimplemented, "method Converse not implemented") } func (UnimplementedConversationServiceServer) Discover(context.Context, *DiscoveryRequest) (*DiscoveryResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Discover not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Discover not implemented") } func (UnimplementedConversationServiceServer) testEmbeddedByValue() {} @@ -93,7 +93,7 @@ type UnsafeConversationServiceServer interface { } func RegisterConversationServiceServer(s grpc.ServiceRegistrar, srv ConversationServiceServer) { - // If the following call panics, it indicates UnimplementedConversationServiceServer was + // If the following call pancis, it indicates UnimplementedConversationServiceServer was // embedded by pointer and is nil. This will cause panics if an // unimplemented method is ever invoked, so we test this at initialization // time to prevent it from happening at runtime later due to I/O. diff --git a/pb/sf/codegen/conversation/v1/conversation_vtproto.pb.go b/pb/sf/codegen/conversation/v1/conversation_vtproto.pb.go new file mode 100644 index 000000000..4c47ccede --- /dev/null +++ b/pb/sf/codegen/conversation/v1/conversation_vtproto.pb.go @@ -0,0 +1,7957 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/codegen/conversation/v1/conversation.proto + +package pbconvo + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" +) + +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) +) + +func (m *Empty) CloneVT() *Empty { + if m == nil { + return (*Empty)(nil) + } + r := new(Empty) + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Empty) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_TextInput) CloneVT() *UserInput_TextInput { + if m == nil { + return (*UserInput_TextInput)(nil) + } + r := new(UserInput_TextInput) + r.Value = m.Value + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput_TextInput) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_LocalFile) CloneVT() *UserInput_LocalFile { + if m == nil { + return (*UserInput_LocalFile)(nil) + } + r := new(UserInput_LocalFile) + if rhs := m.Value; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Value = tmpBytes + } + if rhs := m.Error; rhs != nil { + tmpVal := *rhs + r.Error = &tmpVal + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput_LocalFile) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_Start) CloneVT() *UserInput_Start { + if m == nil { + return (*UserInput_Start)(nil) + } + r := new(UserInput_Start) + r.GeneratorId = m.GeneratorId + r.Hydrate = m.Hydrate.CloneVT() + r.Version = m.Version + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput_Start) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_Hydrate) CloneVT() *UserInput_Hydrate { + if m == nil { + return (*UserInput_Hydrate)(nil) + } + r := new(UserInput_Hydrate) + r.SavedState = m.SavedState + r.LastMsgId = m.LastMsgId + r.ResetConversation = m.ResetConversation + if rhs := m.Signature; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Signature = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput_Hydrate) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_Upload) CloneVT() *UserInput_Upload { + if m == nil { + return (*UserInput_Upload)(nil) + } + r := new(UserInput_Upload) + r.MimeType = m.MimeType + r.Filename = m.Filename + if rhs := m.Content; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Content = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput_Upload) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_Selection) CloneVT() *UserInput_Selection { + if m == nil { + return (*UserInput_Selection)(nil) + } + r := new(UserInput_Selection) + r.Label = m.Label + r.Value = m.Value + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput_Selection) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_Confirmation) CloneVT() *UserInput_Confirmation { + if m == nil { + return (*UserInput_Confirmation)(nil) + } + r := new(UserInput_Confirmation) + r.Affirmative = m.Affirmative + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput_Confirmation) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_DownloadedFiles) CloneVT() *UserInput_DownloadedFiles { + if m == nil { + return (*UserInput_DownloadedFiles)(nil) + } + r := new(UserInput_DownloadedFiles) + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput_DownloadedFiles) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput) CloneVT() *UserInput { + if m == nil { + return (*UserInput)(nil) + } + r := new(UserInput) + r.MsgId = m.MsgId + r.FromMsgId = m.FromMsgId + r.FromActionId = m.FromActionId + if m.Entry != nil { + r.Entry = m.Entry.(interface{ CloneVT() isUserInput_Entry }).CloneVT() + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserInput) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserInput_Start_) CloneVT() isUserInput_Entry { + if m == nil { + return (*UserInput_Start_)(nil) + } + r := new(UserInput_Start_) + r.Start = m.Start.CloneVT() + return r +} + +func (m *UserInput_TextInput_) CloneVT() isUserInput_Entry { + if m == nil { + return (*UserInput_TextInput_)(nil) + } + r := new(UserInput_TextInput_) + r.TextInput = m.TextInput.CloneVT() + return r +} + +func (m *UserInput_Selection_) CloneVT() isUserInput_Entry { + if m == nil { + return (*UserInput_Selection_)(nil) + } + r := new(UserInput_Selection_) + r.Selection = m.Selection.CloneVT() + return r +} + +func (m *UserInput_Confirmation_) CloneVT() isUserInput_Entry { + if m == nil { + return (*UserInput_Confirmation_)(nil) + } + r := new(UserInput_Confirmation_) + r.Confirmation = m.Confirmation.CloneVT() + return r +} + +func (m *UserInput_File) CloneVT() isUserInput_Entry { + if m == nil { + return (*UserInput_File)(nil) + } + r := new(UserInput_File) + r.File = m.File.CloneVT() + return r +} + +func (m *UserInput_DownloadedFiles_) CloneVT() isUserInput_Entry { + if m == nil { + return (*UserInput_DownloadedFiles_)(nil) + } + r := new(UserInput_DownloadedFiles_) + r.DownloadedFiles = m.DownloadedFiles.CloneVT() + return r +} + +func (m *UserInput_LocalFile_) CloneVT() isUserInput_Entry { + if m == nil { + return (*UserInput_LocalFile_)(nil) + } + r := new(UserInput_LocalFile_) + r.LocalFile = m.LocalFile.CloneVT() + return r +} + +func (m *SystemOutput_Message) CloneVT() *SystemOutput_Message { + if m == nil { + return (*SystemOutput_Message)(nil) + } + r := new(SystemOutput_Message) + r.Markdown = m.Markdown + r.Style = m.Style + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_Message) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_ImageWithText) CloneVT() *SystemOutput_ImageWithText { + if m == nil { + return (*SystemOutput_ImageWithText)(nil) + } + r := new(SystemOutput_ImageWithText) + r.ImgUrl = m.ImgUrl + r.Markdown = m.Markdown + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_ImageWithText) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_ListSelect) CloneVT() *SystemOutput_ListSelect { + if m == nil { + return (*SystemOutput_ListSelect)(nil) + } + r := new(SystemOutput_ListSelect) + r.Id = m.Id + r.Instructions = m.Instructions + r.SelectMany = m.SelectMany + r.SelectType = m.SelectType + r.SelectButtonLabel = m.SelectButtonLabel + r.DefaultValue = m.DefaultValue + if rhs := m.Labels; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Labels = tmpContainer + } + if rhs := m.Values; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Values = tmpContainer + } + if rhs := m.ImageUrls; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ImageUrls = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_ListSelect) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_TextInput) CloneVT() *SystemOutput_TextInput { + if m == nil { + return (*SystemOutput_TextInput)(nil) + } + r := new(SystemOutput_TextInput) + r.Prompt = m.Prompt + r.Description = m.Description + r.Placeholder = m.Placeholder + r.DefaultValue = m.DefaultValue + r.MultiLine = m.MultiLine + r.ValidationRegexp = m.ValidationRegexp + r.ValidationErrorMessage = m.ValidationErrorMessage + r.SubmitButtonLabel = m.SubmitButtonLabel + r.SubmitButtonIcon = m.SubmitButtonIcon + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_TextInput) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_LocalFile) CloneVT() *SystemOutput_LocalFile { + if m == nil { + return (*SystemOutput_LocalFile)(nil) + } + r := new(SystemOutput_LocalFile) + r.Prompt = m.Prompt + r.Description = m.Description + r.Placeholder = m.Placeholder + r.DefaultValue = m.DefaultValue + r.SubmitButtonLabel = m.SubmitButtonLabel + r.SubmitButtonIcon = m.SubmitButtonIcon + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_LocalFile) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_Loading) CloneVT() *SystemOutput_Loading { + if m == nil { + return (*SystemOutput_Loading)(nil) + } + r := new(SystemOutput_Loading) + r.Loading = m.Loading + r.Label = m.Label + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_Loading) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_DownloadFiles) CloneVT() *SystemOutput_DownloadFiles { + if m == nil { + return (*SystemOutput_DownloadFiles)(nil) + } + r := new(SystemOutput_DownloadFiles) + if rhs := m.Files; rhs != nil { + tmpContainer := make([]*SystemOutput_DownloadFile, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Files = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_DownloadFiles) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_DownloadFile) CloneVT() *SystemOutput_DownloadFile { + if m == nil { + return (*SystemOutput_DownloadFile)(nil) + } + r := new(SystemOutput_DownloadFile) + r.Filename = m.Filename + r.Type = m.Type + r.Description = m.Description + if rhs := m.Content; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Content = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_DownloadFile) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_Confirm) CloneVT() *SystemOutput_Confirm { + if m == nil { + return (*SystemOutput_Confirm)(nil) + } + r := new(SystemOutput_Confirm) + r.Prompt = m.Prompt + r.Description = m.Description + r.AcceptButtonLabel = m.AcceptButtonLabel + r.DeclineButtonLabel = m.DeclineButtonLabel + r.DefaultButton = m.DefaultButton + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput_Confirm) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput) CloneVT() *SystemOutput { + if m == nil { + return (*SystemOutput)(nil) + } + r := new(SystemOutput) + r.MsgId = m.MsgId + r.FromMsgId = m.FromMsgId + r.ActionId = m.ActionId + r.State = m.State + if rhs := m.StateSignature; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.StateSignature = tmpBytes + } + if m.Entry != nil { + r.Entry = m.Entry.(interface{ CloneVT() isSystemOutput_Entry }).CloneVT() + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SystemOutput) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SystemOutput_Message_) CloneVT() isSystemOutput_Entry { + if m == nil { + return (*SystemOutput_Message_)(nil) + } + r := new(SystemOutput_Message_) + r.Message = m.Message.CloneVT() + return r +} + +func (m *SystemOutput_ImageWithText_) CloneVT() isSystemOutput_Entry { + if m == nil { + return (*SystemOutput_ImageWithText_)(nil) + } + r := new(SystemOutput_ImageWithText_) + r.ImageWithText = m.ImageWithText.CloneVT() + return r +} + +func (m *SystemOutput_ListSelect_) CloneVT() isSystemOutput_Entry { + if m == nil { + return (*SystemOutput_ListSelect_)(nil) + } + r := new(SystemOutput_ListSelect_) + r.ListSelect = m.ListSelect.CloneVT() + return r +} + +func (m *SystemOutput_TextInput_) CloneVT() isSystemOutput_Entry { + if m == nil { + return (*SystemOutput_TextInput_)(nil) + } + r := new(SystemOutput_TextInput_) + r.TextInput = m.TextInput.CloneVT() + return r +} + +func (m *SystemOutput_Confirm_) CloneVT() isSystemOutput_Entry { + if m == nil { + return (*SystemOutput_Confirm_)(nil) + } + r := new(SystemOutput_Confirm_) + r.Confirm = m.Confirm.CloneVT() + return r +} + +func (m *SystemOutput_Loading_) CloneVT() isSystemOutput_Entry { + if m == nil { + return (*SystemOutput_Loading_)(nil) + } + r := new(SystemOutput_Loading_) + r.Loading = m.Loading.CloneVT() + return r +} + +func (m *SystemOutput_DownloadFiles_) CloneVT() isSystemOutput_Entry { + if m == nil { + return (*SystemOutput_DownloadFiles_)(nil) + } + r := new(SystemOutput_DownloadFiles_) + r.DownloadFiles = m.DownloadFiles.CloneVT() + return r +} + +func (m *SystemOutput_LocalFile_) CloneVT() isSystemOutput_Entry { + if m == nil { + return (*SystemOutput_LocalFile_)(nil) + } + r := new(SystemOutput_LocalFile_) + r.LocalFile = m.LocalFile.CloneVT() + return r +} + +func (m *DiscoveryRequest) CloneVT() *DiscoveryRequest { + if m == nil { + return (*DiscoveryRequest)(nil) + } + r := new(DiscoveryRequest) + r.SearchTerms = m.SearchTerms + r.ClientVersion = m.ClientVersion + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DiscoveryRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DiscoveryResponse_Generator) CloneVT() *DiscoveryResponse_Generator { + if m == nil { + return (*DiscoveryResponse_Generator)(nil) + } + r := new(DiscoveryResponse_Generator) + r.Id = m.Id + r.Title = m.Title + r.Description = m.Description + r.IconUrl = m.IconUrl + r.Endpoint = m.Endpoint + r.Group = m.Group + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DiscoveryResponse_Generator) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DiscoveryResponse) CloneVT() *DiscoveryResponse { + if m == nil { + return (*DiscoveryResponse)(nil) + } + r := new(DiscoveryResponse) + if rhs := m.Generators; rhs != nil { + tmpContainer := make([]*DiscoveryResponse_Generator, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Generators = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DiscoveryResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *Empty) EqualVT(that *Empty) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Empty) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Empty) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_TextInput) EqualVT(that *UserInput_TextInput) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Value != that.Value { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput_TextInput) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput_TextInput) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_LocalFile) EqualVT(that *UserInput_LocalFile) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if string(this.Value) != string(that.Value) { + return false + } + if p, q := this.Error, that.Error; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput_LocalFile) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput_LocalFile) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_Start) EqualVT(that *UserInput_Start) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.GeneratorId != that.GeneratorId { + return false + } + if !this.Hydrate.EqualVT(that.Hydrate) { + return false + } + if this.Version != that.Version { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput_Start) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput_Start) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_Hydrate) EqualVT(that *UserInput_Hydrate) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.SavedState != that.SavedState { + return false + } + if string(this.Signature) != string(that.Signature) { + return false + } + if this.LastMsgId != that.LastMsgId { + return false + } + if this.ResetConversation != that.ResetConversation { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput_Hydrate) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput_Hydrate) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_Upload) EqualVT(that *UserInput_Upload) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.MimeType != that.MimeType { + return false + } + if this.Filename != that.Filename { + return false + } + if string(this.Content) != string(that.Content) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput_Upload) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput_Upload) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_Selection) EqualVT(that *UserInput_Selection) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Label != that.Label { + return false + } + if this.Value != that.Value { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput_Selection) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput_Selection) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_Confirmation) EqualVT(that *UserInput_Confirmation) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Affirmative != that.Affirmative { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput_Confirmation) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput_Confirmation) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_DownloadedFiles) EqualVT(that *UserInput_DownloadedFiles) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput_DownloadedFiles) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput_DownloadedFiles) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput) EqualVT(that *UserInput) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Entry == nil && that.Entry != nil { + return false + } else if this.Entry != nil { + if that.Entry == nil { + return false + } + if !this.Entry.(interface{ EqualVT(isUserInput_Entry) bool }).EqualVT(that.Entry) { + return false + } + } + if this.MsgId != that.MsgId { + return false + } + if this.FromMsgId != that.FromMsgId { + return false + } + if this.FromActionId != that.FromActionId { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UserInput) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UserInput) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UserInput_Start_) EqualVT(thatIface isUserInput_Entry) bool { + that, ok := thatIface.(*UserInput_Start_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Start, that.Start; p != q { + if p == nil { + p = &UserInput_Start{} + } + if q == nil { + q = &UserInput_Start{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *UserInput_TextInput_) EqualVT(thatIface isUserInput_Entry) bool { + that, ok := thatIface.(*UserInput_TextInput_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.TextInput, that.TextInput; p != q { + if p == nil { + p = &UserInput_TextInput{} + } + if q == nil { + q = &UserInput_TextInput{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *UserInput_File) EqualVT(thatIface isUserInput_Entry) bool { + that, ok := thatIface.(*UserInput_File) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.File, that.File; p != q { + if p == nil { + p = &UserInput_Upload{} + } + if q == nil { + q = &UserInput_Upload{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *UserInput_Selection_) EqualVT(thatIface isUserInput_Entry) bool { + that, ok := thatIface.(*UserInput_Selection_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Selection, that.Selection; p != q { + if p == nil { + p = &UserInput_Selection{} + } + if q == nil { + q = &UserInput_Selection{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *UserInput_Confirmation_) EqualVT(thatIface isUserInput_Entry) bool { + that, ok := thatIface.(*UserInput_Confirmation_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Confirmation, that.Confirmation; p != q { + if p == nil { + p = &UserInput_Confirmation{} + } + if q == nil { + q = &UserInput_Confirmation{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *UserInput_DownloadedFiles_) EqualVT(thatIface isUserInput_Entry) bool { + that, ok := thatIface.(*UserInput_DownloadedFiles_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.DownloadedFiles, that.DownloadedFiles; p != q { + if p == nil { + p = &UserInput_DownloadedFiles{} + } + if q == nil { + q = &UserInput_DownloadedFiles{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *UserInput_LocalFile_) EqualVT(thatIface isUserInput_Entry) bool { + that, ok := thatIface.(*UserInput_LocalFile_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.LocalFile, that.LocalFile; p != q { + if p == nil { + p = &UserInput_LocalFile{} + } + if q == nil { + q = &UserInput_LocalFile{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *SystemOutput_Message) EqualVT(that *SystemOutput_Message) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Markdown != that.Markdown { + return false + } + if this.Style != that.Style { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_Message) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_Message) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_ImageWithText) EqualVT(that *SystemOutput_ImageWithText) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.ImgUrl != that.ImgUrl { + return false + } + if this.Markdown != that.Markdown { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_ImageWithText) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_ImageWithText) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_ListSelect) EqualVT(that *SystemOutput_ListSelect) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Id != that.Id { + return false + } + if len(this.Labels) != len(that.Labels) { + return false + } + for i, vx := range this.Labels { + vy := that.Labels[i] + if vx != vy { + return false + } + } + if len(this.Values) != len(that.Values) { + return false + } + for i, vx := range this.Values { + vy := that.Values[i] + if vx != vy { + return false + } + } + if len(this.ImageUrls) != len(that.ImageUrls) { + return false + } + for i, vx := range this.ImageUrls { + vy := that.ImageUrls[i] + if vx != vy { + return false + } + } + if this.SelectButtonLabel != that.SelectButtonLabel { + return false + } + if this.Instructions != that.Instructions { + return false + } + if this.SelectType != that.SelectType { + return false + } + if this.SelectMany != that.SelectMany { + return false + } + if this.DefaultValue != that.DefaultValue { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_ListSelect) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_ListSelect) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_TextInput) EqualVT(that *SystemOutput_TextInput) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Description != that.Description { + return false + } + if this.Placeholder != that.Placeholder { + return false + } + if this.MultiLine != that.MultiLine { + return false + } + if this.ValidationRegexp != that.ValidationRegexp { + return false + } + if this.ValidationErrorMessage != that.ValidationErrorMessage { + return false + } + if this.SubmitButtonLabel != that.SubmitButtonLabel { + return false + } + if this.SubmitButtonIcon != that.SubmitButtonIcon { + return false + } + if this.Prompt != that.Prompt { + return false + } + if this.DefaultValue != that.DefaultValue { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_TextInput) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_TextInput) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_LocalFile) EqualVT(that *SystemOutput_LocalFile) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Description != that.Description { + return false + } + if this.Placeholder != that.Placeholder { + return false + } + if this.SubmitButtonLabel != that.SubmitButtonLabel { + return false + } + if this.SubmitButtonIcon != that.SubmitButtonIcon { + return false + } + if this.Prompt != that.Prompt { + return false + } + if this.DefaultValue != that.DefaultValue { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_LocalFile) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_LocalFile) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_Loading) EqualVT(that *SystemOutput_Loading) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Loading != that.Loading { + return false + } + if this.Label != that.Label { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_Loading) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_Loading) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_DownloadFiles) EqualVT(that *SystemOutput_DownloadFiles) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Files) != len(that.Files) { + return false + } + for i, vx := range this.Files { + vy := that.Files[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &SystemOutput_DownloadFile{} + } + if q == nil { + q = &SystemOutput_DownloadFile{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_DownloadFiles) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_DownloadFiles) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_DownloadFile) EqualVT(that *SystemOutput_DownloadFile) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Filename != that.Filename { + return false + } + if this.Type != that.Type { + return false + } + if string(this.Content) != string(that.Content) { + return false + } + if this.Description != that.Description { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_DownloadFile) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_DownloadFile) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_Confirm) EqualVT(that *SystemOutput_Confirm) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Prompt != that.Prompt { + return false + } + if this.AcceptButtonLabel != that.AcceptButtonLabel { + return false + } + if this.DeclineButtonLabel != that.DeclineButtonLabel { + return false + } + if this.Description != that.Description { + return false + } + if this.DefaultButton != that.DefaultButton { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput_Confirm) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput_Confirm) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput) EqualVT(that *SystemOutput) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Entry == nil && that.Entry != nil { + return false + } else if this.Entry != nil { + if that.Entry == nil { + return false + } + if !this.Entry.(interface { + EqualVT(isSystemOutput_Entry) bool + }).EqualVT(that.Entry) { + return false + } + } + if this.MsgId != that.MsgId { + return false + } + if this.FromMsgId != that.FromMsgId { + return false + } + if this.ActionId != that.ActionId { + return false + } + if this.State != that.State { + return false + } + if string(this.StateSignature) != string(that.StateSignature) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SystemOutput) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SystemOutput) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SystemOutput_Message_) EqualVT(thatIface isSystemOutput_Entry) bool { + that, ok := thatIface.(*SystemOutput_Message_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Message, that.Message; p != q { + if p == nil { + p = &SystemOutput_Message{} + } + if q == nil { + q = &SystemOutput_Message{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *SystemOutput_ImageWithText_) EqualVT(thatIface isSystemOutput_Entry) bool { + that, ok := thatIface.(*SystemOutput_ImageWithText_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.ImageWithText, that.ImageWithText; p != q { + if p == nil { + p = &SystemOutput_ImageWithText{} + } + if q == nil { + q = &SystemOutput_ImageWithText{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *SystemOutput_ListSelect_) EqualVT(thatIface isSystemOutput_Entry) bool { + that, ok := thatIface.(*SystemOutput_ListSelect_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.ListSelect, that.ListSelect; p != q { + if p == nil { + p = &SystemOutput_ListSelect{} + } + if q == nil { + q = &SystemOutput_ListSelect{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *SystemOutput_TextInput_) EqualVT(thatIface isSystemOutput_Entry) bool { + that, ok := thatIface.(*SystemOutput_TextInput_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.TextInput, that.TextInput; p != q { + if p == nil { + p = &SystemOutput_TextInput{} + } + if q == nil { + q = &SystemOutput_TextInput{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *SystemOutput_Loading_) EqualVT(thatIface isSystemOutput_Entry) bool { + that, ok := thatIface.(*SystemOutput_Loading_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Loading, that.Loading; p != q { + if p == nil { + p = &SystemOutput_Loading{} + } + if q == nil { + q = &SystemOutput_Loading{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *SystemOutput_DownloadFiles_) EqualVT(thatIface isSystemOutput_Entry) bool { + that, ok := thatIface.(*SystemOutput_DownloadFiles_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.DownloadFiles, that.DownloadFiles; p != q { + if p == nil { + p = &SystemOutput_DownloadFiles{} + } + if q == nil { + q = &SystemOutput_DownloadFiles{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *SystemOutput_Confirm_) EqualVT(thatIface isSystemOutput_Entry) bool { + that, ok := thatIface.(*SystemOutput_Confirm_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Confirm, that.Confirm; p != q { + if p == nil { + p = &SystemOutput_Confirm{} + } + if q == nil { + q = &SystemOutput_Confirm{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *SystemOutput_LocalFile_) EqualVT(thatIface isSystemOutput_Entry) bool { + that, ok := thatIface.(*SystemOutput_LocalFile_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.LocalFile, that.LocalFile; p != q { + if p == nil { + p = &SystemOutput_LocalFile{} + } + if q == nil { + q = &SystemOutput_LocalFile{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *DiscoveryRequest) EqualVT(that *DiscoveryRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.SearchTerms != that.SearchTerms { + return false + } + if this.ClientVersion != that.ClientVersion { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *DiscoveryRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*DiscoveryRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *DiscoveryResponse_Generator) EqualVT(that *DiscoveryResponse_Generator) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Id != that.Id { + return false + } + if this.Title != that.Title { + return false + } + if this.Description != that.Description { + return false + } + if this.IconUrl != that.IconUrl { + return false + } + if this.Endpoint != that.Endpoint { + return false + } + if this.Group != that.Group { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *DiscoveryResponse_Generator) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*DiscoveryResponse_Generator) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *DiscoveryResponse) EqualVT(that *DiscoveryResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Generators) != len(that.Generators) { + return false + } + for i, vx := range this.Generators { + vy := that.Generators[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &DiscoveryResponse_Generator{} + } + if q == nil { + q = &DiscoveryResponse_Generator{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *DiscoveryResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*DiscoveryResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *Empty) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Empty) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Empty) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *UserInput_TextInput) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput_TextInput) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_TextInput) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UserInput_LocalFile) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput_LocalFile) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_LocalFile) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Error != nil { + i -= len(*m.Error) + copy(dAtA[i:], *m.Error) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(*m.Error))) + i-- + dAtA[i] = 0x12 + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UserInput_Start) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput_Start) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_Start) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Version != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x18 + } + if m.Hydrate != nil { + size, err := m.Hydrate.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.GeneratorId) > 0 { + i -= len(m.GeneratorId) + copy(dAtA[i:], m.GeneratorId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GeneratorId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UserInput_Hydrate) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput_Hydrate) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_Hydrate) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ResetConversation { + i-- + if m.ResetConversation { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.LastMsgId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.LastMsgId)) + i-- + dAtA[i] = 0x18 + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 + } + if len(m.SavedState) > 0 { + i -= len(m.SavedState) + copy(dAtA[i:], m.SavedState) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SavedState))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UserInput_Upload) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput_Upload) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_Upload) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Content) > 0 { + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0x1a + } + if len(m.Filename) > 0 { + i -= len(m.Filename) + copy(dAtA[i:], m.Filename) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Filename))) + i-- + dAtA[i] = 0x12 + } + if len(m.MimeType) > 0 { + i -= len(m.MimeType) + copy(dAtA[i:], m.MimeType) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MimeType))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UserInput_Selection) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput_Selection) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_Selection) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Label) > 0 { + i -= len(m.Label) + copy(dAtA[i:], m.Label) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Label))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UserInput_Confirmation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput_Confirmation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_Confirmation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Affirmative { + i-- + if m.Affirmative { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *UserInput_DownloadedFiles) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput_DownloadedFiles) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_DownloadedFiles) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *UserInput) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UserInput) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Entry.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if len(m.FromActionId) > 0 { + i -= len(m.FromActionId) + copy(dAtA[i:], m.FromActionId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FromActionId))) + i-- + dAtA[i] = 0x1a + } + if m.FromMsgId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FromMsgId)) + i-- + dAtA[i] = 0x10 + } + if m.MsgId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MsgId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *UserInput_Start_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_Start_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Start != nil { + size, err := m.Start.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + return len(dAtA) - i, nil +} +func (m *UserInput_TextInput_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_TextInput_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.TextInput != nil { + size, err := m.TextInput.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + return len(dAtA) - i, nil +} +func (m *UserInput_File) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_File) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.File != nil { + size, err := m.File.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *UserInput_Selection_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_Selection_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Selection != nil { + size, err := m.Selection.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *UserInput_Confirmation_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_Confirmation_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Confirmation != nil { + size, err := m.Confirmation.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *UserInput_DownloadedFiles_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_DownloadedFiles_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.DownloadedFiles != nil { + size, err := m.DownloadedFiles.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *UserInput_LocalFile_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UserInput_LocalFile_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.LocalFile != nil { + size, err := m.LocalFile.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *SystemOutput_Message) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_Message) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Style) > 0 { + i -= len(m.Style) + copy(dAtA[i:], m.Style) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Style))) + i-- + dAtA[i] = 0x12 + } + if len(m.Markdown) > 0 { + i -= len(m.Markdown) + copy(dAtA[i:], m.Markdown) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Markdown))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_ImageWithText) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_ImageWithText) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_ImageWithText) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Markdown) > 0 { + i -= len(m.Markdown) + copy(dAtA[i:], m.Markdown) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Markdown))) + i-- + dAtA[i] = 0x12 + } + if len(m.ImgUrl) > 0 { + i -= len(m.ImgUrl) + copy(dAtA[i:], m.ImgUrl) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ImgUrl))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_ListSelect) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_ListSelect) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_ListSelect) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.DefaultValue) > 0 { + i -= len(m.DefaultValue) + copy(dAtA[i:], m.DefaultValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DefaultValue))) + i-- + dAtA[i] = 0x4a + } + if m.SelectMany { + i-- + if m.SelectMany { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if m.SelectType != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SelectType)) + i-- + dAtA[i] = 0x38 + } + if len(m.Instructions) > 0 { + i -= len(m.Instructions) + copy(dAtA[i:], m.Instructions) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Instructions))) + i-- + dAtA[i] = 0x32 + } + if len(m.SelectButtonLabel) > 0 { + i -= len(m.SelectButtonLabel) + copy(dAtA[i:], m.SelectButtonLabel) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SelectButtonLabel))) + i-- + dAtA[i] = 0x2a + } + if len(m.ImageUrls) > 0 { + for iNdEx := len(m.ImageUrls) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ImageUrls[iNdEx]) + copy(dAtA[i:], m.ImageUrls[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ImageUrls[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Values) > 0 { + for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Values[iNdEx]) + copy(dAtA[i:], m.Values[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Values[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Labels) > 0 { + for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Labels[iNdEx]) + copy(dAtA[i:], m.Labels[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Labels[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_TextInput) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_TextInput) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_TextInput) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.DefaultValue) > 0 { + i -= len(m.DefaultValue) + copy(dAtA[i:], m.DefaultValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DefaultValue))) + i-- + dAtA[i] = 0x4a + } + if len(m.Prompt) > 0 { + i -= len(m.Prompt) + copy(dAtA[i:], m.Prompt) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Prompt))) + i-- + dAtA[i] = 0x42 + } + if len(m.SubmitButtonIcon) > 0 { + i -= len(m.SubmitButtonIcon) + copy(dAtA[i:], m.SubmitButtonIcon) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SubmitButtonIcon))) + i-- + dAtA[i] = 0x3a + } + if len(m.SubmitButtonLabel) > 0 { + i -= len(m.SubmitButtonLabel) + copy(dAtA[i:], m.SubmitButtonLabel) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SubmitButtonLabel))) + i-- + dAtA[i] = 0x32 + } + if len(m.ValidationErrorMessage) > 0 { + i -= len(m.ValidationErrorMessage) + copy(dAtA[i:], m.ValidationErrorMessage) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ValidationErrorMessage))) + i-- + dAtA[i] = 0x2a + } + if len(m.ValidationRegexp) > 0 { + i -= len(m.ValidationRegexp) + copy(dAtA[i:], m.ValidationRegexp) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ValidationRegexp))) + i-- + dAtA[i] = 0x22 + } + if m.MultiLine != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MultiLine)) + i-- + dAtA[i] = 0x18 + } + if len(m.Placeholder) > 0 { + i -= len(m.Placeholder) + copy(dAtA[i:], m.Placeholder) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Placeholder))) + i-- + dAtA[i] = 0x12 + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_LocalFile) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_LocalFile) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_LocalFile) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.DefaultValue) > 0 { + i -= len(m.DefaultValue) + copy(dAtA[i:], m.DefaultValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DefaultValue))) + i-- + dAtA[i] = 0x4a + } + if len(m.Prompt) > 0 { + i -= len(m.Prompt) + copy(dAtA[i:], m.Prompt) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Prompt))) + i-- + dAtA[i] = 0x42 + } + if len(m.SubmitButtonIcon) > 0 { + i -= len(m.SubmitButtonIcon) + copy(dAtA[i:], m.SubmitButtonIcon) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SubmitButtonIcon))) + i-- + dAtA[i] = 0x3a + } + if len(m.SubmitButtonLabel) > 0 { + i -= len(m.SubmitButtonLabel) + copy(dAtA[i:], m.SubmitButtonLabel) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SubmitButtonLabel))) + i-- + dAtA[i] = 0x32 + } + if len(m.Placeholder) > 0 { + i -= len(m.Placeholder) + copy(dAtA[i:], m.Placeholder) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Placeholder))) + i-- + dAtA[i] = 0x12 + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_Loading) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_Loading) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_Loading) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Label) > 0 { + i -= len(m.Label) + copy(dAtA[i:], m.Label) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Label))) + i-- + dAtA[i] = 0x12 + } + if m.Loading { + i-- + if m.Loading { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_DownloadFiles) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_DownloadFiles) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_DownloadFiles) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Files) > 0 { + for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Files[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_DownloadFile) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_DownloadFile) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_DownloadFile) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x22 + } + if len(m.Content) > 0 { + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0x1a + } + if len(m.Type) > 0 { + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0x12 + } + if len(m.Filename) > 0 { + i -= len(m.Filename) + copy(dAtA[i:], m.Filename) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Filename))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_Confirm) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput_Confirm) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_Confirm) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.DefaultButton != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DefaultButton)) + i-- + dAtA[i] = 0x28 + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x22 + } + if len(m.DeclineButtonLabel) > 0 { + i -= len(m.DeclineButtonLabel) + copy(dAtA[i:], m.DeclineButtonLabel) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeclineButtonLabel))) + i-- + dAtA[i] = 0x1a + } + if len(m.AcceptButtonLabel) > 0 { + i -= len(m.AcceptButtonLabel) + copy(dAtA[i:], m.AcceptButtonLabel) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AcceptButtonLabel))) + i-- + dAtA[i] = 0x12 + } + if len(m.Prompt) > 0 { + i -= len(m.Prompt) + copy(dAtA[i:], m.Prompt) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Prompt))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SystemOutput) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Entry.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if len(m.StateSignature) > 0 { + i -= len(m.StateSignature) + copy(dAtA[i:], m.StateSignature) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateSignature))) + i-- + dAtA[i] = 0x2a + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0x22 + } + if len(m.ActionId) > 0 { + i -= len(m.ActionId) + copy(dAtA[i:], m.ActionId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ActionId))) + i-- + dAtA[i] = 0x1a + } + if m.FromMsgId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FromMsgId)) + i-- + dAtA[i] = 0x10 + } + if m.MsgId != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MsgId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SystemOutput_Message_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_Message_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Message != nil { + size, err := m.Message.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x7a + } + return len(dAtA) - i, nil +} +func (m *SystemOutput_ImageWithText_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_ImageWithText_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ImageWithText != nil { + size, err := m.ImageWithText.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *SystemOutput_ListSelect_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_ListSelect_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ListSelect != nil { + size, err := m.ListSelect.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} +func (m *SystemOutput_TextInput_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_TextInput_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.TextInput != nil { + size, err := m.TextInput.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *SystemOutput_Loading_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_Loading_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Loading != nil { + size, err := m.Loading.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *SystemOutput_DownloadFiles_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_DownloadFiles_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.DownloadFiles != nil { + size, err := m.DownloadFiles.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *SystemOutput_Confirm_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_Confirm_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Confirm != nil { + size, err := m.Confirm.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} +func (m *SystemOutput_LocalFile_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SystemOutput_LocalFile_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.LocalFile != nil { + size, err := m.LocalFile.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb2 + } + return len(dAtA) - i, nil +} +func (m *DiscoveryRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DiscoveryRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DiscoveryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ClientVersion != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClientVersion)) + i-- + dAtA[i] = 0x10 + } + if len(m.SearchTerms) > 0 { + i -= len(m.SearchTerms) + copy(dAtA[i:], m.SearchTerms) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SearchTerms))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DiscoveryResponse_Generator) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DiscoveryResponse_Generator) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DiscoveryResponse_Generator) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Group) > 0 { + i -= len(m.Group) + copy(dAtA[i:], m.Group) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Group))) + i-- + dAtA[i] = 0x32 + } + if len(m.Endpoint) > 0 { + i -= len(m.Endpoint) + copy(dAtA[i:], m.Endpoint) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Endpoint))) + i-- + dAtA[i] = 0x2a + } + if len(m.IconUrl) > 0 { + i -= len(m.IconUrl) + copy(dAtA[i:], m.IconUrl) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.IconUrl))) + i-- + dAtA[i] = 0x22 + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x1a + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0x12 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DiscoveryResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DiscoveryResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DiscoveryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Generators) > 0 { + for iNdEx := len(m.Generators) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Generators[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *Empty) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *UserInput_TextInput) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UserInput_LocalFile) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Error != nil { + l = len(*m.Error) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UserInput_Start) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.GeneratorId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Hydrate != nil { + l = m.Hydrate.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Version != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Version)) + } + n += len(m.unknownFields) + return n +} + +func (m *UserInput_Hydrate) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SavedState) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.LastMsgId != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.LastMsgId)) + } + if m.ResetConversation { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *UserInput_Upload) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.MimeType) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Filename) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Content) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UserInput_Selection) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Label) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UserInput_Confirmation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Affirmative { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *UserInput_DownloadedFiles) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *UserInput) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MsgId != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.MsgId)) + } + if m.FromMsgId != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.FromMsgId)) + } + l = len(m.FromActionId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if vtmsg, ok := m.Entry.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *UserInput_Start_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Start != nil { + l = m.Start.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *UserInput_TextInput_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TextInput != nil { + l = m.TextInput.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *UserInput_File) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.File != nil { + l = m.File.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *UserInput_Selection_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Selection != nil { + l = m.Selection.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *UserInput_Confirmation_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Confirmation != nil { + l = m.Confirmation.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *UserInput_DownloadedFiles_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DownloadedFiles != nil { + l = m.DownloadedFiles.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *UserInput_LocalFile_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LocalFile != nil { + l = m.LocalFile.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *SystemOutput_Message) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Markdown) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Style) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_ImageWithText) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ImgUrl) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Markdown) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_ListSelect) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Labels) > 0 { + for _, s := range m.Labels { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Values) > 0 { + for _, s := range m.Values { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.ImageUrls) > 0 { + for _, s := range m.ImageUrls { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + l = len(m.SelectButtonLabel) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Instructions) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SelectType != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.SelectType)) + } + if m.SelectMany { + n += 2 + } + l = len(m.DefaultValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_TextInput) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Description) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Placeholder) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MultiLine != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.MultiLine)) + } + l = len(m.ValidationRegexp) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.ValidationErrorMessage) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SubmitButtonLabel) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SubmitButtonIcon) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Prompt) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.DefaultValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_LocalFile) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Description) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Placeholder) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SubmitButtonLabel) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SubmitButtonIcon) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Prompt) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.DefaultValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_Loading) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Loading { + n += 2 + } + l = len(m.Label) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_DownloadFiles) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Files) > 0 { + for _, e := range m.Files { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_DownloadFile) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Filename) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Type) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Content) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_Confirm) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Prompt) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.AcceptButtonLabel) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.DeclineButtonLabel) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DefaultButton != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.DefaultButton)) + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MsgId != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.MsgId)) + } + if m.FromMsgId != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.FromMsgId)) + } + l = len(m.ActionId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.State) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateSignature) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if vtmsg, ok := m.Entry.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *SystemOutput_Message_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Message != nil { + l = m.Message.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *SystemOutput_ImageWithText_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ImageWithText != nil { + l = m.ImageWithText.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *SystemOutput_ListSelect_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ListSelect != nil { + l = m.ListSelect.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *SystemOutput_TextInput_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TextInput != nil { + l = m.TextInput.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *SystemOutput_Loading_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Loading != nil { + l = m.Loading.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *SystemOutput_DownloadFiles_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DownloadFiles != nil { + l = m.DownloadFiles.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *SystemOutput_Confirm_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Confirm != nil { + l = m.Confirm.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *SystemOutput_LocalFile_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LocalFile != nil { + l = m.LocalFile.SizeVT() + n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *DiscoveryRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SearchTerms) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ClientVersion != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ClientVersion)) + } + n += len(m.unknownFields) + return n +} + +func (m *DiscoveryResponse_Generator) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Title) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.IconUrl) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Endpoint) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Group) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DiscoveryResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Generators) > 0 { + for _, e := range m.Generators { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *Empty) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Empty: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput_TextInput) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput_TextInput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput_TextInput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput_LocalFile) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput_LocalFile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput_LocalFile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Error = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput_Start) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput_Start: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput_Start: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GeneratorId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GeneratorId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hydrate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Hydrate == nil { + m.Hydrate = &UserInput_Hydrate{} + } + if err := m.Hydrate.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput_Hydrate) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput_Hydrate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput_Hydrate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SavedState", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SavedState = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastMsgId", wireType) + } + m.LastMsgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastMsgId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResetConversation", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ResetConversation = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput_Upload) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput_Upload: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput_Upload: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MimeType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MimeType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Filename", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Filename = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + 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 protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + 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 := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput_Selection) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput_Selection: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput_Selection: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Label = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput_Confirmation) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput_Confirmation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput_Confirmation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Affirmative", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Affirmative = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput_DownloadedFiles) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput_DownloadedFiles: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput_DownloadedFiles: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserInput) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UserInput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserInput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgId", wireType) + } + m.MsgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MsgId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FromMsgId", wireType) + } + m.FromMsgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FromMsgId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FromActionId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FromActionId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*UserInput_Start_); ok { + if err := oneof.Start.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &UserInput_Start{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &UserInput_Start_{Start: v} + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TextInput", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*UserInput_TextInput_); ok { + if err := oneof.TextInput.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &UserInput_TextInput{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &UserInput_TextInput_{TextInput: v} + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field File", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*UserInput_File); ok { + if err := oneof.File.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &UserInput_Upload{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &UserInput_File{File: v} + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Selection", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*UserInput_Selection_); ok { + if err := oneof.Selection.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &UserInput_Selection{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &UserInput_Selection_{Selection: v} + } + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Confirmation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*UserInput_Confirmation_); ok { + if err := oneof.Confirmation.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &UserInput_Confirmation{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &UserInput_Confirmation_{Confirmation: v} + } + iNdEx = postIndex + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DownloadedFiles", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*UserInput_DownloadedFiles_); ok { + if err := oneof.DownloadedFiles.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &UserInput_DownloadedFiles{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &UserInput_DownloadedFiles_{DownloadedFiles: v} + } + iNdEx = postIndex + case 21: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LocalFile", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*UserInput_LocalFile_); ok { + if err := oneof.LocalFile.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &UserInput_LocalFile{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &UserInput_LocalFile_{LocalFile: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_Message) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_Message: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_Message: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Markdown", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Markdown = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Style = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_ImageWithText) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_ImageWithText: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_ImageWithText: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ImgUrl", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ImgUrl = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Markdown", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Markdown = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_ListSelect) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_ListSelect: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_ListSelect: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Labels = append(m.Labels, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Values = append(m.Values, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ImageUrls", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ImageUrls = append(m.ImageUrls, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SelectButtonLabel", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SelectButtonLabel = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Instructions", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Instructions = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SelectType", wireType) + } + m.SelectType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SelectType |= SystemOutput_ListSelect_SelectType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SelectMany", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SelectMany = bool(v != 0) + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DefaultValue = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_TextInput) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_TextInput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_TextInput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Placeholder", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Placeholder = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MultiLine", wireType) + } + m.MultiLine = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MultiLine |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidationRegexp", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidationRegexp = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidationErrorMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidationErrorMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubmitButtonLabel", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SubmitButtonLabel = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubmitButtonIcon", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SubmitButtonIcon = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prompt", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Prompt = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DefaultValue = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_LocalFile) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_LocalFile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_LocalFile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Placeholder", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Placeholder = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubmitButtonLabel", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SubmitButtonLabel = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubmitButtonIcon", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SubmitButtonIcon = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prompt", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Prompt = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DefaultValue = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_Loading) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_Loading: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_Loading: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Loading", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Loading = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Label = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_DownloadFiles) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_DownloadFiles: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_DownloadFiles: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Files = append(m.Files, &SystemOutput_DownloadFile{}) + if err := m.Files[len(m.Files)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_DownloadFile) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_DownloadFile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_DownloadFile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Filename", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Filename = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + 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 protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...) + if m.Content == nil { + m.Content = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput_Confirm) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput_Confirm: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput_Confirm: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Prompt", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Prompt = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AcceptButtonLabel", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AcceptButtonLabel = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeclineButtonLabel", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeclineButtonLabel = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DefaultButton", wireType) + } + m.DefaultButton = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DefaultButton |= SystemOutput_Confirm_Button(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SystemOutput) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SystemOutput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SystemOutput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgId", wireType) + } + m.MsgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MsgId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FromMsgId", wireType) + } + m.FromMsgId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FromMsgId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActionId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ActionId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateSignature", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateSignature = append(m.StateSignature[:0], dAtA[iNdEx:postIndex]...) + if m.StateSignature == nil { + m.StateSignature = []byte{} + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*SystemOutput_Message_); ok { + if err := oneof.Message.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SystemOutput_Message{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &SystemOutput_Message_{Message: v} + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ImageWithText", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*SystemOutput_ImageWithText_); ok { + if err := oneof.ImageWithText.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SystemOutput_ImageWithText{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &SystemOutput_ImageWithText_{ImageWithText: v} + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListSelect", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*SystemOutput_ListSelect_); ok { + if err := oneof.ListSelect.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SystemOutput_ListSelect{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &SystemOutput_ListSelect_{ListSelect: v} + } + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TextInput", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*SystemOutput_TextInput_); ok { + if err := oneof.TextInput.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SystemOutput_TextInput{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &SystemOutput_TextInput_{TextInput: v} + } + iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Loading", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*SystemOutput_Loading_); ok { + if err := oneof.Loading.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SystemOutput_Loading{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &SystemOutput_Loading_{Loading: v} + } + iNdEx = postIndex + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DownloadFiles", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*SystemOutput_DownloadFiles_); ok { + if err := oneof.DownloadFiles.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SystemOutput_DownloadFiles{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &SystemOutput_DownloadFiles_{DownloadFiles: v} + } + iNdEx = postIndex + case 21: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Confirm", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*SystemOutput_Confirm_); ok { + if err := oneof.Confirm.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SystemOutput_Confirm{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &SystemOutput_Confirm_{Confirm: v} + } + iNdEx = postIndex + case 22: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LocalFile", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Entry.(*SystemOutput_LocalFile_); ok { + if err := oneof.LocalFile.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SystemOutput_LocalFile{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Entry = &SystemOutput_LocalFile_{LocalFile: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DiscoveryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: DiscoveryRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DiscoveryRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SearchTerms", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SearchTerms = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientVersion", wireType) + } + m.ClientVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ClientVersion |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DiscoveryResponse_Generator) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: DiscoveryResponse_Generator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DiscoveryResponse_Generator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IconUrl", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IconUrl = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Endpoint = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Group = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DiscoveryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: DiscoveryResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DiscoveryResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Generators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Generators = append(m.Generators, &DiscoveryResponse_Generator{}) + if err := m.Generators[len(m.Generators)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/index/v1/keys_vtproto.pb.go b/pb/sf/substreams/index/v1/keys_vtproto.pb.go new file mode 100644 index 000000000..3a6e0be9d --- /dev/null +++ b/pb/sf/substreams/index/v1/keys_vtproto.pb.go @@ -0,0 +1,208 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/index/v1/keys.proto + +package pbsubstreams + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" +) + +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) +) + +func (m *Keys) CloneVT() *Keys { + if m == nil { + return (*Keys)(nil) + } + r := new(Keys) + if rhs := m.Keys; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Keys = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Keys) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *Keys) EqualVT(that *Keys) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Keys) != len(that.Keys) { + return false + } + for i, vx := range this.Keys { + vy := that.Keys[i] + if vx != vy { + return false + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Keys) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Keys) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *Keys) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Keys) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Keys) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Keys) > 0 { + for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Keys[iNdEx]) + copy(dAtA[i:], m.Keys[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Keys[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *Keys) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Keys) > 0 { + for _, s := range m.Keys { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *Keys) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Keys: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Keys: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Keys = append(m.Keys, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/intern/v2/deltas_vtproto.pb.go b/pb/sf/substreams/intern/v2/deltas_vtproto.pb.go new file mode 100644 index 000000000..50460d395 --- /dev/null +++ b/pb/sf/substreams/intern/v2/deltas_vtproto.pb.go @@ -0,0 +1,1061 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/intern/v2/deltas.proto + +package pbssinternal + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + anypb1 "github.com/planetscale/vtprotobuf/types/known/anypb" + v1 "github.com/streamingfast/substreams/pb/sf/substreams/v1" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + io "io" +) + +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) +) + +func (m *ModuleOutput) CloneVT() *ModuleOutput { + if m == nil { + return (*ModuleOutput)(nil) + } + r := new(ModuleOutput) + r.ModuleName = m.ModuleName + r.DebugLogsTruncated = m.DebugLogsTruncated + r.Cached = m.Cached + if m.Data != nil { + r.Data = m.Data.(interface{ CloneVT() isModuleOutput_Data }).CloneVT() + } + if rhs := m.Logs; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Logs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ModuleOutput) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ModuleOutput_MapOutput) CloneVT() isModuleOutput_Data { + if m == nil { + return (*ModuleOutput_MapOutput)(nil) + } + r := new(ModuleOutput_MapOutput) + r.MapOutput = (*anypb.Any)((*anypb1.Any)(m.MapOutput).CloneVT()) + return r +} + +func (m *ModuleOutput_StoreDeltas) CloneVT() isModuleOutput_Data { + if m == nil { + return (*ModuleOutput_StoreDeltas)(nil) + } + r := new(ModuleOutput_StoreDeltas) + r.StoreDeltas = m.StoreDeltas.CloneVT() + return r +} + +func (m *Operations) CloneVT() *Operations { + if m == nil { + return (*Operations)(nil) + } + r := new(Operations) + if rhs := m.Operations; rhs != nil { + tmpContainer := make([]*Operation, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Operations = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Operations) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Operation) CloneVT() *Operation { + if m == nil { + return (*Operation)(nil) + } + r := new(Operation) + r.Type = m.Type + r.Ord = m.Ord + r.Key = m.Key + if rhs := m.Value; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Value = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Operation) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *ModuleOutput) EqualVT(that *ModuleOutput) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Data == nil && that.Data != nil { + return false + } else if this.Data != nil { + if that.Data == nil { + return false + } + if !this.Data.(interface { + EqualVT(isModuleOutput_Data) bool + }).EqualVT(that.Data) { + return false + } + } + if this.ModuleName != that.ModuleName { + return false + } + if len(this.Logs) != len(that.Logs) { + return false + } + for i, vx := range this.Logs { + vy := that.Logs[i] + if vx != vy { + return false + } + } + if this.DebugLogsTruncated != that.DebugLogsTruncated { + return false + } + if this.Cached != that.Cached { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ModuleOutput) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ModuleOutput) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ModuleOutput_MapOutput) EqualVT(thatIface isModuleOutput_Data) bool { + that, ok := thatIface.(*ModuleOutput_MapOutput) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.MapOutput, that.MapOutput; p != q { + if p == nil { + p = &anypb.Any{} + } + if q == nil { + q = &anypb.Any{} + } + if !(*anypb1.Any)(p).EqualVT((*anypb1.Any)(q)) { + return false + } + } + return true +} + +func (this *ModuleOutput_StoreDeltas) EqualVT(thatIface isModuleOutput_Data) bool { + that, ok := thatIface.(*ModuleOutput_StoreDeltas) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.StoreDeltas, that.StoreDeltas; p != q { + if p == nil { + p = &v1.StoreDeltas{} + } + if q == nil { + q = &v1.StoreDeltas{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Operations) EqualVT(that *Operations) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Operations) != len(that.Operations) { + return false + } + for i, vx := range this.Operations { + vy := that.Operations[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Operation{} + } + if q == nil { + q = &Operation{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Operations) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Operations) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Operation) EqualVT(that *Operation) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Type != that.Type { + return false + } + if this.Ord != that.Ord { + return false + } + if this.Key != that.Key { + return false + } + if string(this.Value) != string(that.Value) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Operation) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Operation) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *ModuleOutput) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ModuleOutput) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ModuleOutput) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Data.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if m.Cached { + i-- + if m.Cached { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if m.DebugLogsTruncated { + i-- + if m.DebugLogsTruncated { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if len(m.Logs) > 0 { + for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Logs[iNdEx]) + copy(dAtA[i:], m.Logs[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Logs[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(m.ModuleName) > 0 { + i -= len(m.ModuleName) + copy(dAtA[i:], m.ModuleName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ModuleName))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ModuleOutput_MapOutput) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ModuleOutput_MapOutput) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.MapOutput != nil { + size, err := (*anypb1.Any)(m.MapOutput).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *ModuleOutput_StoreDeltas) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ModuleOutput_StoreDeltas) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.StoreDeltas != nil { + size, err := m.StoreDeltas.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *Operations) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Operations) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Operations) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Operations) > 0 { + for iNdEx := len(m.Operations) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Operations[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *Operation) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Operation) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Operation) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x22 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x1a + } + if m.Ord != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Ord)) + i-- + dAtA[i] = 0x10 + } + if m.Type != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ModuleOutput) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ModuleName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if vtmsg, ok := m.Data.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + if len(m.Logs) > 0 { + for _, s := range m.Logs { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.DebugLogsTruncated { + n += 2 + } + if m.Cached { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *ModuleOutput_MapOutput) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MapOutput != nil { + l = (*anypb1.Any)(m.MapOutput).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ModuleOutput_StoreDeltas) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StoreDeltas != nil { + l = m.StoreDeltas.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Operations) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Operations) > 0 { + for _, e := range m.Operations { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *Operation) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Type != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Type)) + } + if m.Ord != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Ord)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ModuleOutput) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ModuleOutput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ModuleOutput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ModuleName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ModuleName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MapOutput", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*ModuleOutput_MapOutput); ok { + if err := (*anypb1.Any)(oneof.MapOutput).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &anypb.Any{} + if err := (*anypb1.Any)(v).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &ModuleOutput_MapOutput{MapOutput: v} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreDeltas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Data.(*ModuleOutput_StoreDeltas); ok { + if err := oneof.StoreDeltas.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &v1.StoreDeltas{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &ModuleOutput_StoreDeltas{StoreDeltas: v} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Logs = append(m.Logs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugLogsTruncated", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DebugLogsTruncated = bool(v != 0) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Cached", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Cached = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Operations) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Operations: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Operations: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Operations = append(m.Operations, &Operation{}) + if err := m.Operations[len(m.Operations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Operation) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Operation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Operation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= Operation_Type(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Ord", wireType) + } + m.Ord = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Ord |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) + if m.Value == nil { + m.Value = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/intern/v2/service_grpc.pb.go b/pb/sf/substreams/intern/v2/service_grpc.pb.go index 4c7f366a8..3557010df 100644 --- a/pb/sf/substreams/intern/v2/service_grpc.pb.go +++ b/pb/sf/substreams/intern/v2/service_grpc.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.6.0 +// - protoc-gen-go-grpc v1.5.1 // - protoc (unknown) // source: sf/substreams/intern/v2/service.proto @@ -71,7 +71,7 @@ type SubstreamsServer interface { type UnimplementedSubstreamsServer struct{} func (UnimplementedSubstreamsServer) ProcessRange(*ProcessRangeRequest, grpc.ServerStreamingServer[ProcessRangeResponse]) error { - return status.Error(codes.Unimplemented, "method ProcessRange not implemented") + return status.Errorf(codes.Unimplemented, "method ProcessRange not implemented") } func (UnimplementedSubstreamsServer) testEmbeddedByValue() {} @@ -83,7 +83,7 @@ type UnsafeSubstreamsServer interface { } func RegisterSubstreamsServer(s grpc.ServiceRegistrar, srv SubstreamsServer) { - // If the following call panics, it indicates UnimplementedSubstreamsServer was + // If the following call pancis, it indicates UnimplementedSubstreamsServer was // embedded by pointer and is nil. This will cause panics if an // unimplemented method is ever invoked, so we test this at initialization // time to prevent it from happening at runtime later due to I/O. diff --git a/pb/sf/substreams/intern/v2/service_vtproto.pb.go b/pb/sf/substreams/intern/v2/service_vtproto.pb.go new file mode 100644 index 000000000..00ee2e9aa --- /dev/null +++ b/pb/sf/substreams/intern/v2/service_vtproto.pb.go @@ -0,0 +1,3671 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/intern/v2/service.proto + +package pbssinternal + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + anypb1 "github.com/planetscale/vtprotobuf/types/known/anypb" + v1 "github.com/streamingfast/substreams/pb/sf/substreams/v1" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + io "io" +) + +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) +) + +func (m *ProcessRangeRequest) CloneVT() *ProcessRangeRequest { + if m == nil { + return (*ProcessRangeRequest)(nil) + } + r := new(ProcessRangeRequest) + r.StopBlockNum = m.StopBlockNum + r.OutputModule = m.OutputModule + r.Modules = m.Modules.CloneVT() + r.Stage = m.Stage + r.MeteringConfig = m.MeteringConfig + r.FirstStreamableBlock = m.FirstStreamableBlock + r.MergedBlocksStore = m.MergedBlocksStore + r.StateStore = m.StateStore + r.StateStoreDefaultTag = m.StateStoreDefaultTag + r.SegmentSize = m.SegmentSize + r.BlockType = m.BlockType + r.SegmentNumber = m.SegmentNumber + r.ProductionMode = m.ProductionMode + r.StreamOutput = m.StreamOutput + r.EthCallFallbackToLatestDuration = m.EthCallFallbackToLatestDuration + r.EthCallFallbackToNumberDuration = m.EthCallFallbackToNumberDuration + if rhs := m.WasmExtensionConfigs; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.WasmExtensionConfigs = tmpContainer + } + if rhs := m.FoundationalStoreEndpoints; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.FoundationalStoreEndpoints = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ProcessRangeRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ProcessRangeResponse) CloneVT() *ProcessRangeResponse { + if m == nil { + return (*ProcessRangeResponse)(nil) + } + r := new(ProcessRangeResponse) + if m.Type != nil { + r.Type = m.Type.(interface { + CloneVT() isProcessRangeResponse_Type + }).CloneVT() + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ProcessRangeResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ProcessRangeResponse_Failed) CloneVT() isProcessRangeResponse_Type { + if m == nil { + return (*ProcessRangeResponse_Failed)(nil) + } + r := new(ProcessRangeResponse_Failed) + r.Failed = m.Failed.CloneVT() + return r +} + +func (m *ProcessRangeResponse_Completed) CloneVT() isProcessRangeResponse_Type { + if m == nil { + return (*ProcessRangeResponse_Completed)(nil) + } + r := new(ProcessRangeResponse_Completed) + r.Completed = m.Completed.CloneVT() + return r +} + +func (m *ProcessRangeResponse_Update) CloneVT() isProcessRangeResponse_Type { + if m == nil { + return (*ProcessRangeResponse_Update)(nil) + } + r := new(ProcessRangeResponse_Update) + r.Update = m.Update.CloneVT() + return r +} + +func (m *ProcessRangeResponse_BlockScopedData) CloneVT() isProcessRangeResponse_Type { + if m == nil { + return (*ProcessRangeResponse_BlockScopedData)(nil) + } + r := new(ProcessRangeResponse_BlockScopedData) + r.BlockScopedData = m.BlockScopedData.CloneVT() + return r +} + +func (m *BlockScopedData) CloneVT() *BlockScopedData { + if m == nil { + return (*BlockScopedData)(nil) + } + r := new(BlockScopedData) + r.Output = (*anypb.Any)((*anypb1.Any)(m.Output).CloneVT()) + r.Clock = m.Clock.CloneVT() + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BlockScopedData) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Update) CloneVT() *Update { + if m == nil { + return (*Update)(nil) + } + r := new(Update) + r.DurationMs = m.DurationMs + r.ProgressBlocks = m.ProgressBlocks + r.TotalBytesRead = m.TotalBytesRead + r.TotalBytesWritten = m.TotalBytesWritten + if rhs := m.ModulesStats; rhs != nil { + tmpContainer := make([]*ModuleStats, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ModulesStats = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Update) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ModuleStats) CloneVT() *ModuleStats { + if m == nil { + return (*ModuleStats)(nil) + } + r := new(ModuleStats) + r.Name = m.Name + r.ProcessingTimeMs = m.ProcessingTimeMs + r.StoreOperationTimeMs = m.StoreOperationTimeMs + r.StoreReadCount = m.StoreReadCount + r.StoreWriteCount = m.StoreWriteCount + r.StoreDeleteprefixCount = m.StoreDeleteprefixCount + r.StoreSizeBytes = m.StoreSizeBytes + if rhs := m.ExternalCallMetrics; rhs != nil { + tmpContainer := make([]*ExternalCallMetric, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ExternalCallMetrics = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ModuleStats) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExternalCallMetric) CloneVT() *ExternalCallMetric { + if m == nil { + return (*ExternalCallMetric)(nil) + } + r := new(ExternalCallMetric) + r.Name = m.Name + r.Count = m.Count + r.TimeMs = m.TimeMs + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExternalCallMetric) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Completed) CloneVT() *Completed { + if m == nil { + return (*Completed)(nil) + } + r := new(Completed) + r.ProcessedBlocks = m.ProcessedBlocks + r.StreamingMode = m.StreamingMode + if rhs := m.AllProcessedRanges; rhs != nil { + tmpContainer := make([]*BlockRange, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.AllProcessedRanges = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Completed) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Failed) CloneVT() *Failed { + if m == nil { + return (*Failed)(nil) + } + r := new(Failed) + r.Reason = m.Reason + r.LogsTruncated = m.LogsTruncated + if rhs := m.Logs; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Logs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Failed) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BlockRange) CloneVT() *BlockRange { + if m == nil { + return (*BlockRange)(nil) + } + r := new(BlockRange) + r.StartBlock = m.StartBlock + r.EndBlock = m.EndBlock + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BlockRange) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *ProcessRangeRequest) EqualVT(that *ProcessRangeRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.StopBlockNum != that.StopBlockNum { + return false + } + if this.OutputModule != that.OutputModule { + return false + } + if !this.Modules.EqualVT(that.Modules) { + return false + } + if this.Stage != that.Stage { + return false + } + if this.MeteringConfig != that.MeteringConfig { + return false + } + if this.FirstStreamableBlock != that.FirstStreamableBlock { + return false + } + if len(this.WasmExtensionConfigs) != len(that.WasmExtensionConfigs) { + return false + } + for i, vx := range this.WasmExtensionConfigs { + vy, ok := that.WasmExtensionConfigs[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + if this.MergedBlocksStore != that.MergedBlocksStore { + return false + } + if this.StateStore != that.StateStore { + return false + } + if this.StateStoreDefaultTag != that.StateStoreDefaultTag { + return false + } + if this.SegmentSize != that.SegmentSize { + return false + } + if this.BlockType != that.BlockType { + return false + } + if this.SegmentNumber != that.SegmentNumber { + return false + } + if this.ProductionMode != that.ProductionMode { + return false + } + if this.StreamOutput != that.StreamOutput { + return false + } + if len(this.FoundationalStoreEndpoints) != len(that.FoundationalStoreEndpoints) { + return false + } + for i, vx := range this.FoundationalStoreEndpoints { + vy, ok := that.FoundationalStoreEndpoints[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + if this.EthCallFallbackToLatestDuration != that.EthCallFallbackToLatestDuration { + return false + } + if this.EthCallFallbackToNumberDuration != that.EthCallFallbackToNumberDuration { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ProcessRangeRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ProcessRangeRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ProcessRangeResponse) EqualVT(that *ProcessRangeResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Type == nil && that.Type != nil { + return false + } else if this.Type != nil { + if that.Type == nil { + return false + } + if !this.Type.(interface { + EqualVT(isProcessRangeResponse_Type) bool + }).EqualVT(that.Type) { + return false + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ProcessRangeResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ProcessRangeResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ProcessRangeResponse_Failed) EqualVT(thatIface isProcessRangeResponse_Type) bool { + that, ok := thatIface.(*ProcessRangeResponse_Failed) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Failed, that.Failed; p != q { + if p == nil { + p = &Failed{} + } + if q == nil { + q = &Failed{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *ProcessRangeResponse_Completed) EqualVT(thatIface isProcessRangeResponse_Type) bool { + that, ok := thatIface.(*ProcessRangeResponse_Completed) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Completed, that.Completed; p != q { + if p == nil { + p = &Completed{} + } + if q == nil { + q = &Completed{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *ProcessRangeResponse_Update) EqualVT(thatIface isProcessRangeResponse_Type) bool { + that, ok := thatIface.(*ProcessRangeResponse_Update) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Update, that.Update; p != q { + if p == nil { + p = &Update{} + } + if q == nil { + q = &Update{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *ProcessRangeResponse_BlockScopedData) EqualVT(thatIface isProcessRangeResponse_Type) bool { + that, ok := thatIface.(*ProcessRangeResponse_BlockScopedData) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.BlockScopedData, that.BlockScopedData; p != q { + if p == nil { + p = &BlockScopedData{} + } + if q == nil { + q = &BlockScopedData{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *BlockScopedData) EqualVT(that *BlockScopedData) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if !(*anypb1.Any)(this.Output).EqualVT((*anypb1.Any)(that.Output)) { + return false + } + if !this.Clock.EqualVT(that.Clock) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *BlockScopedData) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*BlockScopedData) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Update) EqualVT(that *Update) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.DurationMs != that.DurationMs { + return false + } + if this.ProgressBlocks != that.ProgressBlocks { + return false + } + if this.TotalBytesRead != that.TotalBytesRead { + return false + } + if this.TotalBytesWritten != that.TotalBytesWritten { + return false + } + if len(this.ModulesStats) != len(that.ModulesStats) { + return false + } + for i, vx := range this.ModulesStats { + vy := that.ModulesStats[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &ModuleStats{} + } + if q == nil { + q = &ModuleStats{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Update) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Update) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ModuleStats) EqualVT(that *ModuleStats) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Name != that.Name { + return false + } + if this.ProcessingTimeMs != that.ProcessingTimeMs { + return false + } + if this.StoreOperationTimeMs != that.StoreOperationTimeMs { + return false + } + if this.StoreReadCount != that.StoreReadCount { + return false + } + if len(this.ExternalCallMetrics) != len(that.ExternalCallMetrics) { + return false + } + for i, vx := range this.ExternalCallMetrics { + vy := that.ExternalCallMetrics[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &ExternalCallMetric{} + } + if q == nil { + q = &ExternalCallMetric{} + } + if !p.EqualVT(q) { + return false + } + } + } + if this.StoreWriteCount != that.StoreWriteCount { + return false + } + if this.StoreDeleteprefixCount != that.StoreDeleteprefixCount { + return false + } + if this.StoreSizeBytes != that.StoreSizeBytes { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ModuleStats) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ModuleStats) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ExternalCallMetric) EqualVT(that *ExternalCallMetric) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Name != that.Name { + return false + } + if this.Count != that.Count { + return false + } + if this.TimeMs != that.TimeMs { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ExternalCallMetric) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ExternalCallMetric) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Completed) EqualVT(that *Completed) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.AllProcessedRanges) != len(that.AllProcessedRanges) { + return false + } + for i, vx := range this.AllProcessedRanges { + vy := that.AllProcessedRanges[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &BlockRange{} + } + if q == nil { + q = &BlockRange{} + } + if !p.EqualVT(q) { + return false + } + } + } + if this.ProcessedBlocks != that.ProcessedBlocks { + return false + } + if this.StreamingMode != that.StreamingMode { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Completed) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Completed) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Failed) EqualVT(that *Failed) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Reason != that.Reason { + return false + } + if len(this.Logs) != len(that.Logs) { + return false + } + for i, vx := range this.Logs { + vy := that.Logs[i] + if vx != vy { + return false + } + } + if this.LogsTruncated != that.LogsTruncated { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Failed) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Failed) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *BlockRange) EqualVT(that *BlockRange) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.StartBlock != that.StartBlock { + return false + } + if this.EndBlock != that.EndBlock { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *BlockRange) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*BlockRange) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *ProcessRangeRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProcessRangeRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProcessRangeRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.EthCallFallbackToNumberDuration != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EthCallFallbackToNumberDuration)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa0 + } + if m.EthCallFallbackToLatestDuration != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EthCallFallbackToLatestDuration)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x98 + } + if len(m.FoundationalStoreEndpoints) > 0 { + for k := range m.FoundationalStoreEndpoints { + v := m.FoundationalStoreEndpoints[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + } + if m.StreamOutput { + i-- + if m.StreamOutput { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x88 + } + if m.ProductionMode { + i-- + if m.ProductionMode { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x80 + } + if m.SegmentNumber != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SegmentNumber)) + i-- + dAtA[i] = 0x78 + } + if len(m.BlockType) > 0 { + i -= len(m.BlockType) + copy(dAtA[i:], m.BlockType) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockType))) + i-- + dAtA[i] = 0x72 + } + if m.SegmentSize != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SegmentSize)) + i-- + dAtA[i] = 0x68 + } + if len(m.StateStoreDefaultTag) > 0 { + i -= len(m.StateStoreDefaultTag) + copy(dAtA[i:], m.StateStoreDefaultTag) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateStoreDefaultTag))) + i-- + dAtA[i] = 0x62 + } + if len(m.StateStore) > 0 { + i -= len(m.StateStore) + copy(dAtA[i:], m.StateStore) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StateStore))) + i-- + dAtA[i] = 0x5a + } + if len(m.MergedBlocksStore) > 0 { + i -= len(m.MergedBlocksStore) + copy(dAtA[i:], m.MergedBlocksStore) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MergedBlocksStore))) + i-- + dAtA[i] = 0x52 + } + if len(m.WasmExtensionConfigs) > 0 { + for k := range m.WasmExtensionConfigs { + v := m.WasmExtensionConfigs[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x4a + } + } + if m.FirstStreamableBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FirstStreamableBlock)) + i-- + dAtA[i] = 0x38 + } + if len(m.MeteringConfig) > 0 { + i -= len(m.MeteringConfig) + copy(dAtA[i:], m.MeteringConfig) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MeteringConfig))) + i-- + dAtA[i] = 0x32 + } + if m.Stage != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Stage)) + i-- + dAtA[i] = 0x28 + } + if m.Modules != nil { + size, err := m.Modules.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.OutputModule) > 0 { + i -= len(m.OutputModule) + copy(dAtA[i:], m.OutputModule) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OutputModule))) + i-- + dAtA[i] = 0x1a + } + if m.StopBlockNum != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StopBlockNum)) + i-- + dAtA[i] = 0x10 + } + return len(dAtA) - i, nil +} + +func (m *ProcessRangeResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProcessRangeResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProcessRangeResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Type.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + return len(dAtA) - i, nil +} + +func (m *ProcessRangeResponse_Failed) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProcessRangeResponse_Failed) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Failed != nil { + size, err := m.Failed.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *ProcessRangeResponse_Completed) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProcessRangeResponse_Completed) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Completed != nil { + size, err := m.Completed.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *ProcessRangeResponse_Update) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProcessRangeResponse_Update) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Update != nil { + size, err := m.Update.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + return len(dAtA) - i, nil +} +func (m *ProcessRangeResponse_BlockScopedData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProcessRangeResponse_BlockScopedData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BlockScopedData != nil { + size, err := m.BlockScopedData.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + return len(dAtA) - i, nil +} +func (m *BlockScopedData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockScopedData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlockScopedData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Clock != nil { + size, err := m.Clock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Output != nil { + size, err := (*anypb1.Any)(m.Output).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Update) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Update) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Update) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ModulesStats) > 0 { + for iNdEx := len(m.ModulesStats) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ModulesStats[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if m.TotalBytesWritten != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalBytesWritten)) + i-- + dAtA[i] = 0x20 + } + if m.TotalBytesRead != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalBytesRead)) + i-- + dAtA[i] = 0x18 + } + if m.ProgressBlocks != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProgressBlocks)) + i-- + dAtA[i] = 0x10 + } + if m.DurationMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DurationMs)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ModuleStats) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ModuleStats) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ModuleStats) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.StoreSizeBytes != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StoreSizeBytes)) + i-- + dAtA[i] = 0x60 + } + if m.StoreDeleteprefixCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StoreDeleteprefixCount)) + i-- + dAtA[i] = 0x58 + } + if m.StoreWriteCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StoreWriteCount)) + i-- + dAtA[i] = 0x50 + } + if len(m.ExternalCallMetrics) > 0 { + for iNdEx := len(m.ExternalCallMetrics) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ExternalCallMetrics[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if m.StoreReadCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StoreReadCount)) + i-- + dAtA[i] = 0x20 + } + if m.StoreOperationTimeMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StoreOperationTimeMs)) + i-- + dAtA[i] = 0x18 + } + if m.ProcessingTimeMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProcessingTimeMs)) + i-- + dAtA[i] = 0x10 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExternalCallMetric) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExternalCallMetric) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExternalCallMetric) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.TimeMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TimeMs)) + i-- + dAtA[i] = 0x18 + } + if m.Count != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Count)) + i-- + dAtA[i] = 0x10 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Completed) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Completed) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Completed) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.StreamingMode { + i-- + if m.StreamingMode { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.ProcessedBlocks != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProcessedBlocks)) + i-- + dAtA[i] = 0x18 + } + if len(m.AllProcessedRanges) > 0 { + for iNdEx := len(m.AllProcessedRanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.AllProcessedRanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *Failed) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Failed) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Failed) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.LogsTruncated { + i-- + if m.LogsTruncated { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Logs) > 0 { + for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Logs[iNdEx]) + copy(dAtA[i:], m.Logs[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Logs[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlockRange) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockRange) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlockRange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.EndBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EndBlock)) + i-- + dAtA[i] = 0x18 + } + if m.StartBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StartBlock)) + i-- + dAtA[i] = 0x10 + } + return len(dAtA) - i, nil +} + +func (m *ProcessRangeRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StopBlockNum != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StopBlockNum)) + } + l = len(m.OutputModule) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Modules != nil { + l = m.Modules.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Stage != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Stage)) + } + l = len(m.MeteringConfig) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FirstStreamableBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.FirstStreamableBlock)) + } + if len(m.WasmExtensionConfigs) > 0 { + for k, v := range m.WasmExtensionConfigs { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + l = len(m.MergedBlocksStore) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateStore) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.StateStoreDefaultTag) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SegmentSize != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.SegmentSize)) + } + l = len(m.BlockType) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SegmentNumber != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.SegmentNumber)) + } + if m.ProductionMode { + n += 3 + } + if m.StreamOutput { + n += 3 + } + if len(m.FoundationalStoreEndpoints) > 0 { + for k, v := range m.FoundationalStoreEndpoints { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 2 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + if m.EthCallFallbackToLatestDuration != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.EthCallFallbackToLatestDuration)) + } + if m.EthCallFallbackToNumberDuration != 0 { + n += 2 + protohelpers.SizeOfVarint(uint64(m.EthCallFallbackToNumberDuration)) + } + n += len(m.unknownFields) + return n +} + +func (m *ProcessRangeResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if vtmsg, ok := m.Type.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *ProcessRangeResponse_Failed) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Failed != nil { + l = m.Failed.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ProcessRangeResponse_Completed) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Completed != nil { + l = m.Completed.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ProcessRangeResponse_Update) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Update != nil { + l = m.Update.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *ProcessRangeResponse_BlockScopedData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockScopedData != nil { + l = m.BlockScopedData.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *BlockScopedData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Output != nil { + l = (*anypb1.Any)(m.Output).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Clock != nil { + l = m.Clock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Update) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DurationMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.DurationMs)) + } + if m.ProgressBlocks != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProgressBlocks)) + } + if m.TotalBytesRead != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalBytesRead)) + } + if m.TotalBytesWritten != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalBytesWritten)) + } + if len(m.ModulesStats) > 0 { + for _, e := range m.ModulesStats { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ModuleStats) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProcessingTimeMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProcessingTimeMs)) + } + if m.StoreOperationTimeMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StoreOperationTimeMs)) + } + if m.StoreReadCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StoreReadCount)) + } + if len(m.ExternalCallMetrics) > 0 { + for _, e := range m.ExternalCallMetrics { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.StoreWriteCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StoreWriteCount)) + } + if m.StoreDeleteprefixCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StoreDeleteprefixCount)) + } + if m.StoreSizeBytes != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StoreSizeBytes)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExternalCallMetric) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Count != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Count)) + } + if m.TimeMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TimeMs)) + } + n += len(m.unknownFields) + return n +} + +func (m *Completed) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AllProcessedRanges) > 0 { + for _, e := range m.AllProcessedRanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ProcessedBlocks != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProcessedBlocks)) + } + if m.StreamingMode { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *Failed) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Reason) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Logs) > 0 { + for _, s := range m.Logs { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.LogsTruncated { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *BlockRange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StartBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StartBlock)) + } + if m.EndBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.EndBlock)) + } + n += len(m.unknownFields) + return n +} + +func (m *ProcessRangeRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ProcessRangeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProcessRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StopBlockNum", wireType) + } + m.StopBlockNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StopBlockNum |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputModule", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputModule = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Modules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Modules == nil { + m.Modules = &v1.Modules{} + } + if err := m.Modules.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Stage", wireType) + } + m.Stage = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Stage |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MeteringConfig", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MeteringConfig = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FirstStreamableBlock", wireType) + } + m.FirstStreamableBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FirstStreamableBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WasmExtensionConfigs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WasmExtensionConfigs == nil { + m.WasmExtensionConfigs = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.WasmExtensionConfigs[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MergedBlocksStore", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MergedBlocksStore = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateStore", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateStore = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateStoreDefaultTag", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateStoreDefaultTag = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SegmentSize", wireType) + } + m.SegmentSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SegmentSize |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SegmentNumber", wireType) + } + m.SegmentNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SegmentNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProductionMode", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ProductionMode = bool(v != 0) + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StreamOutput", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.StreamOutput = bool(v != 0) + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FoundationalStoreEndpoints", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FoundationalStoreEndpoints == nil { + m.FoundationalStoreEndpoints = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.FoundationalStoreEndpoints[mapkey] = mapvalue + iNdEx = postIndex + case 19: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EthCallFallbackToLatestDuration", wireType) + } + m.EthCallFallbackToLatestDuration = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EthCallFallbackToLatestDuration |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 20: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EthCallFallbackToNumberDuration", wireType) + } + m.EthCallFallbackToNumberDuration = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EthCallFallbackToNumberDuration |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProcessRangeResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ProcessRangeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProcessRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Type.(*ProcessRangeResponse_Failed); ok { + if err := oneof.Failed.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Failed{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Type = &ProcessRangeResponse_Failed{Failed: v} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Completed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Type.(*ProcessRangeResponse_Completed); ok { + if err := oneof.Completed.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Completed{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Type = &ProcessRangeResponse_Completed{Completed: v} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Type.(*ProcessRangeResponse_Update); ok { + if err := oneof.Update.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Update{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Type = &ProcessRangeResponse_Update{Update: v} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockScopedData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Type.(*ProcessRangeResponse_BlockScopedData); ok { + if err := oneof.BlockScopedData.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &BlockScopedData{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Type = &ProcessRangeResponse_BlockScopedData{BlockScopedData: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlockScopedData) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: BlockScopedData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockScopedData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output == nil { + m.Output = &anypb.Any{} + } + if err := (*anypb1.Any)(m.Output).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Clock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Clock == nil { + m.Clock = &v1.Clock{} + } + if err := m.Clock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Update) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Update: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationMs", wireType) + } + m.DurationMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DurationMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressBlocks", wireType) + } + m.ProgressBlocks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProgressBlocks |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytesRead", wireType) + } + m.TotalBytesRead = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalBytesRead |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytesWritten", wireType) + } + m.TotalBytesWritten = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalBytesWritten |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ModulesStats", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ModulesStats = append(m.ModulesStats, &ModuleStats{}) + if err := m.ModulesStats[len(m.ModulesStats)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ModuleStats) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ModuleStats: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ModuleStats: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProcessingTimeMs", wireType) + } + m.ProcessingTimeMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProcessingTimeMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreOperationTimeMs", wireType) + } + m.StoreOperationTimeMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StoreOperationTimeMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreReadCount", wireType) + } + m.StoreReadCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StoreReadCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExternalCallMetrics", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExternalCallMetrics = append(m.ExternalCallMetrics, &ExternalCallMetric{}) + if err := m.ExternalCallMetrics[len(m.ExternalCallMetrics)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreWriteCount", wireType) + } + m.StoreWriteCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StoreWriteCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreDeleteprefixCount", wireType) + } + m.StoreDeleteprefixCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StoreDeleteprefixCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreSizeBytes", wireType) + } + m.StoreSizeBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StoreSizeBytes |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExternalCallMetric) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ExternalCallMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalCallMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + m.Count = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Count |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TimeMs", wireType) + } + m.TimeMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TimeMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Completed) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Completed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Completed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllProcessedRanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AllProcessedRanges = append(m.AllProcessedRanges, &BlockRange{}) + if err := m.AllProcessedRanges[len(m.AllProcessedRanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProcessedBlocks", wireType) + } + m.ProcessedBlocks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProcessedBlocks |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StreamingMode", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.StreamingMode = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Failed) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Failed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Failed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Logs = append(m.Logs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsTruncated", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LogsTruncated = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlockRange) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: BlockRange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockRange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlock", wireType) + } + m.StartBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType) + } + m.EndBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/options_vtproto.pb.go b/pb/sf/substreams/options_vtproto.pb.go new file mode 100644 index 000000000..648044543 --- /dev/null +++ b/pb/sf/substreams/options_vtproto.pb.go @@ -0,0 +1,221 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/options.proto + +package pbsubstreams + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" +) + +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) +) + +func (m *FieldOptions) CloneVT() *FieldOptions { + if m == nil { + return (*FieldOptions)(nil) + } + r := new(FieldOptions) + r.LoadFromFile = m.LoadFromFile + r.ZipFromFolder = m.ZipFromFolder + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *FieldOptions) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *FieldOptions) EqualVT(that *FieldOptions) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.LoadFromFile != that.LoadFromFile { + return false + } + if this.ZipFromFolder != that.ZipFromFolder { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *FieldOptions) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*FieldOptions) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *FieldOptions) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FieldOptions) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *FieldOptions) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ZipFromFolder { + i-- + if m.ZipFromFolder { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.LoadFromFile { + i-- + if m.LoadFromFile { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *FieldOptions) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LoadFromFile { + n += 2 + } + if m.ZipFromFolder { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *FieldOptions) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: FieldOptions: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FieldOptions: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LoadFromFile", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LoadFromFile = bool(v != 0) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ZipFromFolder", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ZipFromFolder = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/rpc/v2/service.pb.go b/pb/sf/substreams/rpc/v2/service.pb.go index 7ea3f3d48..6412a8bde 100644 --- a/pb/sf/substreams/rpc/v2/service.pb.go +++ b/pb/sf/substreams/rpc/v2/service.pb.go @@ -7,15 +7,14 @@ package pbsubstreamsrpcv2 import ( - reflect "reflect" - sync "sync" - unsafe "unsafe" - v2 "github.com/streamingfast/pbgo/sf/firehose/v2" v1 "github.com/streamingfast/substreams/pb/sf/substreams/v1" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" anypb "google.golang.org/protobuf/types/known/anypb" + reflect "reflect" + sync "sync" + unsafe "unsafe" ) const ( @@ -74,7 +73,7 @@ func (x StoreDelta_Operation) Number() protoreflect.EnumNumber { // Deprecated: Use StoreDelta_Operation.Descriptor instead. func (StoreDelta_Operation) EnumDescriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{17, 0} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{18, 0} } type Request struct { @@ -258,6 +257,7 @@ type Response struct { // *Response_BlockScopedData // *Response_BlockUndoSignal // *Response_FatalError + // *Response_BlockScopedDatas // *Response_DebugSnapshotData // *Response_DebugSnapshotComplete Message isResponse_Message `protobuf_oneof:"message"` @@ -347,6 +347,15 @@ func (x *Response) GetFatalError() *Error { return nil } +func (x *Response) GetBlockScopedDatas() *BlockScopedDatas { + if x != nil { + if x, ok := x.Message.(*Response_BlockScopedDatas); ok { + return x.BlockScopedDatas + } + } + return nil +} + func (x *Response) GetDebugSnapshotData() *InitialSnapshotData { if x != nil { if x, ok := x.Message.(*Response_DebugSnapshotData); ok { @@ -389,6 +398,10 @@ type Response_FatalError struct { FatalError *Error `protobuf:"bytes,5,opt,name=fatal_error,json=fatalError,proto3,oneof"` } +type Response_BlockScopedDatas struct { + BlockScopedDatas *BlockScopedDatas `protobuf:"bytes,6,opt,name=block_scoped_datas,json=blockScopedDatas,proto3,oneof"` +} + type Response_DebugSnapshotData struct { // Available only in developer mode, and only if `debug_initial_store_snapshot_for_modules` is set. DebugSnapshotData *InitialSnapshotData `protobuf:"bytes,10,opt,name=debug_snapshot_data,json=debugSnapshotData,proto3,oneof"` @@ -409,6 +422,8 @@ func (*Response_BlockUndoSignal) isResponse_Message() {} func (*Response_FatalError) isResponse_Message() {} +func (*Response_BlockScopedDatas) isResponse_Message() {} + func (*Response_DebugSnapshotData) isResponse_Message() {} func (*Response_DebugSnapshotComplete) isResponse_Message() {} @@ -468,6 +483,50 @@ func (x *BlockUndoSignal) GetLastValidCursor() string { return "" } +type BlockScopedDatas struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items []*BlockScopedData `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BlockScopedDatas) Reset() { + *x = BlockScopedDatas{} + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BlockScopedDatas) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlockScopedDatas) ProtoMessage() {} + +func (x *BlockScopedDatas) ProtoReflect() protoreflect.Message { + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlockScopedDatas.ProtoReflect.Descriptor instead. +func (*BlockScopedDatas) Descriptor() ([]byte, []int) { + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{3} +} + +func (x *BlockScopedDatas) GetItems() []*BlockScopedData { + if x != nil { + return x.Items + } + return nil +} + type BlockScopedData struct { state protoimpl.MessageState `protogen:"open.v1"` Output *MapModuleOutput `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` @@ -493,7 +552,7 @@ type BlockScopedData struct { func (x *BlockScopedData) Reset() { *x = BlockScopedData{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[3] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -505,7 +564,7 @@ func (x *BlockScopedData) String() string { func (*BlockScopedData) ProtoMessage() {} func (x *BlockScopedData) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[3] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[4] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -518,7 +577,7 @@ func (x *BlockScopedData) ProtoReflect() protoreflect.Message { // Deprecated: Use BlockScopedData.ProtoReflect.Descriptor instead. func (*BlockScopedData) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{3} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{4} } func (x *BlockScopedData) GetOutput() *MapModuleOutput { @@ -617,7 +676,7 @@ type SessionInit struct { func (x *SessionInit) Reset() { *x = SessionInit{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[4] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[5] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -629,7 +688,7 @@ func (x *SessionInit) String() string { func (*SessionInit) ProtoMessage() {} func (x *SessionInit) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[4] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[5] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -642,7 +701,7 @@ func (x *SessionInit) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionInit.ProtoReflect.Descriptor instead. func (*SessionInit) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{4} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{5} } func (x *SessionInit) GetTraceId() string { @@ -724,7 +783,7 @@ type InitialSnapshotComplete struct { func (x *InitialSnapshotComplete) Reset() { *x = InitialSnapshotComplete{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[5] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -736,7 +795,7 @@ func (x *InitialSnapshotComplete) String() string { func (*InitialSnapshotComplete) ProtoMessage() {} func (x *InitialSnapshotComplete) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[5] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[6] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -749,7 +808,7 @@ func (x *InitialSnapshotComplete) ProtoReflect() protoreflect.Message { // Deprecated: Use InitialSnapshotComplete.ProtoReflect.Descriptor instead. func (*InitialSnapshotComplete) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{5} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{6} } func (x *InitialSnapshotComplete) GetCursor() string { @@ -771,7 +830,7 @@ type InitialSnapshotData struct { func (x *InitialSnapshotData) Reset() { *x = InitialSnapshotData{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[6] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -783,7 +842,7 @@ func (x *InitialSnapshotData) String() string { func (*InitialSnapshotData) ProtoMessage() {} func (x *InitialSnapshotData) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[6] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[7] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -796,7 +855,7 @@ func (x *InitialSnapshotData) ProtoReflect() protoreflect.Message { // Deprecated: Use InitialSnapshotData.ProtoReflect.Descriptor instead. func (*InitialSnapshotData) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{6} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{7} } func (x *InitialSnapshotData) GetModuleName() string { @@ -839,7 +898,7 @@ type MapModuleOutput struct { func (x *MapModuleOutput) Reset() { *x = MapModuleOutput{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[7] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -851,7 +910,7 @@ func (x *MapModuleOutput) String() string { func (*MapModuleOutput) ProtoMessage() {} func (x *MapModuleOutput) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[7] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[8] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -864,7 +923,7 @@ func (x *MapModuleOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use MapModuleOutput.ProtoReflect.Descriptor instead. func (*MapModuleOutput) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{7} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{8} } func (x *MapModuleOutput) GetName() string { @@ -903,7 +962,7 @@ type StoreModuleOutput struct { func (x *StoreModuleOutput) Reset() { *x = StoreModuleOutput{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[8] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -915,7 +974,7 @@ func (x *StoreModuleOutput) String() string { func (*StoreModuleOutput) ProtoMessage() {} func (x *StoreModuleOutput) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[8] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[9] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -928,7 +987,7 @@ func (x *StoreModuleOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use StoreModuleOutput.ProtoReflect.Descriptor instead. func (*StoreModuleOutput) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{8} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{9} } func (x *StoreModuleOutput) GetName() string { @@ -965,7 +1024,7 @@ type OutputDebugInfo struct { func (x *OutputDebugInfo) Reset() { *x = OutputDebugInfo{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[9] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -977,7 +1036,7 @@ func (x *OutputDebugInfo) String() string { func (*OutputDebugInfo) ProtoMessage() {} func (x *OutputDebugInfo) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[9] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[10] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -990,7 +1049,7 @@ func (x *OutputDebugInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use OutputDebugInfo.ProtoReflect.Descriptor instead. func (*OutputDebugInfo) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{9} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{10} } func (x *OutputDebugInfo) GetLogs() []string { @@ -1031,7 +1090,7 @@ type ModulesProgress struct { func (x *ModulesProgress) Reset() { *x = ModulesProgress{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[10] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1043,7 +1102,7 @@ func (x *ModulesProgress) String() string { func (*ModulesProgress) ProtoMessage() {} func (x *ModulesProgress) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[10] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[11] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1056,7 +1115,7 @@ func (x *ModulesProgress) ProtoReflect() protoreflect.Message { // Deprecated: Use ModulesProgress.ProtoReflect.Descriptor instead. func (*ModulesProgress) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{10} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{11} } func (x *ModulesProgress) GetRunningJobs() []*Job { @@ -1104,7 +1163,7 @@ type ProcessedBytes struct { func (x *ProcessedBytes) Reset() { *x = ProcessedBytes{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[11] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1116,7 +1175,7 @@ func (x *ProcessedBytes) String() string { func (*ProcessedBytes) ProtoMessage() {} func (x *ProcessedBytes) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[11] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[12] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1129,7 +1188,7 @@ func (x *ProcessedBytes) ProtoReflect() protoreflect.Message { // Deprecated: Use ProcessedBytes.ProtoReflect.Descriptor instead. func (*ProcessedBytes) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{11} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{12} } func (x *ProcessedBytes) GetTotalBytesRead() uint64 { @@ -1160,7 +1219,7 @@ type Error struct { func (x *Error) Reset() { *x = Error{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[12] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1172,7 +1231,7 @@ func (x *Error) String() string { func (*Error) ProtoMessage() {} func (x *Error) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[12] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[13] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1185,7 +1244,7 @@ func (x *Error) ProtoReflect() protoreflect.Message { // Deprecated: Use Error.ProtoReflect.Descriptor instead. func (*Error) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{12} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{13} } func (x *Error) GetModule() string { @@ -1229,7 +1288,7 @@ type Job struct { func (x *Job) Reset() { *x = Job{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[13] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1241,7 +1300,7 @@ func (x *Job) String() string { func (*Job) ProtoMessage() {} func (x *Job) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[13] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1254,7 +1313,7 @@ func (x *Job) ProtoReflect() protoreflect.Message { // Deprecated: Use Job.ProtoReflect.Descriptor instead. func (*Job) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{13} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{14} } func (x *Job) GetStage() uint32 { @@ -1302,7 +1361,7 @@ type Stage struct { func (x *Stage) Reset() { *x = Stage{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[14] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1314,7 +1373,7 @@ func (x *Stage) String() string { func (*Stage) ProtoMessage() {} func (x *Stage) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[14] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1327,7 +1386,7 @@ func (x *Stage) ProtoReflect() protoreflect.Message { // Deprecated: Use Stage.ProtoReflect.Descriptor instead. func (*Stage) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{14} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{15} } func (x *Stage) GetModules() []string { @@ -1379,7 +1438,7 @@ type ModuleStats struct { func (x *ModuleStats) Reset() { *x = ModuleStats{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[15] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1391,7 +1450,7 @@ func (x *ModuleStats) String() string { func (*ModuleStats) ProtoMessage() {} func (x *ModuleStats) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[15] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1404,7 +1463,7 @@ func (x *ModuleStats) ProtoReflect() protoreflect.Message { // Deprecated: Use ModuleStats.ProtoReflect.Descriptor instead. func (*ModuleStats) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{15} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{16} } func (x *ModuleStats) GetName() string { @@ -1502,7 +1561,7 @@ type ExternalCallMetric struct { func (x *ExternalCallMetric) Reset() { *x = ExternalCallMetric{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[16] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1514,7 +1573,7 @@ func (x *ExternalCallMetric) String() string { func (*ExternalCallMetric) ProtoMessage() {} func (x *ExternalCallMetric) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[16] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1527,7 +1586,7 @@ func (x *ExternalCallMetric) ProtoReflect() protoreflect.Message { // Deprecated: Use ExternalCallMetric.ProtoReflect.Descriptor instead. func (*ExternalCallMetric) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{16} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{17} } func (x *ExternalCallMetric) GetName() string { @@ -1564,7 +1623,7 @@ type StoreDelta struct { func (x *StoreDelta) Reset() { *x = StoreDelta{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[17] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1576,7 +1635,7 @@ func (x *StoreDelta) String() string { func (*StoreDelta) ProtoMessage() {} func (x *StoreDelta) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[17] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1589,7 +1648,7 @@ func (x *StoreDelta) ProtoReflect() protoreflect.Message { // Deprecated: Use StoreDelta.ProtoReflect.Descriptor instead. func (*StoreDelta) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{17} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{18} } func (x *StoreDelta) GetOperation() StoreDelta_Operation { @@ -1637,7 +1696,7 @@ type BlockRange struct { func (x *BlockRange) Reset() { *x = BlockRange{} - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[18] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1649,7 +1708,7 @@ func (x *BlockRange) String() string { func (*BlockRange) ProtoMessage() {} func (x *BlockRange) ProtoReflect() protoreflect.Message { - mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[18] + mi := &file_sf_substreams_rpc_v2_service_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1662,7 +1721,7 @@ func (x *BlockRange) ProtoReflect() protoreflect.Message { // Deprecated: Use BlockRange.ProtoReflect.Descriptor instead. func (*BlockRange) Descriptor() ([]byte, []int) { - return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{18} + return file_sf_substreams_rpc_v2_service_proto_rawDescGZIP(), []int{19} } func (x *BlockRange) GetStartBlock() uint64 { @@ -1698,21 +1757,24 @@ const file_sf_substreams_rpc_v2_service_proto_rawDesc = "" + "\x16limit_processed_blocks\x18\f \x01(\x04R\x14limitProcessedBlocks\x12,\n" + "\x12dev_output_modules\x18\r \x03(\tR\x10devOutputModules\x12A\n" + "\x1dprogress_messages_interval_ms\x18\x0e \x01(\x04R\x1aprogressMessagesIntervalMs\x12%\n" + - "\x0epartial_blocks\x18\x10 \x01(\bR\rpartialBlocksJ\x04\b\x0f\x10\x10\"\xc9\x04\n" + + "\x0epartial_blocks\x18\x10 \x01(\bR\rpartialBlocksJ\x04\b\x0f\x10\x10\"\xa1\x05\n" + "\bResponse\x12=\n" + "\asession\x18\x01 \x01(\v2!.sf.substreams.rpc.v2.SessionInitH\x00R\asession\x12C\n" + "\bprogress\x18\x02 \x01(\v2%.sf.substreams.rpc.v2.ModulesProgressH\x00R\bprogress\x12S\n" + "\x11block_scoped_data\x18\x03 \x01(\v2%.sf.substreams.rpc.v2.BlockScopedDataH\x00R\x0fblockScopedData\x12S\n" + "\x11block_undo_signal\x18\x04 \x01(\v2%.sf.substreams.rpc.v2.BlockUndoSignalH\x00R\x0fblockUndoSignal\x12>\n" + "\vfatal_error\x18\x05 \x01(\v2\x1b.sf.substreams.rpc.v2.ErrorH\x00R\n" + - "fatalError\x12[\n" + + "fatalError\x12V\n" + + "\x12block_scoped_datas\x18\x06 \x01(\v2&.sf.substreams.rpc.v2.BlockScopedDatasH\x00R\x10blockScopedDatas\x12[\n" + "\x13debug_snapshot_data\x18\n" + " \x01(\v2).sf.substreams.rpc.v2.InitialSnapshotDataH\x00R\x11debugSnapshotData\x12g\n" + "\x17debug_snapshot_complete\x18\v \x01(\v2-.sf.substreams.rpc.v2.InitialSnapshotCompleteH\x00R\x15debugSnapshotCompleteB\t\n" + "\amessage\"\x83\x01\n" + "\x0fBlockUndoSignal\x12D\n" + "\x10last_valid_block\x18\x01 \x01(\v2\x1a.sf.substreams.v1.BlockRefR\x0elastValidBlock\x12*\n" + - "\x11last_valid_cursor\x18\x02 \x01(\tR\x0flastValidCursor\"\xaf\x04\n" + + "\x11last_valid_cursor\x18\x02 \x01(\tR\x0flastValidCursor\"O\n" + + "\x10BlockScopedDatas\x12;\n" + + "\x05items\x18\x01 \x03(\v2%.sf.substreams.rpc.v2.BlockScopedDataR\x05items\"\xaf\x04\n" + "\x0fBlockScopedData\x12=\n" + "\x06output\x18\x01 \x01(\v2%.sf.substreams.rpc.v2.MapModuleOutputR\x06output\x12-\n" + "\x05clock\x18\x02 \x01(\v2\x17.sf.substreams.v1.ClockR\x05clock\x12\x16\n" + @@ -1849,70 +1911,73 @@ func file_sf_substreams_rpc_v2_service_proto_rawDescGZIP() []byte { } var file_sf_substreams_rpc_v2_service_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_sf_substreams_rpc_v2_service_proto_msgTypes = make([]protoimpl.MessageInfo, 19) +var file_sf_substreams_rpc_v2_service_proto_msgTypes = make([]protoimpl.MessageInfo, 20) var file_sf_substreams_rpc_v2_service_proto_goTypes = []any{ (StoreDelta_Operation)(0), // 0: sf.substreams.rpc.v2.StoreDelta.Operation (*Request)(nil), // 1: sf.substreams.rpc.v2.Request (*Response)(nil), // 2: sf.substreams.rpc.v2.Response (*BlockUndoSignal)(nil), // 3: sf.substreams.rpc.v2.BlockUndoSignal - (*BlockScopedData)(nil), // 4: sf.substreams.rpc.v2.BlockScopedData - (*SessionInit)(nil), // 5: sf.substreams.rpc.v2.SessionInit - (*InitialSnapshotComplete)(nil), // 6: sf.substreams.rpc.v2.InitialSnapshotComplete - (*InitialSnapshotData)(nil), // 7: sf.substreams.rpc.v2.InitialSnapshotData - (*MapModuleOutput)(nil), // 8: sf.substreams.rpc.v2.MapModuleOutput - (*StoreModuleOutput)(nil), // 9: sf.substreams.rpc.v2.StoreModuleOutput - (*OutputDebugInfo)(nil), // 10: sf.substreams.rpc.v2.OutputDebugInfo - (*ModulesProgress)(nil), // 11: sf.substreams.rpc.v2.ModulesProgress - (*ProcessedBytes)(nil), // 12: sf.substreams.rpc.v2.ProcessedBytes - (*Error)(nil), // 13: sf.substreams.rpc.v2.Error - (*Job)(nil), // 14: sf.substreams.rpc.v2.Job - (*Stage)(nil), // 15: sf.substreams.rpc.v2.Stage - (*ModuleStats)(nil), // 16: sf.substreams.rpc.v2.ModuleStats - (*ExternalCallMetric)(nil), // 17: sf.substreams.rpc.v2.ExternalCallMetric - (*StoreDelta)(nil), // 18: sf.substreams.rpc.v2.StoreDelta - (*BlockRange)(nil), // 19: sf.substreams.rpc.v2.BlockRange - (*v1.Modules)(nil), // 20: sf.substreams.v1.Modules - (*v1.BlockRef)(nil), // 21: sf.substreams.v1.BlockRef - (*v1.Clock)(nil), // 22: sf.substreams.v1.Clock - (*anypb.Any)(nil), // 23: google.protobuf.Any - (*v2.InfoRequest)(nil), // 24: sf.firehose.v2.InfoRequest - (*v2.InfoResponse)(nil), // 25: sf.firehose.v2.InfoResponse + (*BlockScopedDatas)(nil), // 4: sf.substreams.rpc.v2.BlockScopedDatas + (*BlockScopedData)(nil), // 5: sf.substreams.rpc.v2.BlockScopedData + (*SessionInit)(nil), // 6: sf.substreams.rpc.v2.SessionInit + (*InitialSnapshotComplete)(nil), // 7: sf.substreams.rpc.v2.InitialSnapshotComplete + (*InitialSnapshotData)(nil), // 8: sf.substreams.rpc.v2.InitialSnapshotData + (*MapModuleOutput)(nil), // 9: sf.substreams.rpc.v2.MapModuleOutput + (*StoreModuleOutput)(nil), // 10: sf.substreams.rpc.v2.StoreModuleOutput + (*OutputDebugInfo)(nil), // 11: sf.substreams.rpc.v2.OutputDebugInfo + (*ModulesProgress)(nil), // 12: sf.substreams.rpc.v2.ModulesProgress + (*ProcessedBytes)(nil), // 13: sf.substreams.rpc.v2.ProcessedBytes + (*Error)(nil), // 14: sf.substreams.rpc.v2.Error + (*Job)(nil), // 15: sf.substreams.rpc.v2.Job + (*Stage)(nil), // 16: sf.substreams.rpc.v2.Stage + (*ModuleStats)(nil), // 17: sf.substreams.rpc.v2.ModuleStats + (*ExternalCallMetric)(nil), // 18: sf.substreams.rpc.v2.ExternalCallMetric + (*StoreDelta)(nil), // 19: sf.substreams.rpc.v2.StoreDelta + (*BlockRange)(nil), // 20: sf.substreams.rpc.v2.BlockRange + (*v1.Modules)(nil), // 21: sf.substreams.v1.Modules + (*v1.BlockRef)(nil), // 22: sf.substreams.v1.BlockRef + (*v1.Clock)(nil), // 23: sf.substreams.v1.Clock + (*anypb.Any)(nil), // 24: google.protobuf.Any + (*v2.InfoRequest)(nil), // 25: sf.firehose.v2.InfoRequest + (*v2.InfoResponse)(nil), // 26: sf.firehose.v2.InfoResponse } var file_sf_substreams_rpc_v2_service_proto_depIdxs = []int32{ - 20, // 0: sf.substreams.rpc.v2.Request.modules:type_name -> sf.substreams.v1.Modules - 5, // 1: sf.substreams.rpc.v2.Response.session:type_name -> sf.substreams.rpc.v2.SessionInit - 11, // 2: sf.substreams.rpc.v2.Response.progress:type_name -> sf.substreams.rpc.v2.ModulesProgress - 4, // 3: sf.substreams.rpc.v2.Response.block_scoped_data:type_name -> sf.substreams.rpc.v2.BlockScopedData + 21, // 0: sf.substreams.rpc.v2.Request.modules:type_name -> sf.substreams.v1.Modules + 6, // 1: sf.substreams.rpc.v2.Response.session:type_name -> sf.substreams.rpc.v2.SessionInit + 12, // 2: sf.substreams.rpc.v2.Response.progress:type_name -> sf.substreams.rpc.v2.ModulesProgress + 5, // 3: sf.substreams.rpc.v2.Response.block_scoped_data:type_name -> sf.substreams.rpc.v2.BlockScopedData 3, // 4: sf.substreams.rpc.v2.Response.block_undo_signal:type_name -> sf.substreams.rpc.v2.BlockUndoSignal - 13, // 5: sf.substreams.rpc.v2.Response.fatal_error:type_name -> sf.substreams.rpc.v2.Error - 7, // 6: sf.substreams.rpc.v2.Response.debug_snapshot_data:type_name -> sf.substreams.rpc.v2.InitialSnapshotData - 6, // 7: sf.substreams.rpc.v2.Response.debug_snapshot_complete:type_name -> sf.substreams.rpc.v2.InitialSnapshotComplete - 21, // 8: sf.substreams.rpc.v2.BlockUndoSignal.last_valid_block:type_name -> sf.substreams.v1.BlockRef - 8, // 9: sf.substreams.rpc.v2.BlockScopedData.output:type_name -> sf.substreams.rpc.v2.MapModuleOutput - 22, // 10: sf.substreams.rpc.v2.BlockScopedData.clock:type_name -> sf.substreams.v1.Clock - 8, // 11: sf.substreams.rpc.v2.BlockScopedData.debug_map_outputs:type_name -> sf.substreams.rpc.v2.MapModuleOutput - 9, // 12: sf.substreams.rpc.v2.BlockScopedData.debug_store_outputs:type_name -> sf.substreams.rpc.v2.StoreModuleOutput - 18, // 13: sf.substreams.rpc.v2.InitialSnapshotData.deltas:type_name -> sf.substreams.rpc.v2.StoreDelta - 23, // 14: sf.substreams.rpc.v2.MapModuleOutput.map_output:type_name -> google.protobuf.Any - 10, // 15: sf.substreams.rpc.v2.MapModuleOutput.debug_info:type_name -> sf.substreams.rpc.v2.OutputDebugInfo - 18, // 16: sf.substreams.rpc.v2.StoreModuleOutput.debug_store_deltas:type_name -> sf.substreams.rpc.v2.StoreDelta - 10, // 17: sf.substreams.rpc.v2.StoreModuleOutput.debug_info:type_name -> sf.substreams.rpc.v2.OutputDebugInfo - 14, // 18: sf.substreams.rpc.v2.ModulesProgress.running_jobs:type_name -> sf.substreams.rpc.v2.Job - 16, // 19: sf.substreams.rpc.v2.ModulesProgress.modules_stats:type_name -> sf.substreams.rpc.v2.ModuleStats - 15, // 20: sf.substreams.rpc.v2.ModulesProgress.stages:type_name -> sf.substreams.rpc.v2.Stage - 12, // 21: sf.substreams.rpc.v2.ModulesProgress.processed_bytes:type_name -> sf.substreams.rpc.v2.ProcessedBytes - 19, // 22: sf.substreams.rpc.v2.Stage.completed_ranges:type_name -> sf.substreams.rpc.v2.BlockRange - 17, // 23: sf.substreams.rpc.v2.ModuleStats.external_call_metrics:type_name -> sf.substreams.rpc.v2.ExternalCallMetric - 0, // 24: sf.substreams.rpc.v2.StoreDelta.operation:type_name -> sf.substreams.rpc.v2.StoreDelta.Operation - 1, // 25: sf.substreams.rpc.v2.Stream.Blocks:input_type -> sf.substreams.rpc.v2.Request - 24, // 26: sf.substreams.rpc.v2.EndpointInfo.Info:input_type -> sf.firehose.v2.InfoRequest - 2, // 27: sf.substreams.rpc.v2.Stream.Blocks:output_type -> sf.substreams.rpc.v2.Response - 25, // 28: sf.substreams.rpc.v2.EndpointInfo.Info:output_type -> sf.firehose.v2.InfoResponse - 27, // [27:29] is the sub-list for method output_type - 25, // [25:27] is the sub-list for method input_type - 25, // [25:25] is the sub-list for extension type_name - 25, // [25:25] is the sub-list for extension extendee - 0, // [0:25] is the sub-list for field type_name + 14, // 5: sf.substreams.rpc.v2.Response.fatal_error:type_name -> sf.substreams.rpc.v2.Error + 4, // 6: sf.substreams.rpc.v2.Response.block_scoped_datas:type_name -> sf.substreams.rpc.v2.BlockScopedDatas + 8, // 7: sf.substreams.rpc.v2.Response.debug_snapshot_data:type_name -> sf.substreams.rpc.v2.InitialSnapshotData + 7, // 8: sf.substreams.rpc.v2.Response.debug_snapshot_complete:type_name -> sf.substreams.rpc.v2.InitialSnapshotComplete + 22, // 9: sf.substreams.rpc.v2.BlockUndoSignal.last_valid_block:type_name -> sf.substreams.v1.BlockRef + 5, // 10: sf.substreams.rpc.v2.BlockScopedDatas.items:type_name -> sf.substreams.rpc.v2.BlockScopedData + 9, // 11: sf.substreams.rpc.v2.BlockScopedData.output:type_name -> sf.substreams.rpc.v2.MapModuleOutput + 23, // 12: sf.substreams.rpc.v2.BlockScopedData.clock:type_name -> sf.substreams.v1.Clock + 9, // 13: sf.substreams.rpc.v2.BlockScopedData.debug_map_outputs:type_name -> sf.substreams.rpc.v2.MapModuleOutput + 10, // 14: sf.substreams.rpc.v2.BlockScopedData.debug_store_outputs:type_name -> sf.substreams.rpc.v2.StoreModuleOutput + 19, // 15: sf.substreams.rpc.v2.InitialSnapshotData.deltas:type_name -> sf.substreams.rpc.v2.StoreDelta + 24, // 16: sf.substreams.rpc.v2.MapModuleOutput.map_output:type_name -> google.protobuf.Any + 11, // 17: sf.substreams.rpc.v2.MapModuleOutput.debug_info:type_name -> sf.substreams.rpc.v2.OutputDebugInfo + 19, // 18: sf.substreams.rpc.v2.StoreModuleOutput.debug_store_deltas:type_name -> sf.substreams.rpc.v2.StoreDelta + 11, // 19: sf.substreams.rpc.v2.StoreModuleOutput.debug_info:type_name -> sf.substreams.rpc.v2.OutputDebugInfo + 15, // 20: sf.substreams.rpc.v2.ModulesProgress.running_jobs:type_name -> sf.substreams.rpc.v2.Job + 17, // 21: sf.substreams.rpc.v2.ModulesProgress.modules_stats:type_name -> sf.substreams.rpc.v2.ModuleStats + 16, // 22: sf.substreams.rpc.v2.ModulesProgress.stages:type_name -> sf.substreams.rpc.v2.Stage + 13, // 23: sf.substreams.rpc.v2.ModulesProgress.processed_bytes:type_name -> sf.substreams.rpc.v2.ProcessedBytes + 20, // 24: sf.substreams.rpc.v2.Stage.completed_ranges:type_name -> sf.substreams.rpc.v2.BlockRange + 18, // 25: sf.substreams.rpc.v2.ModuleStats.external_call_metrics:type_name -> sf.substreams.rpc.v2.ExternalCallMetric + 0, // 26: sf.substreams.rpc.v2.StoreDelta.operation:type_name -> sf.substreams.rpc.v2.StoreDelta.Operation + 1, // 27: sf.substreams.rpc.v2.Stream.Blocks:input_type -> sf.substreams.rpc.v2.Request + 25, // 28: sf.substreams.rpc.v2.EndpointInfo.Info:input_type -> sf.firehose.v2.InfoRequest + 2, // 29: sf.substreams.rpc.v2.Stream.Blocks:output_type -> sf.substreams.rpc.v2.Response + 26, // 30: sf.substreams.rpc.v2.EndpointInfo.Info:output_type -> sf.firehose.v2.InfoResponse + 29, // [29:31] is the sub-list for method output_type + 27, // [27:29] is the sub-list for method input_type + 27, // [27:27] is the sub-list for extension type_name + 27, // [27:27] is the sub-list for extension extendee + 0, // [0:27] is the sub-list for field type_name } func init() { file_sf_substreams_rpc_v2_service_proto_init() } @@ -1926,17 +1991,18 @@ func file_sf_substreams_rpc_v2_service_proto_init() { (*Response_BlockScopedData)(nil), (*Response_BlockUndoSignal)(nil), (*Response_FatalError)(nil), + (*Response_BlockScopedDatas)(nil), (*Response_DebugSnapshotData)(nil), (*Response_DebugSnapshotComplete)(nil), } - file_sf_substreams_rpc_v2_service_proto_msgTypes[3].OneofWrappers = []any{} + file_sf_substreams_rpc_v2_service_proto_msgTypes[4].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_sf_substreams_rpc_v2_service_proto_rawDesc), len(file_sf_substreams_rpc_v2_service_proto_rawDesc)), NumEnums: 1, - NumMessages: 19, + NumMessages: 20, NumExtensions: 0, NumServices: 2, }, diff --git a/pb/sf/substreams/rpc/v2/service_grpc.pb.go b/pb/sf/substreams/rpc/v2/service_grpc.pb.go index 55d3b02c1..50d06b884 100644 --- a/pb/sf/substreams/rpc/v2/service_grpc.pb.go +++ b/pb/sf/substreams/rpc/v2/service_grpc.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.6.0 +// - protoc-gen-go-grpc v1.5.1 // - protoc (unknown) // source: sf/substreams/rpc/v2/service.proto @@ -72,7 +72,7 @@ type StreamServer interface { type UnimplementedStreamServer struct{} func (UnimplementedStreamServer) Blocks(*Request, grpc.ServerStreamingServer[Response]) error { - return status.Error(codes.Unimplemented, "method Blocks not implemented") + return status.Errorf(codes.Unimplemented, "method Blocks not implemented") } func (UnimplementedStreamServer) testEmbeddedByValue() {} @@ -84,7 +84,7 @@ type UnsafeStreamServer interface { } func RegisterStreamServer(s grpc.ServiceRegistrar, srv StreamServer) { - // If the following call panics, it indicates UnimplementedStreamServer was + // If the following call pancis, it indicates UnimplementedStreamServer was // embedded by pointer and is nil. This will cause panics if an // unimplemented method is ever invoked, so we test this at initialization // time to prevent it from happening at runtime later due to I/O. @@ -166,7 +166,7 @@ type EndpointInfoServer interface { type UnimplementedEndpointInfoServer struct{} func (UnimplementedEndpointInfoServer) Info(context.Context, *v2.InfoRequest) (*v2.InfoResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Info not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Info not implemented") } func (UnimplementedEndpointInfoServer) testEmbeddedByValue() {} @@ -178,7 +178,7 @@ type UnsafeEndpointInfoServer interface { } func RegisterEndpointInfoServer(s grpc.ServiceRegistrar, srv EndpointInfoServer) { - // If the following call panics, it indicates UnimplementedEndpointInfoServer was + // If the following call pancis, it indicates UnimplementedEndpointInfoServer was // embedded by pointer and is nil. This will cause panics if an // unimplemented method is ever invoked, so we test this at initialization // time to prevent it from happening at runtime later due to I/O. diff --git a/pb/sf/substreams/rpc/v2/service_vtproto.pb.go b/pb/sf/substreams/rpc/v2/service_vtproto.pb.go new file mode 100644 index 000000000..99f23f687 --- /dev/null +++ b/pb/sf/substreams/rpc/v2/service_vtproto.pb.go @@ -0,0 +1,7361 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/rpc/v2/service.proto + +package pbsubstreamsrpcv2 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + anypb1 "github.com/planetscale/vtprotobuf/types/known/anypb" + v1 "github.com/streamingfast/substreams/pb/sf/substreams/v1" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + io "io" +) + +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) +) + +func (m *Request) CloneVT() *Request { + if m == nil { + return (*Request)(nil) + } + r := new(Request) + r.StartBlockNum = m.StartBlockNum + r.StartCursor = m.StartCursor + r.StopBlockNum = m.StopBlockNum + r.FinalBlocksOnly = m.FinalBlocksOnly + r.ProductionMode = m.ProductionMode + r.OutputModule = m.OutputModule + r.Modules = m.Modules.CloneVT() + r.NoopMode = m.NoopMode + r.LimitProcessedBlocks = m.LimitProcessedBlocks + r.ProgressMessagesIntervalMs = m.ProgressMessagesIntervalMs + r.PartialBlocks = m.PartialBlocks + if rhs := m.DebugInitialStoreSnapshotForModules; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.DebugInitialStoreSnapshotForModules = tmpContainer + } + if rhs := m.DevOutputModules; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.DevOutputModules = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Request) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Response) CloneVT() *Response { + if m == nil { + return (*Response)(nil) + } + r := new(Response) + if m.Message != nil { + r.Message = m.Message.(interface{ CloneVT() isResponse_Message }).CloneVT() + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Response) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Response_Session) CloneVT() isResponse_Message { + if m == nil { + return (*Response_Session)(nil) + } + r := new(Response_Session) + r.Session = m.Session.CloneVT() + return r +} + +func (m *Response_Progress) CloneVT() isResponse_Message { + if m == nil { + return (*Response_Progress)(nil) + } + r := new(Response_Progress) + r.Progress = m.Progress.CloneVT() + return r +} + +func (m *Response_BlockScopedData) CloneVT() isResponse_Message { + if m == nil { + return (*Response_BlockScopedData)(nil) + } + r := new(Response_BlockScopedData) + r.BlockScopedData = m.BlockScopedData.CloneVT() + return r +} + +func (m *Response_BlockUndoSignal) CloneVT() isResponse_Message { + if m == nil { + return (*Response_BlockUndoSignal)(nil) + } + r := new(Response_BlockUndoSignal) + r.BlockUndoSignal = m.BlockUndoSignal.CloneVT() + return r +} + +func (m *Response_FatalError) CloneVT() isResponse_Message { + if m == nil { + return (*Response_FatalError)(nil) + } + r := new(Response_FatalError) + r.FatalError = m.FatalError.CloneVT() + return r +} + +func (m *Response_BlockScopedDatas) CloneVT() isResponse_Message { + if m == nil { + return (*Response_BlockScopedDatas)(nil) + } + r := new(Response_BlockScopedDatas) + r.BlockScopedDatas = m.BlockScopedDatas.CloneVT() + return r +} + +func (m *Response_DebugSnapshotData) CloneVT() isResponse_Message { + if m == nil { + return (*Response_DebugSnapshotData)(nil) + } + r := new(Response_DebugSnapshotData) + r.DebugSnapshotData = m.DebugSnapshotData.CloneVT() + return r +} + +func (m *Response_DebugSnapshotComplete) CloneVT() isResponse_Message { + if m == nil { + return (*Response_DebugSnapshotComplete)(nil) + } + r := new(Response_DebugSnapshotComplete) + r.DebugSnapshotComplete = m.DebugSnapshotComplete.CloneVT() + return r +} + +func (m *BlockUndoSignal) CloneVT() *BlockUndoSignal { + if m == nil { + return (*BlockUndoSignal)(nil) + } + r := new(BlockUndoSignal) + r.LastValidBlock = m.LastValidBlock.CloneVT() + r.LastValidCursor = m.LastValidCursor + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BlockUndoSignal) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BlockScopedDatas) CloneVT() *BlockScopedDatas { + if m == nil { + return (*BlockScopedDatas)(nil) + } + r := new(BlockScopedDatas) + if rhs := m.Items; rhs != nil { + tmpContainer := make([]*BlockScopedData, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Items = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BlockScopedDatas) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BlockScopedData) CloneVT() *BlockScopedData { + if m == nil { + return (*BlockScopedData)(nil) + } + r := new(BlockScopedData) + r.Output = m.Output.CloneVT() + r.Clock = m.Clock.CloneVT() + r.Cursor = m.Cursor + r.FinalBlockHeight = m.FinalBlockHeight + r.Attestation = m.Attestation + r.IsPartial = m.IsPartial + if rhs := m.DebugMapOutputs; rhs != nil { + tmpContainer := make([]*MapModuleOutput, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.DebugMapOutputs = tmpContainer + } + if rhs := m.DebugStoreOutputs; rhs != nil { + tmpContainer := make([]*StoreModuleOutput, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.DebugStoreOutputs = tmpContainer + } + if rhs := m.PartialIndex; rhs != nil { + tmpVal := *rhs + r.PartialIndex = &tmpVal + } + if rhs := m.IsLastPartial; rhs != nil { + tmpVal := *rhs + r.IsLastPartial = &tmpVal + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BlockScopedData) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SessionInit) CloneVT() *SessionInit { + if m == nil { + return (*SessionInit)(nil) + } + r := new(SessionInit) + r.TraceId = m.TraceId + r.ResolvedStartBlock = m.ResolvedStartBlock + r.LinearHandoffBlock = m.LinearHandoffBlock + r.MaxParallelWorkers = m.MaxParallelWorkers + r.AttestationPublicKey = m.AttestationPublicKey + r.ChainHead = m.ChainHead + r.BlocksToProcessBeforeStartBlock = m.BlocksToProcessBeforeStartBlock + r.EffectiveBlocksToProcessBeforeStartBlock = m.EffectiveBlocksToProcessBeforeStartBlock + r.BlocksToProcessAfterStartBlock = m.BlocksToProcessAfterStartBlock + r.EffectiveBlocksToProcessAfterStartBlock = m.EffectiveBlocksToProcessAfterStartBlock + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SessionInit) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InitialSnapshotComplete) CloneVT() *InitialSnapshotComplete { + if m == nil { + return (*InitialSnapshotComplete)(nil) + } + r := new(InitialSnapshotComplete) + r.Cursor = m.Cursor + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InitialSnapshotComplete) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InitialSnapshotData) CloneVT() *InitialSnapshotData { + if m == nil { + return (*InitialSnapshotData)(nil) + } + r := new(InitialSnapshotData) + r.ModuleName = m.ModuleName + r.SentKeys = m.SentKeys + r.TotalKeys = m.TotalKeys + if rhs := m.Deltas; rhs != nil { + tmpContainer := make([]*StoreDelta, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Deltas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InitialSnapshotData) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MapModuleOutput) CloneVT() *MapModuleOutput { + if m == nil { + return (*MapModuleOutput)(nil) + } + r := new(MapModuleOutput) + r.Name = m.Name + r.MapOutput = (*anypb.Any)((*anypb1.Any)(m.MapOutput).CloneVT()) + r.DebugInfo = m.DebugInfo.CloneVT() + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MapModuleOutput) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StoreModuleOutput) CloneVT() *StoreModuleOutput { + if m == nil { + return (*StoreModuleOutput)(nil) + } + r := new(StoreModuleOutput) + r.Name = m.Name + r.DebugInfo = m.DebugInfo.CloneVT() + if rhs := m.DebugStoreDeltas; rhs != nil { + tmpContainer := make([]*StoreDelta, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.DebugStoreDeltas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StoreModuleOutput) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *OutputDebugInfo) CloneVT() *OutputDebugInfo { + if m == nil { + return (*OutputDebugInfo)(nil) + } + r := new(OutputDebugInfo) + r.LogsTruncated = m.LogsTruncated + r.Cached = m.Cached + if rhs := m.Logs; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Logs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *OutputDebugInfo) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ModulesProgress) CloneVT() *ModulesProgress { + if m == nil { + return (*ModulesProgress)(nil) + } + r := new(ModulesProgress) + r.ProcessedBytes = m.ProcessedBytes.CloneVT() + r.ProcessedBlocks = m.ProcessedBlocks + if rhs := m.RunningJobs; rhs != nil { + tmpContainer := make([]*Job, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.RunningJobs = tmpContainer + } + if rhs := m.ModulesStats; rhs != nil { + tmpContainer := make([]*ModuleStats, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ModulesStats = tmpContainer + } + if rhs := m.Stages; rhs != nil { + tmpContainer := make([]*Stage, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Stages = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ModulesProgress) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ProcessedBytes) CloneVT() *ProcessedBytes { + if m == nil { + return (*ProcessedBytes)(nil) + } + r := new(ProcessedBytes) + r.TotalBytesRead = m.TotalBytesRead + r.TotalBytesWritten = m.TotalBytesWritten + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ProcessedBytes) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Error) CloneVT() *Error { + if m == nil { + return (*Error)(nil) + } + r := new(Error) + r.Module = m.Module + r.Reason = m.Reason + r.LogsTruncated = m.LogsTruncated + if rhs := m.Logs; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Logs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Error) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Job) CloneVT() *Job { + if m == nil { + return (*Job)(nil) + } + r := new(Job) + r.Stage = m.Stage + r.StartBlock = m.StartBlock + r.StopBlock = m.StopBlock + r.ProgressBlocks = m.ProgressBlocks + r.DurationMs = m.DurationMs + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Job) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Stage) CloneVT() *Stage { + if m == nil { + return (*Stage)(nil) + } + r := new(Stage) + if rhs := m.Modules; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Modules = tmpContainer + } + if rhs := m.CompletedRanges; rhs != nil { + tmpContainer := make([]*BlockRange, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.CompletedRanges = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Stage) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ModuleStats) CloneVT() *ModuleStats { + if m == nil { + return (*ModuleStats)(nil) + } + r := new(ModuleStats) + r.Name = m.Name + r.TotalProcessedBlockCount = m.TotalProcessedBlockCount + r.TotalProcessingTimeMs = m.TotalProcessingTimeMs + r.TotalStoreOperationTimeMs = m.TotalStoreOperationTimeMs + r.TotalStoreReadCount = m.TotalStoreReadCount + r.TotalStoreWriteCount = m.TotalStoreWriteCount + r.TotalStoreDeleteprefixCount = m.TotalStoreDeleteprefixCount + r.StoreSizeBytes = m.StoreSizeBytes + r.TotalStoreMergingTimeMs = m.TotalStoreMergingTimeMs + r.StoreCurrentlyMerging = m.StoreCurrentlyMerging + r.HighestContiguousBlock = m.HighestContiguousBlock + if rhs := m.ExternalCallMetrics; rhs != nil { + tmpContainer := make([]*ExternalCallMetric, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ExternalCallMetrics = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ModuleStats) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExternalCallMetric) CloneVT() *ExternalCallMetric { + if m == nil { + return (*ExternalCallMetric)(nil) + } + r := new(ExternalCallMetric) + r.Name = m.Name + r.Count = m.Count + r.TimeMs = m.TimeMs + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExternalCallMetric) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StoreDelta) CloneVT() *StoreDelta { + if m == nil { + return (*StoreDelta)(nil) + } + r := new(StoreDelta) + r.Operation = m.Operation + r.Ordinal = m.Ordinal + r.Key = m.Key + if rhs := m.OldValue; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.OldValue = tmpBytes + } + if rhs := m.NewValue; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.NewValue = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StoreDelta) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BlockRange) CloneVT() *BlockRange { + if m == nil { + return (*BlockRange)(nil) + } + r := new(BlockRange) + r.StartBlock = m.StartBlock + r.EndBlock = m.EndBlock + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BlockRange) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *Request) EqualVT(that *Request) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.StartBlockNum != that.StartBlockNum { + return false + } + if this.StartCursor != that.StartCursor { + return false + } + if this.StopBlockNum != that.StopBlockNum { + return false + } + if this.FinalBlocksOnly != that.FinalBlocksOnly { + return false + } + if this.ProductionMode != that.ProductionMode { + return false + } + if this.OutputModule != that.OutputModule { + return false + } + if !this.Modules.EqualVT(that.Modules) { + return false + } + if len(this.DebugInitialStoreSnapshotForModules) != len(that.DebugInitialStoreSnapshotForModules) { + return false + } + for i, vx := range this.DebugInitialStoreSnapshotForModules { + vy := that.DebugInitialStoreSnapshotForModules[i] + if vx != vy { + return false + } + } + if this.NoopMode != that.NoopMode { + return false + } + if this.LimitProcessedBlocks != that.LimitProcessedBlocks { + return false + } + if len(this.DevOutputModules) != len(that.DevOutputModules) { + return false + } + for i, vx := range this.DevOutputModules { + vy := that.DevOutputModules[i] + if vx != vy { + return false + } + } + if this.ProgressMessagesIntervalMs != that.ProgressMessagesIntervalMs { + return false + } + if this.PartialBlocks != that.PartialBlocks { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Request) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Request) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Response) EqualVT(that *Response) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Message == nil && that.Message != nil { + return false + } else if this.Message != nil { + if that.Message == nil { + return false + } + if !this.Message.(interface{ EqualVT(isResponse_Message) bool }).EqualVT(that.Message) { + return false + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Response) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Response) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Response_Session) EqualVT(thatIface isResponse_Message) bool { + that, ok := thatIface.(*Response_Session) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Session, that.Session; p != q { + if p == nil { + p = &SessionInit{} + } + if q == nil { + q = &SessionInit{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Response_Progress) EqualVT(thatIface isResponse_Message) bool { + that, ok := thatIface.(*Response_Progress) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Progress, that.Progress; p != q { + if p == nil { + p = &ModulesProgress{} + } + if q == nil { + q = &ModulesProgress{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Response_BlockScopedData) EqualVT(thatIface isResponse_Message) bool { + that, ok := thatIface.(*Response_BlockScopedData) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.BlockScopedData, that.BlockScopedData; p != q { + if p == nil { + p = &BlockScopedData{} + } + if q == nil { + q = &BlockScopedData{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Response_BlockUndoSignal) EqualVT(thatIface isResponse_Message) bool { + that, ok := thatIface.(*Response_BlockUndoSignal) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.BlockUndoSignal, that.BlockUndoSignal; p != q { + if p == nil { + p = &BlockUndoSignal{} + } + if q == nil { + q = &BlockUndoSignal{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Response_FatalError) EqualVT(thatIface isResponse_Message) bool { + that, ok := thatIface.(*Response_FatalError) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.FatalError, that.FatalError; p != q { + if p == nil { + p = &Error{} + } + if q == nil { + q = &Error{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Response_BlockScopedDatas) EqualVT(thatIface isResponse_Message) bool { + that, ok := thatIface.(*Response_BlockScopedDatas) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.BlockScopedDatas, that.BlockScopedDatas; p != q { + if p == nil { + p = &BlockScopedDatas{} + } + if q == nil { + q = &BlockScopedDatas{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Response_DebugSnapshotData) EqualVT(thatIface isResponse_Message) bool { + that, ok := thatIface.(*Response_DebugSnapshotData) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.DebugSnapshotData, that.DebugSnapshotData; p != q { + if p == nil { + p = &InitialSnapshotData{} + } + if q == nil { + q = &InitialSnapshotData{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Response_DebugSnapshotComplete) EqualVT(thatIface isResponse_Message) bool { + that, ok := thatIface.(*Response_DebugSnapshotComplete) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.DebugSnapshotComplete, that.DebugSnapshotComplete; p != q { + if p == nil { + p = &InitialSnapshotComplete{} + } + if q == nil { + q = &InitialSnapshotComplete{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *BlockUndoSignal) EqualVT(that *BlockUndoSignal) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if !this.LastValidBlock.EqualVT(that.LastValidBlock) { + return false + } + if this.LastValidCursor != that.LastValidCursor { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *BlockUndoSignal) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*BlockUndoSignal) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *BlockScopedDatas) EqualVT(that *BlockScopedDatas) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Items) != len(that.Items) { + return false + } + for i, vx := range this.Items { + vy := that.Items[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &BlockScopedData{} + } + if q == nil { + q = &BlockScopedData{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *BlockScopedDatas) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*BlockScopedDatas) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *BlockScopedData) EqualVT(that *BlockScopedData) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if !this.Output.EqualVT(that.Output) { + return false + } + if !this.Clock.EqualVT(that.Clock) { + return false + } + if this.Cursor != that.Cursor { + return false + } + if this.FinalBlockHeight != that.FinalBlockHeight { + return false + } + if len(this.DebugMapOutputs) != len(that.DebugMapOutputs) { + return false + } + for i, vx := range this.DebugMapOutputs { + vy := that.DebugMapOutputs[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &MapModuleOutput{} + } + if q == nil { + q = &MapModuleOutput{} + } + if !p.EqualVT(q) { + return false + } + } + } + if len(this.DebugStoreOutputs) != len(that.DebugStoreOutputs) { + return false + } + for i, vx := range this.DebugStoreOutputs { + vy := that.DebugStoreOutputs[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &StoreModuleOutput{} + } + if q == nil { + q = &StoreModuleOutput{} + } + if !p.EqualVT(q) { + return false + } + } + } + if this.Attestation != that.Attestation { + return false + } + if this.IsPartial != that.IsPartial { + return false + } + if p, q := this.PartialIndex, that.PartialIndex; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) { + return false + } + if p, q := this.IsLastPartial, that.IsLastPartial; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *BlockScopedData) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*BlockScopedData) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SessionInit) EqualVT(that *SessionInit) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.TraceId != that.TraceId { + return false + } + if this.ResolvedStartBlock != that.ResolvedStartBlock { + return false + } + if this.LinearHandoffBlock != that.LinearHandoffBlock { + return false + } + if this.MaxParallelWorkers != that.MaxParallelWorkers { + return false + } + if this.AttestationPublicKey != that.AttestationPublicKey { + return false + } + if this.ChainHead != that.ChainHead { + return false + } + if this.BlocksToProcessBeforeStartBlock != that.BlocksToProcessBeforeStartBlock { + return false + } + if this.EffectiveBlocksToProcessBeforeStartBlock != that.EffectiveBlocksToProcessBeforeStartBlock { + return false + } + if this.BlocksToProcessAfterStartBlock != that.BlocksToProcessAfterStartBlock { + return false + } + if this.EffectiveBlocksToProcessAfterStartBlock != that.EffectiveBlocksToProcessAfterStartBlock { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SessionInit) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SessionInit) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *InitialSnapshotComplete) EqualVT(that *InitialSnapshotComplete) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Cursor != that.Cursor { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *InitialSnapshotComplete) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*InitialSnapshotComplete) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *InitialSnapshotData) EqualVT(that *InitialSnapshotData) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.ModuleName != that.ModuleName { + return false + } + if len(this.Deltas) != len(that.Deltas) { + return false + } + for i, vx := range this.Deltas { + vy := that.Deltas[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &StoreDelta{} + } + if q == nil { + q = &StoreDelta{} + } + if !p.EqualVT(q) { + return false + } + } + } + if this.TotalKeys != that.TotalKeys { + return false + } + if this.SentKeys != that.SentKeys { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *InitialSnapshotData) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*InitialSnapshotData) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *MapModuleOutput) EqualVT(that *MapModuleOutput) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Name != that.Name { + return false + } + if !(*anypb1.Any)(this.MapOutput).EqualVT((*anypb1.Any)(that.MapOutput)) { + return false + } + if !this.DebugInfo.EqualVT(that.DebugInfo) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *MapModuleOutput) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*MapModuleOutput) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *StoreModuleOutput) EqualVT(that *StoreModuleOutput) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Name != that.Name { + return false + } + if len(this.DebugStoreDeltas) != len(that.DebugStoreDeltas) { + return false + } + for i, vx := range this.DebugStoreDeltas { + vy := that.DebugStoreDeltas[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &StoreDelta{} + } + if q == nil { + q = &StoreDelta{} + } + if !p.EqualVT(q) { + return false + } + } + } + if !this.DebugInfo.EqualVT(that.DebugInfo) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *StoreModuleOutput) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*StoreModuleOutput) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *OutputDebugInfo) EqualVT(that *OutputDebugInfo) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Logs) != len(that.Logs) { + return false + } + for i, vx := range this.Logs { + vy := that.Logs[i] + if vx != vy { + return false + } + } + if this.LogsTruncated != that.LogsTruncated { + return false + } + if this.Cached != that.Cached { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *OutputDebugInfo) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*OutputDebugInfo) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ModulesProgress) EqualVT(that *ModulesProgress) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.RunningJobs) != len(that.RunningJobs) { + return false + } + for i, vx := range this.RunningJobs { + vy := that.RunningJobs[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Job{} + } + if q == nil { + q = &Job{} + } + if !p.EqualVT(q) { + return false + } + } + } + if len(this.ModulesStats) != len(that.ModulesStats) { + return false + } + for i, vx := range this.ModulesStats { + vy := that.ModulesStats[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &ModuleStats{} + } + if q == nil { + q = &ModuleStats{} + } + if !p.EqualVT(q) { + return false + } + } + } + if len(this.Stages) != len(that.Stages) { + return false + } + for i, vx := range this.Stages { + vy := that.Stages[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Stage{} + } + if q == nil { + q = &Stage{} + } + if !p.EqualVT(q) { + return false + } + } + } + if !this.ProcessedBytes.EqualVT(that.ProcessedBytes) { + return false + } + if this.ProcessedBlocks != that.ProcessedBlocks { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ModulesProgress) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ModulesProgress) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ProcessedBytes) EqualVT(that *ProcessedBytes) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.TotalBytesRead != that.TotalBytesRead { + return false + } + if this.TotalBytesWritten != that.TotalBytesWritten { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ProcessedBytes) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ProcessedBytes) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Error) EqualVT(that *Error) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Module != that.Module { + return false + } + if this.Reason != that.Reason { + return false + } + if len(this.Logs) != len(that.Logs) { + return false + } + for i, vx := range this.Logs { + vy := that.Logs[i] + if vx != vy { + return false + } + } + if this.LogsTruncated != that.LogsTruncated { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Error) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Error) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Job) EqualVT(that *Job) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Stage != that.Stage { + return false + } + if this.StartBlock != that.StartBlock { + return false + } + if this.StopBlock != that.StopBlock { + return false + } + if this.ProgressBlocks != that.ProgressBlocks { + return false + } + if this.DurationMs != that.DurationMs { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Job) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Job) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Stage) EqualVT(that *Stage) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Modules) != len(that.Modules) { + return false + } + for i, vx := range this.Modules { + vy := that.Modules[i] + if vx != vy { + return false + } + } + if len(this.CompletedRanges) != len(that.CompletedRanges) { + return false + } + for i, vx := range this.CompletedRanges { + vy := that.CompletedRanges[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &BlockRange{} + } + if q == nil { + q = &BlockRange{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Stage) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Stage) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ModuleStats) EqualVT(that *ModuleStats) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Name != that.Name { + return false + } + if this.TotalProcessedBlockCount != that.TotalProcessedBlockCount { + return false + } + if this.TotalProcessingTimeMs != that.TotalProcessingTimeMs { + return false + } + if len(this.ExternalCallMetrics) != len(that.ExternalCallMetrics) { + return false + } + for i, vx := range this.ExternalCallMetrics { + vy := that.ExternalCallMetrics[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &ExternalCallMetric{} + } + if q == nil { + q = &ExternalCallMetric{} + } + if !p.EqualVT(q) { + return false + } + } + } + if this.TotalStoreOperationTimeMs != that.TotalStoreOperationTimeMs { + return false + } + if this.TotalStoreReadCount != that.TotalStoreReadCount { + return false + } + if this.TotalStoreWriteCount != that.TotalStoreWriteCount { + return false + } + if this.TotalStoreDeleteprefixCount != that.TotalStoreDeleteprefixCount { + return false + } + if this.StoreSizeBytes != that.StoreSizeBytes { + return false + } + if this.TotalStoreMergingTimeMs != that.TotalStoreMergingTimeMs { + return false + } + if this.StoreCurrentlyMerging != that.StoreCurrentlyMerging { + return false + } + if this.HighestContiguousBlock != that.HighestContiguousBlock { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ModuleStats) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ModuleStats) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ExternalCallMetric) EqualVT(that *ExternalCallMetric) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Name != that.Name { + return false + } + if this.Count != that.Count { + return false + } + if this.TimeMs != that.TimeMs { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ExternalCallMetric) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ExternalCallMetric) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *StoreDelta) EqualVT(that *StoreDelta) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Operation != that.Operation { + return false + } + if this.Ordinal != that.Ordinal { + return false + } + if this.Key != that.Key { + return false + } + if string(this.OldValue) != string(that.OldValue) { + return false + } + if string(this.NewValue) != string(that.NewValue) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *StoreDelta) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*StoreDelta) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *BlockRange) EqualVT(that *BlockRange) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.StartBlock != that.StartBlock { + return false + } + if this.EndBlock != that.EndBlock { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *BlockRange) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*BlockRange) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *Request) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Request) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Request) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PartialBlocks { + i-- + if m.PartialBlocks { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x80 + } + if m.ProgressMessagesIntervalMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProgressMessagesIntervalMs)) + i-- + dAtA[i] = 0x70 + } + if len(m.DevOutputModules) > 0 { + for iNdEx := len(m.DevOutputModules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DevOutputModules[iNdEx]) + copy(dAtA[i:], m.DevOutputModules[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DevOutputModules[iNdEx]))) + i-- + dAtA[i] = 0x6a + } + } + if m.LimitProcessedBlocks != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.LimitProcessedBlocks)) + i-- + dAtA[i] = 0x60 + } + if m.NoopMode { + i-- + if m.NoopMode { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 + } + if len(m.DebugInitialStoreSnapshotForModules) > 0 { + for iNdEx := len(m.DebugInitialStoreSnapshotForModules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DebugInitialStoreSnapshotForModules[iNdEx]) + copy(dAtA[i:], m.DebugInitialStoreSnapshotForModules[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DebugInitialStoreSnapshotForModules[iNdEx]))) + i-- + dAtA[i] = 0x52 + } + } + if m.Modules != nil { + size, err := m.Modules.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.OutputModule) > 0 { + i -= len(m.OutputModule) + copy(dAtA[i:], m.OutputModule) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OutputModule))) + i-- + dAtA[i] = 0x32 + } + if m.ProductionMode { + i-- + if m.ProductionMode { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if m.FinalBlocksOnly { + i-- + if m.FinalBlocksOnly { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.StopBlockNum != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StopBlockNum)) + i-- + dAtA[i] = 0x18 + } + if len(m.StartCursor) > 0 { + i -= len(m.StartCursor) + copy(dAtA[i:], m.StartCursor) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StartCursor))) + i-- + dAtA[i] = 0x12 + } + if m.StartBlockNum != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StartBlockNum)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Response) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Response) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Message.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + return len(dAtA) - i, nil +} + +func (m *Response_Session) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response_Session) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Session != nil { + size, err := m.Session.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *Response_Progress) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response_Progress) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Progress != nil { + size, err := m.Progress.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *Response_BlockScopedData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response_BlockScopedData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BlockScopedData != nil { + size, err := m.BlockScopedData.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *Response_BlockUndoSignal) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response_BlockUndoSignal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BlockUndoSignal != nil { + size, err := m.BlockUndoSignal.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *Response_FatalError) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response_FatalError) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FatalError != nil { + size, err := m.FatalError.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *Response_BlockScopedDatas) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response_BlockScopedDatas) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BlockScopedDatas != nil { + size, err := m.BlockScopedDatas.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + return len(dAtA) - i, nil +} +func (m *Response_DebugSnapshotData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response_DebugSnapshotData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.DebugSnapshotData != nil { + size, err := m.DebugSnapshotData.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + return len(dAtA) - i, nil +} +func (m *Response_DebugSnapshotComplete) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Response_DebugSnapshotComplete) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.DebugSnapshotComplete != nil { + size, err := m.DebugSnapshotComplete.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + return len(dAtA) - i, nil +} +func (m *BlockUndoSignal) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockUndoSignal) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlockUndoSignal) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.LastValidCursor) > 0 { + i -= len(m.LastValidCursor) + copy(dAtA[i:], m.LastValidCursor) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LastValidCursor))) + i-- + dAtA[i] = 0x12 + } + if m.LastValidBlock != nil { + size, err := m.LastValidBlock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlockScopedDatas) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockScopedDatas) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlockScopedDatas) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Items[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *BlockScopedData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockScopedData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlockScopedData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.IsLastPartial != nil { + i-- + if *m.IsLastPartial { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x78 + } + if m.PartialIndex != nil { + i = protohelpers.EncodeVarint(dAtA, i, uint64(*m.PartialIndex)) + i-- + dAtA[i] = 0x70 + } + if m.IsPartial { + i-- + if m.IsPartial { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x68 + } + if len(m.Attestation) > 0 { + i -= len(m.Attestation) + copy(dAtA[i:], m.Attestation) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Attestation))) + i-- + dAtA[i] = 0x62 + } + if len(m.DebugStoreOutputs) > 0 { + for iNdEx := len(m.DebugStoreOutputs) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.DebugStoreOutputs[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + } + if len(m.DebugMapOutputs) > 0 { + for iNdEx := len(m.DebugMapOutputs) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.DebugMapOutputs[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + } + if m.FinalBlockHeight != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FinalBlockHeight)) + i-- + dAtA[i] = 0x20 + } + if len(m.Cursor) > 0 { + i -= len(m.Cursor) + copy(dAtA[i:], m.Cursor) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Cursor))) + i-- + dAtA[i] = 0x1a + } + if m.Clock != nil { + size, err := m.Clock.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Output != nil { + size, err := m.Output.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SessionInit) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SessionInit) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SessionInit) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.EffectiveBlocksToProcessAfterStartBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EffectiveBlocksToProcessAfterStartBlock)) + i-- + dAtA[i] = 0x50 + } + if m.BlocksToProcessAfterStartBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BlocksToProcessAfterStartBlock)) + i-- + dAtA[i] = 0x48 + } + if m.EffectiveBlocksToProcessBeforeStartBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EffectiveBlocksToProcessBeforeStartBlock)) + i-- + dAtA[i] = 0x40 + } + if m.BlocksToProcessBeforeStartBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BlocksToProcessBeforeStartBlock)) + i-- + dAtA[i] = 0x38 + } + if m.ChainHead != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ChainHead)) + i-- + dAtA[i] = 0x30 + } + if len(m.AttestationPublicKey) > 0 { + i -= len(m.AttestationPublicKey) + copy(dAtA[i:], m.AttestationPublicKey) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AttestationPublicKey))) + i-- + dAtA[i] = 0x2a + } + if m.MaxParallelWorkers != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MaxParallelWorkers)) + i-- + dAtA[i] = 0x20 + } + if m.LinearHandoffBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.LinearHandoffBlock)) + i-- + dAtA[i] = 0x18 + } + if m.ResolvedStartBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ResolvedStartBlock)) + i-- + dAtA[i] = 0x10 + } + if len(m.TraceId) > 0 { + i -= len(m.TraceId) + copy(dAtA[i:], m.TraceId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TraceId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *InitialSnapshotComplete) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InitialSnapshotComplete) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *InitialSnapshotComplete) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Cursor) > 0 { + i -= len(m.Cursor) + copy(dAtA[i:], m.Cursor) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Cursor))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *InitialSnapshotData) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InitialSnapshotData) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *InitialSnapshotData) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.SentKeys != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SentKeys)) + i-- + dAtA[i] = 0x20 + } + if m.TotalKeys != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalKeys)) + i-- + dAtA[i] = 0x18 + } + if len(m.Deltas) > 0 { + for iNdEx := len(m.Deltas) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deltas[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.ModuleName) > 0 { + i -= len(m.ModuleName) + copy(dAtA[i:], m.ModuleName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ModuleName))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MapModuleOutput) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MapModuleOutput) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *MapModuleOutput) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.DebugInfo != nil { + size, err := m.DebugInfo.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if m.MapOutput != nil { + size, err := (*anypb1.Any)(m.MapOutput).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StoreModuleOutput) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreModuleOutput) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *StoreModuleOutput) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.DebugInfo != nil { + size, err := m.DebugInfo.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.DebugStoreDeltas) > 0 { + for iNdEx := len(m.DebugStoreDeltas) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.DebugStoreDeltas[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *OutputDebugInfo) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *OutputDebugInfo) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *OutputDebugInfo) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Cached { + i-- + if m.Cached { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.LogsTruncated { + i-- + if m.LogsTruncated { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(m.Logs) > 0 { + for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Logs[iNdEx]) + copy(dAtA[i:], m.Logs[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Logs[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ModulesProgress) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ModulesProgress) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ModulesProgress) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.ProcessedBlocks != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProcessedBlocks)) + i-- + dAtA[i] = 0x30 + } + if m.ProcessedBytes != nil { + size, err := m.ProcessedBytes.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if len(m.Stages) > 0 { + for iNdEx := len(m.Stages) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Stages[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.ModulesStats) > 0 { + for iNdEx := len(m.ModulesStats) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ModulesStats[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.RunningJobs) > 0 { + for iNdEx := len(m.RunningJobs) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.RunningJobs[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + return len(dAtA) - i, nil +} + +func (m *ProcessedBytes) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProcessedBytes) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ProcessedBytes) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.TotalBytesWritten != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalBytesWritten)) + i-- + dAtA[i] = 0x10 + } + if m.TotalBytesRead != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalBytesRead)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Error) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Error) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Error) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.LogsTruncated { + i-- + if m.LogsTruncated { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if len(m.Logs) > 0 { + for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Logs[iNdEx]) + copy(dAtA[i:], m.Logs[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Logs[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x12 + } + if len(m.Module) > 0 { + i -= len(m.Module) + copy(dAtA[i:], m.Module) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Module))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Job) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Job) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Job) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.DurationMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DurationMs)) + i-- + dAtA[i] = 0x28 + } + if m.ProgressBlocks != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProgressBlocks)) + i-- + dAtA[i] = 0x20 + } + if m.StopBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StopBlock)) + i-- + dAtA[i] = 0x18 + } + if m.StartBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StartBlock)) + i-- + dAtA[i] = 0x10 + } + if m.Stage != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Stage)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Stage) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Stage) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Stage) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.CompletedRanges) > 0 { + for iNdEx := len(m.CompletedRanges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.CompletedRanges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Modules) > 0 { + for iNdEx := len(m.Modules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Modules[iNdEx]) + copy(dAtA[i:], m.Modules[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Modules[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ModuleStats) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ModuleStats) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ModuleStats) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.HighestContiguousBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.HighestContiguousBlock)) + i-- + dAtA[i] = 0x78 + } + if m.StoreCurrentlyMerging { + i-- + if m.StoreCurrentlyMerging { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x70 + } + if m.TotalStoreMergingTimeMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalStoreMergingTimeMs)) + i-- + dAtA[i] = 0x68 + } + if m.StoreSizeBytes != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StoreSizeBytes)) + i-- + dAtA[i] = 0x60 + } + if m.TotalStoreDeleteprefixCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalStoreDeleteprefixCount)) + i-- + dAtA[i] = 0x58 + } + if m.TotalStoreWriteCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalStoreWriteCount)) + i-- + dAtA[i] = 0x50 + } + if m.TotalStoreReadCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalStoreReadCount)) + i-- + dAtA[i] = 0x30 + } + if m.TotalStoreOperationTimeMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalStoreOperationTimeMs)) + i-- + dAtA[i] = 0x28 + } + if len(m.ExternalCallMetrics) > 0 { + for iNdEx := len(m.ExternalCallMetrics) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ExternalCallMetrics[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if m.TotalProcessingTimeMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalProcessingTimeMs)) + i-- + dAtA[i] = 0x18 + } + if m.TotalProcessedBlockCount != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalProcessedBlockCount)) + i-- + dAtA[i] = 0x10 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExternalCallMetric) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExternalCallMetric) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ExternalCallMetric) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.TimeMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TimeMs)) + i-- + dAtA[i] = 0x18 + } + if m.Count != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Count)) + i-- + dAtA[i] = 0x10 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StoreDelta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreDelta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *StoreDelta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.NewValue) > 0 { + i -= len(m.NewValue) + copy(dAtA[i:], m.NewValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewValue))) + i-- + dAtA[i] = 0x2a + } + if len(m.OldValue) > 0 { + i -= len(m.OldValue) + copy(dAtA[i:], m.OldValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldValue))) + i-- + dAtA[i] = 0x22 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x1a + } + if m.Ordinal != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Ordinal)) + i-- + dAtA[i] = 0x10 + } + if m.Operation != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Operation)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BlockRange) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockRange) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlockRange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.EndBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EndBlock)) + i-- + dAtA[i] = 0x18 + } + if m.StartBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StartBlock)) + i-- + dAtA[i] = 0x10 + } + return len(dAtA) - i, nil +} + +func (m *Request) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StartBlockNum != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StartBlockNum)) + } + l = len(m.StartCursor) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StopBlockNum != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StopBlockNum)) + } + if m.FinalBlocksOnly { + n += 2 + } + if m.ProductionMode { + n += 2 + } + l = len(m.OutputModule) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Modules != nil { + l = m.Modules.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.DebugInitialStoreSnapshotForModules) > 0 { + for _, s := range m.DebugInitialStoreSnapshotForModules { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.NoopMode { + n += 2 + } + if m.LimitProcessedBlocks != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.LimitProcessedBlocks)) + } + if len(m.DevOutputModules) > 0 { + for _, s := range m.DevOutputModules { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ProgressMessagesIntervalMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProgressMessagesIntervalMs)) + } + if m.PartialBlocks { + n += 3 + } + n += len(m.unknownFields) + return n +} + +func (m *Response) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if vtmsg, ok := m.Message.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *Response_Session) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Session != nil { + l = m.Session.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Response_Progress) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Progress != nil { + l = m.Progress.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Response_BlockScopedData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockScopedData != nil { + l = m.BlockScopedData.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Response_BlockUndoSignal) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockUndoSignal != nil { + l = m.BlockUndoSignal.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Response_FatalError) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FatalError != nil { + l = m.FatalError.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Response_BlockScopedDatas) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockScopedDatas != nil { + l = m.BlockScopedDatas.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Response_DebugSnapshotData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DebugSnapshotData != nil { + l = m.DebugSnapshotData.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Response_DebugSnapshotComplete) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DebugSnapshotComplete != nil { + l = m.DebugSnapshotComplete.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *BlockUndoSignal) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LastValidBlock != nil { + l = m.LastValidBlock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.LastValidCursor) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlockScopedDatas) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *BlockScopedData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Output != nil { + l = m.Output.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Clock != nil { + l = m.Clock.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Cursor) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.FinalBlockHeight != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.FinalBlockHeight)) + } + if len(m.DebugMapOutputs) > 0 { + for _, e := range m.DebugMapOutputs { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.DebugStoreOutputs) > 0 { + for _, e := range m.DebugStoreOutputs { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + l = len(m.Attestation) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.IsPartial { + n += 2 + } + if m.PartialIndex != nil { + n += 1 + protohelpers.SizeOfVarint(uint64(*m.PartialIndex)) + } + if m.IsLastPartial != nil { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *SessionInit) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.TraceId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ResolvedStartBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ResolvedStartBlock)) + } + if m.LinearHandoffBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.LinearHandoffBlock)) + } + if m.MaxParallelWorkers != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.MaxParallelWorkers)) + } + l = len(m.AttestationPublicKey) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ChainHead != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ChainHead)) + } + if m.BlocksToProcessBeforeStartBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BlocksToProcessBeforeStartBlock)) + } + if m.EffectiveBlocksToProcessBeforeStartBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.EffectiveBlocksToProcessBeforeStartBlock)) + } + if m.BlocksToProcessAfterStartBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BlocksToProcessAfterStartBlock)) + } + if m.EffectiveBlocksToProcessAfterStartBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.EffectiveBlocksToProcessAfterStartBlock)) + } + n += len(m.unknownFields) + return n +} + +func (m *InitialSnapshotComplete) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Cursor) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *InitialSnapshotData) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ModuleName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Deltas) > 0 { + for _, e := range m.Deltas { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.TotalKeys != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalKeys)) + } + if m.SentKeys != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.SentKeys)) + } + n += len(m.unknownFields) + return n +} + +func (m *MapModuleOutput) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.MapOutput != nil { + l = (*anypb1.Any)(m.MapOutput).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DebugInfo != nil { + l = m.DebugInfo.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *StoreModuleOutput) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.DebugStoreDeltas) > 0 { + for _, e := range m.DebugStoreDeltas { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.DebugInfo != nil { + l = m.DebugInfo.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *OutputDebugInfo) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Logs) > 0 { + for _, s := range m.Logs { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.LogsTruncated { + n += 2 + } + if m.Cached { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *ModulesProgress) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.RunningJobs) > 0 { + for _, e := range m.RunningJobs { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.ModulesStats) > 0 { + for _, e := range m.ModulesStats { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Stages) > 0 { + for _, e := range m.Stages { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ProcessedBytes != nil { + l = m.ProcessedBytes.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.ProcessedBlocks != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProcessedBlocks)) + } + n += len(m.unknownFields) + return n +} + +func (m *ProcessedBytes) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TotalBytesRead != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalBytesRead)) + } + if m.TotalBytesWritten != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalBytesWritten)) + } + n += len(m.unknownFields) + return n +} + +func (m *Error) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Module) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Reason) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Logs) > 0 { + for _, s := range m.Logs { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.LogsTruncated { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *Job) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Stage != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Stage)) + } + if m.StartBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StartBlock)) + } + if m.StopBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StopBlock)) + } + if m.ProgressBlocks != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProgressBlocks)) + } + if m.DurationMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.DurationMs)) + } + n += len(m.unknownFields) + return n +} + +func (m *Stage) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Modules) > 0 { + for _, s := range m.Modules { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.CompletedRanges) > 0 { + for _, e := range m.CompletedRanges { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *ModuleStats) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.TotalProcessedBlockCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalProcessedBlockCount)) + } + if m.TotalProcessingTimeMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalProcessingTimeMs)) + } + if len(m.ExternalCallMetrics) > 0 { + for _, e := range m.ExternalCallMetrics { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.TotalStoreOperationTimeMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalStoreOperationTimeMs)) + } + if m.TotalStoreReadCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalStoreReadCount)) + } + if m.TotalStoreWriteCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalStoreWriteCount)) + } + if m.TotalStoreDeleteprefixCount != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalStoreDeleteprefixCount)) + } + if m.StoreSizeBytes != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StoreSizeBytes)) + } + if m.TotalStoreMergingTimeMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalStoreMergingTimeMs)) + } + if m.StoreCurrentlyMerging { + n += 2 + } + if m.HighestContiguousBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.HighestContiguousBlock)) + } + n += len(m.unknownFields) + return n +} + +func (m *ExternalCallMetric) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Count != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Count)) + } + if m.TimeMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.TimeMs)) + } + n += len(m.unknownFields) + return n +} + +func (m *StoreDelta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Operation != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Operation)) + } + if m.Ordinal != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Ordinal)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.OldValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.NewValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlockRange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StartBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StartBlock)) + } + if m.EndBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.EndBlock)) + } + n += len(m.unknownFields) + return n +} + +func (m *Request) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Request: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlockNum", wireType) + } + m.StartBlockNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlockNum |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartCursor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StartCursor = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StopBlockNum", wireType) + } + m.StopBlockNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StopBlockNum |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalBlocksOnly", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.FinalBlocksOnly = bool(v != 0) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProductionMode", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ProductionMode = bool(v != 0) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputModule", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputModule = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Modules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Modules == nil { + m.Modules = &v1.Modules{} + } + if err := m.Modules.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugInitialStoreSnapshotForModules", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DebugInitialStoreSnapshotForModules = append(m.DebugInitialStoreSnapshotForModules, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NoopMode", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NoopMode = bool(v != 0) + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LimitProcessedBlocks", wireType) + } + m.LimitProcessedBlocks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LimitProcessedBlocks |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DevOutputModules", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DevOutputModules = append(m.DevOutputModules, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressMessagesIntervalMs", wireType) + } + m.ProgressMessagesIntervalMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProgressMessagesIntervalMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialBlocks", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.PartialBlocks = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Response) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Response: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Session", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*Response_Session); ok { + if err := oneof.Session.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &SessionInit{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &Response_Session{Session: v} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*Response_Progress); ok { + if err := oneof.Progress.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &ModulesProgress{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &Response_Progress{Progress: v} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockScopedData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*Response_BlockScopedData); ok { + if err := oneof.BlockScopedData.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &BlockScopedData{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &Response_BlockScopedData{BlockScopedData: v} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockUndoSignal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*Response_BlockUndoSignal); ok { + if err := oneof.BlockUndoSignal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &BlockUndoSignal{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &Response_BlockUndoSignal{BlockUndoSignal: v} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FatalError", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*Response_FatalError); ok { + if err := oneof.FatalError.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Error{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &Response_FatalError{FatalError: v} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockScopedDatas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*Response_BlockScopedDatas); ok { + if err := oneof.BlockScopedDatas.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &BlockScopedDatas{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &Response_BlockScopedDatas{BlockScopedDatas: v} + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugSnapshotData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*Response_DebugSnapshotData); ok { + if err := oneof.DebugSnapshotData.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &InitialSnapshotData{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &Response_DebugSnapshotData{DebugSnapshotData: v} + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugSnapshotComplete", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Message.(*Response_DebugSnapshotComplete); ok { + if err := oneof.DebugSnapshotComplete.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &InitialSnapshotComplete{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Message = &Response_DebugSnapshotComplete{DebugSnapshotComplete: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlockUndoSignal) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: BlockUndoSignal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockUndoSignal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastValidBlock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastValidBlock == nil { + m.LastValidBlock = &v1.BlockRef{} + } + if err := m.LastValidBlock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastValidCursor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LastValidCursor = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlockScopedDatas) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: BlockScopedDatas: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockScopedDatas: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, &BlockScopedData{}) + if err := m.Items[len(m.Items)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlockScopedData) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: BlockScopedData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockScopedData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output == nil { + m.Output = &MapModuleOutput{} + } + if err := m.Output.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Clock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Clock == nil { + m.Clock = &v1.Clock{} + } + if err := m.Clock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cursor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Cursor = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalBlockHeight", wireType) + } + m.FinalBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FinalBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugMapOutputs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DebugMapOutputs = append(m.DebugMapOutputs, &MapModuleOutput{}) + if err := m.DebugMapOutputs[len(m.DebugMapOutputs)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugStoreOutputs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DebugStoreOutputs = append(m.DebugStoreOutputs, &StoreModuleOutput{}) + if err := m.DebugStoreOutputs[len(m.DebugStoreOutputs)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attestation", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Attestation = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsPartial", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsPartial = bool(v != 0) + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialIndex", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.PartialIndex = &v + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsLastPartial", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.IsLastPartial = &b + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SessionInit) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SessionInit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SessionInit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TraceId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResolvedStartBlock", wireType) + } + m.ResolvedStartBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ResolvedStartBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LinearHandoffBlock", wireType) + } + m.LinearHandoffBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LinearHandoffBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxParallelWorkers", wireType) + } + m.MaxParallelWorkers = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxParallelWorkers |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttestationPublicKey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AttestationPublicKey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainHead", wireType) + } + m.ChainHead = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ChainHead |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlocksToProcessBeforeStartBlock", wireType) + } + m.BlocksToProcessBeforeStartBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlocksToProcessBeforeStartBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EffectiveBlocksToProcessBeforeStartBlock", wireType) + } + m.EffectiveBlocksToProcessBeforeStartBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EffectiveBlocksToProcessBeforeStartBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlocksToProcessAfterStartBlock", wireType) + } + m.BlocksToProcessAfterStartBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlocksToProcessAfterStartBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EffectiveBlocksToProcessAfterStartBlock", wireType) + } + m.EffectiveBlocksToProcessAfterStartBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EffectiveBlocksToProcessAfterStartBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InitialSnapshotComplete) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: InitialSnapshotComplete: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InitialSnapshotComplete: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cursor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Cursor = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InitialSnapshotData) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: InitialSnapshotData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InitialSnapshotData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ModuleName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ModuleName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deltas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Deltas = append(m.Deltas, &StoreDelta{}) + if err := m.Deltas[len(m.Deltas)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalKeys", wireType) + } + m.TotalKeys = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalKeys |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SentKeys", wireType) + } + m.SentKeys = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SentKeys |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MapModuleOutput) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: MapModuleOutput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MapModuleOutput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MapOutput", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MapOutput == nil { + m.MapOutput = &anypb.Any{} + } + if err := (*anypb1.Any)(m.MapOutput).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DebugInfo == nil { + m.DebugInfo = &OutputDebugInfo{} + } + if err := m.DebugInfo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreModuleOutput) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: StoreModuleOutput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreModuleOutput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugStoreDeltas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DebugStoreDeltas = append(m.DebugStoreDeltas, &StoreDelta{}) + if err := m.DebugStoreDeltas[len(m.DebugStoreDeltas)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DebugInfo == nil { + m.DebugInfo = &OutputDebugInfo{} + } + if err := m.DebugInfo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OutputDebugInfo) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: OutputDebugInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OutputDebugInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Logs = append(m.Logs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsTruncated", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LogsTruncated = bool(v != 0) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Cached", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Cached = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ModulesProgress) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ModulesProgress: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ModulesProgress: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RunningJobs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RunningJobs = append(m.RunningJobs, &Job{}) + if err := m.RunningJobs[len(m.RunningJobs)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ModulesStats", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ModulesStats = append(m.ModulesStats, &ModuleStats{}) + if err := m.ModulesStats[len(m.ModulesStats)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stages", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Stages = append(m.Stages, &Stage{}) + if err := m.Stages[len(m.Stages)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProcessedBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ProcessedBytes == nil { + m.ProcessedBytes = &ProcessedBytes{} + } + if err := m.ProcessedBytes.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProcessedBlocks", wireType) + } + m.ProcessedBlocks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProcessedBlocks |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProcessedBytes) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ProcessedBytes: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProcessedBytes: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytesRead", wireType) + } + m.TotalBytesRead = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalBytesRead |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytesWritten", wireType) + } + m.TotalBytesWritten = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalBytesWritten |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Error) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Error: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Module", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Module = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Logs = append(m.Logs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LogsTruncated", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LogsTruncated = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Job) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Job: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Job: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Stage", wireType) + } + m.Stage = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Stage |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlock", wireType) + } + m.StartBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StopBlock", wireType) + } + m.StopBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StopBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressBlocks", wireType) + } + m.ProgressBlocks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProgressBlocks |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DurationMs", wireType) + } + m.DurationMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DurationMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Stage) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Stage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Stage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Modules", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Modules = append(m.Modules, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CompletedRanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CompletedRanges = append(m.CompletedRanges, &BlockRange{}) + if err := m.CompletedRanges[len(m.CompletedRanges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ModuleStats) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ModuleStats: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ModuleStats: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalProcessedBlockCount", wireType) + } + m.TotalProcessedBlockCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalProcessedBlockCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalProcessingTimeMs", wireType) + } + m.TotalProcessingTimeMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalProcessingTimeMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExternalCallMetrics", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExternalCallMetrics = append(m.ExternalCallMetrics, &ExternalCallMetric{}) + if err := m.ExternalCallMetrics[len(m.ExternalCallMetrics)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalStoreOperationTimeMs", wireType) + } + m.TotalStoreOperationTimeMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalStoreOperationTimeMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalStoreReadCount", wireType) + } + m.TotalStoreReadCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalStoreReadCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalStoreWriteCount", wireType) + } + m.TotalStoreWriteCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalStoreWriteCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalStoreDeleteprefixCount", wireType) + } + m.TotalStoreDeleteprefixCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalStoreDeleteprefixCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreSizeBytes", wireType) + } + m.StoreSizeBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StoreSizeBytes |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalStoreMergingTimeMs", wireType) + } + m.TotalStoreMergingTimeMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalStoreMergingTimeMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreCurrentlyMerging", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.StoreCurrentlyMerging = bool(v != 0) + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HighestContiguousBlock", wireType) + } + m.HighestContiguousBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.HighestContiguousBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExternalCallMetric) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ExternalCallMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalCallMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + m.Count = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Count |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TimeMs", wireType) + } + m.TimeMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TimeMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreDelta) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: StoreDelta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreDelta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType) + } + m.Operation = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Operation |= StoreDelta_Operation(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Ordinal", wireType) + } + m.Ordinal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Ordinal |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OldValue", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OldValue = append(m.OldValue[:0], dAtA[iNdEx:postIndex]...) + if m.OldValue == nil { + m.OldValue = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewValue", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewValue = append(m.NewValue[:0], dAtA[iNdEx:postIndex]...) + if m.NewValue == nil { + m.NewValue = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlockRange) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: BlockRange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockRange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlock", wireType) + } + m.StartBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType) + } + m.EndBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/rpc/v3/service_grpc.pb.go b/pb/sf/substreams/rpc/v3/service_grpc.pb.go index e801d7c71..321d2bed5 100644 --- a/pb/sf/substreams/rpc/v3/service_grpc.pb.go +++ b/pb/sf/substreams/rpc/v3/service_grpc.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.6.0 +// - protoc-gen-go-grpc v1.5.1 // - protoc (unknown) // source: sf/substreams/rpc/v3/service.proto @@ -84,7 +84,7 @@ type StreamServer interface { type UnimplementedStreamServer struct{} func (UnimplementedStreamServer) Blocks(*Request, grpc.ServerStreamingServer[v2.Response]) error { - return status.Error(codes.Unimplemented, "method Blocks not implemented") + return status.Errorf(codes.Unimplemented, "method Blocks not implemented") } func (UnimplementedStreamServer) testEmbeddedByValue() {} @@ -96,7 +96,7 @@ type UnsafeStreamServer interface { } func RegisterStreamServer(s grpc.ServiceRegistrar, srv StreamServer) { - // If the following call panics, it indicates UnimplementedStreamServer was + // If the following call pancis, it indicates UnimplementedStreamServer was // embedded by pointer and is nil. This will cause panics if an // unimplemented method is ever invoked, so we test this at initialization // time to prevent it from happening at runtime later due to I/O. diff --git a/pb/sf/substreams/rpc/v3/service_vtproto.pb.go b/pb/sf/substreams/rpc/v3/service_vtproto.pb.go new file mode 100644 index 000000000..d6de0915e --- /dev/null +++ b/pb/sf/substreams/rpc/v3/service_vtproto.pb.go @@ -0,0 +1,912 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/rpc/v3/service.proto + +package pbsubstreamsrpcv3 + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + v1 "github.com/streamingfast/substreams/pb/sf/substreams/v1" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" +) + +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) +) + +func (m *Request) CloneVT() *Request { + if m == nil { + return (*Request)(nil) + } + r := new(Request) + r.StartBlockNum = m.StartBlockNum + r.StartCursor = m.StartCursor + r.StopBlockNum = m.StopBlockNum + r.FinalBlocksOnly = m.FinalBlocksOnly + r.ProductionMode = m.ProductionMode + r.OutputModule = m.OutputModule + r.Package = m.Package.CloneVT() + r.Network = m.Network + r.NoopMode = m.NoopMode + r.LimitProcessedBlocks = m.LimitProcessedBlocks + r.ProgressMessagesIntervalMs = m.ProgressMessagesIntervalMs + r.PartialBlocks = m.PartialBlocks + if rhs := m.Params; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Params = tmpContainer + } + if rhs := m.DebugInitialStoreSnapshotForModules; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.DebugInitialStoreSnapshotForModules = tmpContainer + } + if rhs := m.DevOutputModules; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.DevOutputModules = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Request) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *Request) EqualVT(that *Request) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.StartBlockNum != that.StartBlockNum { + return false + } + if this.StartCursor != that.StartCursor { + return false + } + if this.StopBlockNum != that.StopBlockNum { + return false + } + if this.FinalBlocksOnly != that.FinalBlocksOnly { + return false + } + if this.ProductionMode != that.ProductionMode { + return false + } + if this.OutputModule != that.OutputModule { + return false + } + if !this.Package.EqualVT(that.Package) { + return false + } + if len(this.Params) != len(that.Params) { + return false + } + for i, vx := range this.Params { + vy, ok := that.Params[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + if this.Network != that.Network { + return false + } + if len(this.DebugInitialStoreSnapshotForModules) != len(that.DebugInitialStoreSnapshotForModules) { + return false + } + for i, vx := range this.DebugInitialStoreSnapshotForModules { + vy := that.DebugInitialStoreSnapshotForModules[i] + if vx != vy { + return false + } + } + if this.NoopMode != that.NoopMode { + return false + } + if this.LimitProcessedBlocks != that.LimitProcessedBlocks { + return false + } + if len(this.DevOutputModules) != len(that.DevOutputModules) { + return false + } + for i, vx := range this.DevOutputModules { + vy := that.DevOutputModules[i] + if vx != vy { + return false + } + } + if this.ProgressMessagesIntervalMs != that.ProgressMessagesIntervalMs { + return false + } + if this.PartialBlocks != that.PartialBlocks { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Request) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Request) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *Request) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Request) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Request) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PartialBlocks { + i-- + if m.PartialBlocks { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x80 + } + if m.ProgressMessagesIntervalMs != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ProgressMessagesIntervalMs)) + i-- + dAtA[i] = 0x70 + } + if len(m.DevOutputModules) > 0 { + for iNdEx := len(m.DevOutputModules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DevOutputModules[iNdEx]) + copy(dAtA[i:], m.DevOutputModules[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DevOutputModules[iNdEx]))) + i-- + dAtA[i] = 0x6a + } + } + if m.LimitProcessedBlocks != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.LimitProcessedBlocks)) + i-- + dAtA[i] = 0x60 + } + if m.NoopMode { + i-- + if m.NoopMode { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 + } + if len(m.DebugInitialStoreSnapshotForModules) > 0 { + for iNdEx := len(m.DebugInitialStoreSnapshotForModules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DebugInitialStoreSnapshotForModules[iNdEx]) + copy(dAtA[i:], m.DebugInitialStoreSnapshotForModules[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DebugInitialStoreSnapshotForModules[iNdEx]))) + i-- + dAtA[i] = 0x52 + } + } + if len(m.Network) > 0 { + i -= len(m.Network) + copy(dAtA[i:], m.Network) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Network))) + i-- + dAtA[i] = 0x4a + } + if len(m.Params) > 0 { + for k := range m.Params { + v := m.Params[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x42 + } + } + if m.Package != nil { + size, err := m.Package.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.OutputModule) > 0 { + i -= len(m.OutputModule) + copy(dAtA[i:], m.OutputModule) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OutputModule))) + i-- + dAtA[i] = 0x32 + } + if m.ProductionMode { + i-- + if m.ProductionMode { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if m.FinalBlocksOnly { + i-- + if m.FinalBlocksOnly { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.StopBlockNum != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StopBlockNum)) + i-- + dAtA[i] = 0x18 + } + if len(m.StartCursor) > 0 { + i -= len(m.StartCursor) + copy(dAtA[i:], m.StartCursor) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StartCursor))) + i-- + dAtA[i] = 0x12 + } + if m.StartBlockNum != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StartBlockNum)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Request) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StartBlockNum != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StartBlockNum)) + } + l = len(m.StartCursor) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.StopBlockNum != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.StopBlockNum)) + } + if m.FinalBlocksOnly { + n += 2 + } + if m.ProductionMode { + n += 2 + } + l = len(m.OutputModule) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Package != nil { + l = m.Package.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Params) > 0 { + for k, v := range m.Params { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + l = len(m.Network) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.DebugInitialStoreSnapshotForModules) > 0 { + for _, s := range m.DebugInitialStoreSnapshotForModules { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.NoopMode { + n += 2 + } + if m.LimitProcessedBlocks != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.LimitProcessedBlocks)) + } + if len(m.DevOutputModules) > 0 { + for _, s := range m.DevOutputModules { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.ProgressMessagesIntervalMs != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.ProgressMessagesIntervalMs)) + } + if m.PartialBlocks { + n += 3 + } + n += len(m.unknownFields) + return n +} + +func (m *Request) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Request: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlockNum", wireType) + } + m.StartBlockNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlockNum |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartCursor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StartCursor = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StopBlockNum", wireType) + } + m.StopBlockNum = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StopBlockNum |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FinalBlocksOnly", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.FinalBlocksOnly = bool(v != 0) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProductionMode", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ProductionMode = bool(v != 0) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputModule", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputModule = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Package", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Package == nil { + m.Package = &v1.Package{} + } + if err := m.Package.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + 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 protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Params == nil { + m.Params = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Params[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Network = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebugInitialStoreSnapshotForModules", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DebugInitialStoreSnapshotForModules = append(m.DebugInitialStoreSnapshotForModules, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NoopMode", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NoopMode = bool(v != 0) + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LimitProcessedBlocks", wireType) + } + m.LimitProcessedBlocks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LimitProcessedBlocks |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DevOutputModules", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DevOutputModules = append(m.DevOutputModules, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProgressMessagesIntervalMs", wireType) + } + m.ProgressMessagesIntervalMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProgressMessagesIntervalMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PartialBlocks", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.PartialBlocks = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/sink/service/v1/service_grpc.pb.go b/pb/sf/substreams/sink/service/v1/service_grpc.pb.go index f1dd1f8d3..3c2a40116 100644 --- a/pb/sf/substreams/sink/service/v1/service_grpc.pb.go +++ b/pb/sf/substreams/sink/service/v1/service_grpc.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.6.0 +// - protoc-gen-go-grpc v1.5.1 // - protoc (unknown) // source: sf/substreams/sink/service/v1/service.proto @@ -153,28 +153,28 @@ type ProviderServer interface { type UnimplementedProviderServer struct{} func (UnimplementedProviderServer) Deploy(context.Context, *DeployRequest) (*DeployResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Deploy not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Deploy not implemented") } func (UnimplementedProviderServer) Update(context.Context, *UpdateRequest) (*UpdateResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Update not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") } func (UnimplementedProviderServer) Info(context.Context, *InfoRequest) (*InfoResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Info not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Info not implemented") } func (UnimplementedProviderServer) List(context.Context, *ListRequest) (*ListResponse, error) { - return nil, status.Error(codes.Unimplemented, "method List not implemented") + return nil, status.Errorf(codes.Unimplemented, "method List not implemented") } func (UnimplementedProviderServer) Pause(context.Context, *PauseRequest) (*PauseResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Pause not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Pause not implemented") } func (UnimplementedProviderServer) Stop(context.Context, *StopRequest) (*StopResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Stop not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented") } func (UnimplementedProviderServer) Resume(context.Context, *ResumeRequest) (*ResumeResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Resume not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Resume not implemented") } func (UnimplementedProviderServer) Remove(context.Context, *RemoveRequest) (*RemoveResponse, error) { - return nil, status.Error(codes.Unimplemented, "method Remove not implemented") + return nil, status.Errorf(codes.Unimplemented, "method Remove not implemented") } func (UnimplementedProviderServer) testEmbeddedByValue() {} @@ -186,7 +186,7 @@ type UnsafeProviderServer interface { } func RegisterProviderServer(s grpc.ServiceRegistrar, srv ProviderServer) { - // If the following call panics, it indicates UnimplementedProviderServer was + // If the following call pancis, it indicates UnimplementedProviderServer was // embedded by pointer and is nil. This will cause panics if an // unimplemented method is ever invoked, so we test this at initialization // time to prevent it from happening at runtime later due to I/O. diff --git a/pb/sf/substreams/sink/service/v1/service_vtproto.pb.go b/pb/sf/substreams/sink/service/v1/service_vtproto.pb.go new file mode 100644 index 000000000..870479716 --- /dev/null +++ b/pb/sf/substreams/sink/service/v1/service_vtproto.pb.go @@ -0,0 +1,5017 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/sink/service/v1/service.proto + +package pbsinksvc + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + v1 "github.com/streamingfast/substreams/pb/sf/substreams/v1" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" +) + +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) +) + +func (m *DeployRequest) CloneVT() *DeployRequest { + if m == nil { + return (*DeployRequest)(nil) + } + r := new(DeployRequest) + r.SubstreamsPackage = m.SubstreamsPackage.CloneVT() + r.DevelopmentMode = m.DevelopmentMode + if rhs := m.Parameters; rhs != nil { + tmpContainer := make([]*Parameter, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Parameters = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeployRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Parameter) CloneVT() *Parameter { + if m == nil { + return (*Parameter)(nil) + } + r := new(Parameter) + r.Key = m.Key + r.Value = m.Value + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Parameter) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeployResponse) CloneVT() *DeployResponse { + if m == nil { + return (*DeployResponse)(nil) + } + r := new(DeployResponse) + r.Status = m.Status + r.DeploymentId = m.DeploymentId + r.Reason = m.Reason + r.Motd = m.Motd + if rhs := m.Services; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Services = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeployResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateRequest) CloneVT() *UpdateRequest { + if m == nil { + return (*UpdateRequest)(nil) + } + r := new(UpdateRequest) + r.SubstreamsPackage = m.SubstreamsPackage.CloneVT() + r.DeploymentId = m.DeploymentId + r.Reset_ = m.Reset_ + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateResponse) CloneVT() *UpdateResponse { + if m == nil { + return (*UpdateResponse)(nil) + } + r := new(UpdateResponse) + r.Status = m.Status + r.Reason = m.Reason + r.Motd = m.Motd + if rhs := m.Services; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Services = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InfoRequest) CloneVT() *InfoRequest { + if m == nil { + return (*InfoRequest)(nil) + } + r := new(InfoRequest) + r.DeploymentId = m.DeploymentId + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InfoRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InfoResponse) CloneVT() *InfoResponse { + if m == nil { + return (*InfoResponse)(nil) + } + r := new(InfoResponse) + r.Status = m.Status + r.Reason = m.Reason + r.PackageInfo = m.PackageInfo.CloneVT() + r.Progress = m.Progress.CloneVT() + r.Motd = m.Motd + if rhs := m.Services; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Services = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InfoResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SinkProgress) CloneVT() *SinkProgress { + if m == nil { + return (*SinkProgress)(nil) + } + r := new(SinkProgress) + r.LastProcessedBlock = m.LastProcessedBlock + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SinkProgress) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PackageInfo) CloneVT() *PackageInfo { + if m == nil { + return (*PackageInfo)(nil) + } + r := new(PackageInfo) + r.Name = m.Name + r.Version = m.Version + r.OutputModuleName = m.OutputModuleName + r.OutputModuleHash = m.OutputModuleHash + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PackageInfo) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ListRequest) CloneVT() *ListRequest { + if m == nil { + return (*ListRequest)(nil) + } + r := new(ListRequest) + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ListRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ListResponse) CloneVT() *ListResponse { + if m == nil { + return (*ListResponse)(nil) + } + r := new(ListResponse) + if rhs := m.Deployments; rhs != nil { + tmpContainer := make([]*DeploymentWithStatus, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Deployments = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ListResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeploymentWithStatus) CloneVT() *DeploymentWithStatus { + if m == nil { + return (*DeploymentWithStatus)(nil) + } + r := new(DeploymentWithStatus) + r.Id = m.Id + r.Status = m.Status + r.Reason = m.Reason + r.PackageInfo = m.PackageInfo.CloneVT() + r.Progress = m.Progress.CloneVT() + r.Motd = m.Motd + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeploymentWithStatus) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveRequest) CloneVT() *RemoveRequest { + if m == nil { + return (*RemoveRequest)(nil) + } + r := new(RemoveRequest) + r.DeploymentId = m.DeploymentId + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveResponse) CloneVT() *RemoveResponse { + if m == nil { + return (*RemoveResponse)(nil) + } + r := new(RemoveResponse) + r.PreviousStatus = m.PreviousStatus + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PauseRequest) CloneVT() *PauseRequest { + if m == nil { + return (*PauseRequest)(nil) + } + r := new(PauseRequest) + r.DeploymentId = m.DeploymentId + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PauseRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PauseResponse) CloneVT() *PauseResponse { + if m == nil { + return (*PauseResponse)(nil) + } + r := new(PauseResponse) + r.PreviousStatus = m.PreviousStatus + r.NewStatus = m.NewStatus + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PauseResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopRequest) CloneVT() *StopRequest { + if m == nil { + return (*StopRequest)(nil) + } + r := new(StopRequest) + r.DeploymentId = m.DeploymentId + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopResponse) CloneVT() *StopResponse { + if m == nil { + return (*StopResponse)(nil) + } + r := new(StopResponse) + r.PreviousStatus = m.PreviousStatus + r.NewStatus = m.NewStatus + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResumeRequest) CloneVT() *ResumeRequest { + if m == nil { + return (*ResumeRequest)(nil) + } + r := new(ResumeRequest) + r.DeploymentId = m.DeploymentId + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResumeRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResumeResponse) CloneVT() *ResumeResponse { + if m == nil { + return (*ResumeResponse)(nil) + } + r := new(ResumeResponse) + r.PreviousStatus = m.PreviousStatus + r.NewStatus = m.NewStatus + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResumeResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *DeployRequest) EqualVT(that *DeployRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if !this.SubstreamsPackage.EqualVT(that.SubstreamsPackage) { + return false + } + if this.DevelopmentMode != that.DevelopmentMode { + return false + } + if len(this.Parameters) != len(that.Parameters) { + return false + } + for i, vx := range this.Parameters { + vy := that.Parameters[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Parameter{} + } + if q == nil { + q = &Parameter{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *DeployRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*DeployRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Parameter) EqualVT(that *Parameter) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Key != that.Key { + return false + } + if this.Value != that.Value { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Parameter) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Parameter) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *DeployResponse) EqualVT(that *DeployResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Status != that.Status { + return false + } + if this.DeploymentId != that.DeploymentId { + return false + } + if len(this.Services) != len(that.Services) { + return false + } + for i, vx := range this.Services { + vy, ok := that.Services[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + if this.Reason != that.Reason { + return false + } + if this.Motd != that.Motd { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *DeployResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*DeployResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UpdateRequest) EqualVT(that *UpdateRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if !this.SubstreamsPackage.EqualVT(that.SubstreamsPackage) { + return false + } + if this.DeploymentId != that.DeploymentId { + return false + } + if this.Reset_ != that.Reset_ { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UpdateRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UpdateRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *UpdateResponse) EqualVT(that *UpdateResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Status != that.Status { + return false + } + if len(this.Services) != len(that.Services) { + return false + } + for i, vx := range this.Services { + vy, ok := that.Services[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + if this.Reason != that.Reason { + return false + } + if this.Motd != that.Motd { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *UpdateResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*UpdateResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *InfoRequest) EqualVT(that *InfoRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.DeploymentId != that.DeploymentId { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *InfoRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*InfoRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *InfoResponse) EqualVT(that *InfoResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Status != that.Status { + return false + } + if len(this.Services) != len(that.Services) { + return false + } + for i, vx := range this.Services { + vy, ok := that.Services[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + if this.Reason != that.Reason { + return false + } + if !this.PackageInfo.EqualVT(that.PackageInfo) { + return false + } + if !this.Progress.EqualVT(that.Progress) { + return false + } + if this.Motd != that.Motd { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *InfoResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*InfoResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *SinkProgress) EqualVT(that *SinkProgress) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.LastProcessedBlock != that.LastProcessedBlock { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *SinkProgress) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*SinkProgress) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *PackageInfo) EqualVT(that *PackageInfo) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Name != that.Name { + return false + } + if this.Version != that.Version { + return false + } + if this.OutputModuleName != that.OutputModuleName { + return false + } + if this.OutputModuleHash != that.OutputModuleHash { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *PackageInfo) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*PackageInfo) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ListRequest) EqualVT(that *ListRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ListRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ListRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ListResponse) EqualVT(that *ListResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Deployments) != len(that.Deployments) { + return false + } + for i, vx := range this.Deployments { + vy := that.Deployments[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &DeploymentWithStatus{} + } + if q == nil { + q = &DeploymentWithStatus{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ListResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ListResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *DeploymentWithStatus) EqualVT(that *DeploymentWithStatus) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Id != that.Id { + return false + } + if this.Status != that.Status { + return false + } + if this.Reason != that.Reason { + return false + } + if !this.PackageInfo.EqualVT(that.PackageInfo) { + return false + } + if !this.Progress.EqualVT(that.Progress) { + return false + } + if this.Motd != that.Motd { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *DeploymentWithStatus) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*DeploymentWithStatus) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *RemoveRequest) EqualVT(that *RemoveRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.DeploymentId != that.DeploymentId { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *RemoveRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*RemoveRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *RemoveResponse) EqualVT(that *RemoveResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.PreviousStatus != that.PreviousStatus { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *RemoveResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*RemoveResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *PauseRequest) EqualVT(that *PauseRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.DeploymentId != that.DeploymentId { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *PauseRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*PauseRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *PauseResponse) EqualVT(that *PauseResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.PreviousStatus != that.PreviousStatus { + return false + } + if this.NewStatus != that.NewStatus { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *PauseResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*PauseResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *StopRequest) EqualVT(that *StopRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.DeploymentId != that.DeploymentId { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *StopRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*StopRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *StopResponse) EqualVT(that *StopResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.PreviousStatus != that.PreviousStatus { + return false + } + if this.NewStatus != that.NewStatus { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *StopResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*StopResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ResumeRequest) EqualVT(that *ResumeRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.DeploymentId != that.DeploymentId { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ResumeRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ResumeRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ResumeResponse) EqualVT(that *ResumeResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.PreviousStatus != that.PreviousStatus { + return false + } + if this.NewStatus != that.NewStatus { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ResumeResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ResumeResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *DeployRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeployRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DeployRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Parameters) > 0 { + for iNdEx := len(m.Parameters) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Parameters[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if m.DevelopmentMode { + i-- + if m.DevelopmentMode { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.SubstreamsPackage != nil { + size, err := m.SubstreamsPackage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Parameter) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Parameter) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Parameter) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DeployResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeployResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DeployResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Motd) > 0 { + i -= len(m.Motd) + copy(dAtA[i:], m.Motd) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Motd))) + i-- + dAtA[i] = 0x2a + } + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x22 + } + if len(m.Services) > 0 { + for k := range m.Services { + v := m.Services[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.DeploymentId) > 0 { + i -= len(m.DeploymentId) + copy(dAtA[i:], m.DeploymentId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeploymentId))) + i-- + dAtA[i] = 0x12 + } + if m.Status != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Status)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *UpdateRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpdateRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UpdateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Reset_ { + i-- + if m.Reset_ { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.DeploymentId) > 0 { + i -= len(m.DeploymentId) + copy(dAtA[i:], m.DeploymentId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeploymentId))) + i-- + dAtA[i] = 0x12 + } + if m.SubstreamsPackage != nil { + size, err := m.SubstreamsPackage.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UpdateResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpdateResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *UpdateResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Motd) > 0 { + i -= len(m.Motd) + copy(dAtA[i:], m.Motd) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Motd))) + i-- + dAtA[i] = 0x22 + } + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x1a + } + if len(m.Services) > 0 { + for k := range m.Services { + v := m.Services[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if m.Status != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Status)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *InfoRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InfoRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *InfoRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.DeploymentId) > 0 { + i -= len(m.DeploymentId) + copy(dAtA[i:], m.DeploymentId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeploymentId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *InfoResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InfoResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *InfoResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Motd) > 0 { + i -= len(m.Motd) + copy(dAtA[i:], m.Motd) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Motd))) + i-- + dAtA[i] = 0x32 + } + if m.Progress != nil { + size, err := m.Progress.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.PackageInfo != nil { + size, err := m.PackageInfo.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x1a + } + if len(m.Services) > 0 { + for k := range m.Services { + v := m.Services[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if m.Status != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Status)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SinkProgress) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SinkProgress) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *SinkProgress) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.LastProcessedBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.LastProcessedBlock)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *PackageInfo) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PackageInfo) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *PackageInfo) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.OutputModuleHash) > 0 { + i -= len(m.OutputModuleHash) + copy(dAtA[i:], m.OutputModuleHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OutputModuleHash))) + i-- + dAtA[i] = 0x22 + } + if len(m.OutputModuleName) > 0 { + i -= len(m.OutputModuleName) + copy(dAtA[i:], m.OutputModuleName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OutputModuleName))) + i-- + dAtA[i] = 0x1a + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ListRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ListRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ListRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *ListResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ListResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ListResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Deployments) > 0 { + for iNdEx := len(m.Deployments) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Deployments[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *DeploymentWithStatus) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeploymentWithStatus) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *DeploymentWithStatus) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Motd) > 0 { + i -= len(m.Motd) + copy(dAtA[i:], m.Motd) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Motd))) + i-- + dAtA[i] = 0x32 + } + if m.Progress != nil { + size, err := m.Progress.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.PackageInfo != nil { + size, err := m.PackageInfo.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Reason))) + i-- + dAtA[i] = 0x1a + } + if m.Status != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Status)) + i-- + dAtA[i] = 0x10 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RemoveRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RemoveRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RemoveRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.DeploymentId) > 0 { + i -= len(m.DeploymentId) + copy(dAtA[i:], m.DeploymentId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeploymentId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RemoveResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RemoveResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *RemoveResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.PreviousStatus != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PreviousStatus)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *PauseRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PauseRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *PauseRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.DeploymentId) > 0 { + i -= len(m.DeploymentId) + copy(dAtA[i:], m.DeploymentId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeploymentId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PauseResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PauseResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *PauseResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.NewStatus != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NewStatus)) + i-- + dAtA[i] = 0x10 + } + if m.PreviousStatus != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PreviousStatus)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *StopRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StopRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *StopRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.DeploymentId) > 0 { + i -= len(m.DeploymentId) + copy(dAtA[i:], m.DeploymentId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeploymentId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StopResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StopResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *StopResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.NewStatus != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NewStatus)) + i-- + dAtA[i] = 0x10 + } + if m.PreviousStatus != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PreviousStatus)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ResumeRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResumeRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ResumeRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.DeploymentId) > 0 { + i -= len(m.DeploymentId) + copy(dAtA[i:], m.DeploymentId) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeploymentId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ResumeResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ResumeResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ResumeResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.NewStatus != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NewStatus)) + i-- + dAtA[i] = 0x10 + } + if m.PreviousStatus != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PreviousStatus)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *DeployRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SubstreamsPackage != nil { + l = m.SubstreamsPackage.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.DevelopmentMode { + n += 2 + } + if len(m.Parameters) > 0 { + for _, e := range m.Parameters { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *Parameter) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *DeployResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Status != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Status)) + } + l = len(m.DeploymentId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Services) > 0 { + for k, v := range m.Services { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + l = len(m.Reason) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Motd) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *UpdateRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SubstreamsPackage != nil { + l = m.SubstreamsPackage.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.DeploymentId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Reset_ { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *UpdateResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Status != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Status)) + } + if len(m.Services) > 0 { + for k, v := range m.Services { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + l = len(m.Reason) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Motd) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *InfoRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DeploymentId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *InfoResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Status != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Status)) + } + if len(m.Services) > 0 { + for k, v := range m.Services { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + l = len(m.Reason) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PackageInfo != nil { + l = m.PackageInfo.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Progress != nil { + l = m.Progress.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Motd) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *SinkProgress) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LastProcessedBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.LastProcessedBlock)) + } + n += len(m.unknownFields) + return n +} + +func (m *PackageInfo) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.OutputModuleName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.OutputModuleHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ListRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *ListResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Deployments) > 0 { + for _, e := range m.Deployments { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *DeploymentWithStatus) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Status != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Status)) + } + l = len(m.Reason) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.PackageInfo != nil { + l = m.PackageInfo.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Progress != nil { + l = m.Progress.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Motd) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *RemoveRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DeploymentId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *RemoveResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PreviousStatus != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.PreviousStatus)) + } + n += len(m.unknownFields) + return n +} + +func (m *PauseRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DeploymentId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *PauseResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PreviousStatus != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.PreviousStatus)) + } + if m.NewStatus != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.NewStatus)) + } + n += len(m.unknownFields) + return n +} + +func (m *StopRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DeploymentId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *StopResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PreviousStatus != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.PreviousStatus)) + } + if m.NewStatus != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.NewStatus)) + } + n += len(m.unknownFields) + return n +} + +func (m *ResumeRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DeploymentId) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ResumeResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PreviousStatus != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.PreviousStatus)) + } + if m.NewStatus != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.NewStatus)) + } + n += len(m.unknownFields) + return n +} + +func (m *DeployRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: DeployRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeployRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubstreamsPackage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SubstreamsPackage == nil { + m.SubstreamsPackage = &v1.Package{} + } + if err := m.SubstreamsPackage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DevelopmentMode", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DevelopmentMode = bool(v != 0) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Parameters = append(m.Parameters, &Parameter{}) + if err := m.Parameters[len(m.Parameters)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Parameter) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Parameter: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Parameter: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeployResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: DeployResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeployResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + m.Status = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Status |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeploymentId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeploymentId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Services == nil { + m.Services = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Services[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Motd", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Motd = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UpdateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubstreamsPackage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SubstreamsPackage == nil { + m.SubstreamsPackage = &v1.Package{} + } + if err := m.SubstreamsPackage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeploymentId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeploymentId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Reset_", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Reset_ = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: UpdateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + m.Status = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Status |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Services == nil { + m.Services = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Services[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Motd", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Motd = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InfoRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: InfoRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeploymentId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeploymentId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InfoResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: InfoResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + m.Status = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Status |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Services == nil { + m.Services = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Services[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PackageInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PackageInfo == nil { + m.PackageInfo = &PackageInfo{} + } + if err := m.PackageInfo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Progress == nil { + m.Progress = &SinkProgress{} + } + if err := m.Progress.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Motd", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Motd = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SinkProgress) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: SinkProgress: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SinkProgress: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastProcessedBlock", wireType) + } + m.LastProcessedBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastProcessedBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PackageInfo) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: PackageInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PackageInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputModuleName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputModuleName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputModuleHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputModuleHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ListRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ListRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ListRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ListResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ListResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ListResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Deployments", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Deployments = append(m.Deployments, &DeploymentWithStatus{}) + if err := m.Deployments[len(m.Deployments)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeploymentWithStatus) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: DeploymentWithStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeploymentWithStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + m.Status = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Status |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PackageInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PackageInfo == nil { + m.PackageInfo = &PackageInfo{} + } + if err := m.PackageInfo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Progress == nil { + m.Progress = &SinkProgress{} + } + if err := m.Progress.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Motd", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Motd = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RemoveRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: RemoveRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RemoveRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeploymentId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeploymentId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RemoveResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: RemoveResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RemoveResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviousStatus", wireType) + } + m.PreviousStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PreviousStatus |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PauseRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: PauseRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PauseRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeploymentId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeploymentId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PauseResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: PauseResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PauseResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviousStatus", wireType) + } + m.PreviousStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PreviousStatus |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewStatus", wireType) + } + m.NewStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewStatus |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StopRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: StopRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StopRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeploymentId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeploymentId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StopResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: StopResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StopResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviousStatus", wireType) + } + m.PreviousStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PreviousStatus |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewStatus", wireType) + } + m.NewStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewStatus |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResumeRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ResumeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResumeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeploymentId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeploymentId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResumeResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ResumeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResumeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviousStatus", wireType) + } + m.PreviousStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PreviousStatus |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewStatus", wireType) + } + m.NewStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewStatus |= DeploymentStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/v1/clock_vtproto.pb.go b/pb/sf/substreams/v1/clock_vtproto.pb.go new file mode 100644 index 000000000..0412c1050 --- /dev/null +++ b/pb/sf/substreams/v1/clock_vtproto.pb.go @@ -0,0 +1,485 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/v1/clock.proto + +package pbsubstreams + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + timestamppb1 "github.com/planetscale/vtprotobuf/types/known/timestamppb" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + io "io" +) + +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) +) + +func (m *Clock) CloneVT() *Clock { + if m == nil { + return (*Clock)(nil) + } + r := new(Clock) + r.Id = m.Id + r.Number = m.Number + r.Timestamp = (*timestamppb.Timestamp)((*timestamppb1.Timestamp)(m.Timestamp).CloneVT()) + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Clock) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BlockRef) CloneVT() *BlockRef { + if m == nil { + return (*BlockRef)(nil) + } + r := new(BlockRef) + r.Id = m.Id + r.Number = m.Number + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BlockRef) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *Clock) EqualVT(that *Clock) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Id != that.Id { + return false + } + if this.Number != that.Number { + return false + } + if !(*timestamppb1.Timestamp)(this.Timestamp).EqualVT((*timestamppb1.Timestamp)(that.Timestamp)) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Clock) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Clock) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *BlockRef) EqualVT(that *BlockRef) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Id != that.Id { + return false + } + if this.Number != that.Number { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *BlockRef) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*BlockRef) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *Clock) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Clock) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Clock) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Timestamp != nil { + size, err := (*timestamppb1.Timestamp)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Number != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Number)) + i-- + dAtA[i] = 0x10 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlockRef) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BlockRef) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *BlockRef) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Number != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Number)) + i-- + dAtA[i] = 0x10 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Clock) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Number != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Number)) + } + if m.Timestamp != nil { + l = (*timestamppb1.Timestamp)(m.Timestamp).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *BlockRef) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Number != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Number)) + } + n += len(m.unknownFields) + return n +} + +func (m *Clock) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Clock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Clock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + m.Number = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Number |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = ×tamppb.Timestamp{} + } + if err := (*timestamppb1.Timestamp)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BlockRef) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: BlockRef: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockRef: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + m.Number = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Number |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/v1/deltas_vtproto.pb.go b/pb/sf/substreams/v1/deltas_vtproto.pb.go new file mode 100644 index 000000000..48b303227 --- /dev/null +++ b/pb/sf/substreams/v1/deltas_vtproto.pb.go @@ -0,0 +1,564 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/v1/deltas.proto + +package pbsubstreams + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" +) + +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) +) + +func (m *StoreDeltas) CloneVT() *StoreDeltas { + if m == nil { + return (*StoreDeltas)(nil) + } + r := new(StoreDeltas) + if rhs := m.StoreDeltas; rhs != nil { + tmpContainer := make([]*StoreDelta, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.StoreDeltas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StoreDeltas) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StoreDelta) CloneVT() *StoreDelta { + if m == nil { + return (*StoreDelta)(nil) + } + r := new(StoreDelta) + r.Operation = m.Operation + r.Ordinal = m.Ordinal + r.Key = m.Key + if rhs := m.OldValue; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.OldValue = tmpBytes + } + if rhs := m.NewValue; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.NewValue = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StoreDelta) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *StoreDeltas) EqualVT(that *StoreDeltas) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.StoreDeltas) != len(that.StoreDeltas) { + return false + } + for i, vx := range this.StoreDeltas { + vy := that.StoreDeltas[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &StoreDelta{} + } + if q == nil { + q = &StoreDelta{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *StoreDeltas) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*StoreDeltas) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *StoreDelta) EqualVT(that *StoreDelta) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Operation != that.Operation { + return false + } + if this.Ordinal != that.Ordinal { + return false + } + if this.Key != that.Key { + return false + } + if string(this.OldValue) != string(that.OldValue) { + return false + } + if string(this.NewValue) != string(that.NewValue) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *StoreDelta) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*StoreDelta) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *StoreDeltas) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreDeltas) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *StoreDeltas) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.StoreDeltas) > 0 { + for iNdEx := len(m.StoreDeltas) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.StoreDeltas[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *StoreDelta) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StoreDelta) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *StoreDelta) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.NewValue) > 0 { + i -= len(m.NewValue) + copy(dAtA[i:], m.NewValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewValue))) + i-- + dAtA[i] = 0x2a + } + if len(m.OldValue) > 0 { + i -= len(m.OldValue) + copy(dAtA[i:], m.OldValue) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldValue))) + i-- + dAtA[i] = 0x22 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x1a + } + if m.Ordinal != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Ordinal)) + i-- + dAtA[i] = 0x10 + } + if m.Operation != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Operation)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *StoreDeltas) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.StoreDeltas) > 0 { + for _, e := range m.StoreDeltas { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *StoreDelta) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Operation != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Operation)) + } + if m.Ordinal != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Ordinal)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.OldValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.NewValue) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *StoreDeltas) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: StoreDeltas: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreDeltas: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreDeltas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StoreDeltas = append(m.StoreDeltas, &StoreDelta{}) + if err := m.StoreDeltas[len(m.StoreDeltas)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreDelta) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: StoreDelta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreDelta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType) + } + m.Operation = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Operation |= StoreDelta_Operation(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Ordinal", wireType) + } + m.Ordinal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Ordinal |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OldValue", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OldValue = append(m.OldValue[:0], dAtA[iNdEx:postIndex]...) + if m.OldValue == nil { + m.OldValue = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewValue", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewValue = append(m.NewValue[:0], dAtA[iNdEx:postIndex]...) + if m.NewValue == nil { + m.NewValue = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/v1/modules_vtproto.pb.go b/pb/sf/substreams/v1/modules_vtproto.pb.go new file mode 100644 index 000000000..47db9b0e7 --- /dev/null +++ b/pb/sf/substreams/v1/modules_vtproto.pb.go @@ -0,0 +1,4152 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/v1/modules.proto + +package pbsubstreams + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" +) + +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) +) + +func (m *Modules) CloneVT() *Modules { + if m == nil { + return (*Modules)(nil) + } + r := new(Modules) + if rhs := m.Modules; rhs != nil { + tmpContainer := make([]*Module, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Modules = tmpContainer + } + if rhs := m.Binaries; rhs != nil { + tmpContainer := make([]*Binary, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Binaries = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Modules) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Binary) CloneVT() *Binary { + if m == nil { + return (*Binary)(nil) + } + r := new(Binary) + r.Type = m.Type + if rhs := m.Content; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Content = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Binary) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_BlockFilter) CloneVT() *Module_BlockFilter { + if m == nil { + return (*Module_BlockFilter)(nil) + } + r := new(Module_BlockFilter) + r.Module = m.Module + if m.Query != nil { + r.Query = m.Query.(interface { + CloneVT() isModule_BlockFilter_Query + }).CloneVT() + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_BlockFilter) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_BlockFilter_QueryString) CloneVT() isModule_BlockFilter_Query { + if m == nil { + return (*Module_BlockFilter_QueryString)(nil) + } + r := new(Module_BlockFilter_QueryString) + r.QueryString = m.QueryString + return r +} + +func (m *Module_BlockFilter_QueryFromParams) CloneVT() isModule_BlockFilter_Query { + if m == nil { + return (*Module_BlockFilter_QueryFromParams)(nil) + } + r := new(Module_BlockFilter_QueryFromParams) + r.QueryFromParams = m.QueryFromParams.CloneVT() + return r +} + +func (m *Module_QueryFromParams) CloneVT() *Module_QueryFromParams { + if m == nil { + return (*Module_QueryFromParams)(nil) + } + r := new(Module_QueryFromParams) + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_QueryFromParams) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_KindMap) CloneVT() *Module_KindMap { + if m == nil { + return (*Module_KindMap)(nil) + } + r := new(Module_KindMap) + r.OutputType = m.OutputType + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_KindMap) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_KindStore) CloneVT() *Module_KindStore { + if m == nil { + return (*Module_KindStore)(nil) + } + r := new(Module_KindStore) + r.UpdatePolicy = m.UpdatePolicy + r.ValueType = m.ValueType + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_KindStore) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_KindBlockIndex) CloneVT() *Module_KindBlockIndex { + if m == nil { + return (*Module_KindBlockIndex)(nil) + } + r := new(Module_KindBlockIndex) + r.OutputType = m.OutputType + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_KindBlockIndex) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_FoundationalStore) CloneVT() *Module_FoundationalStore { + if m == nil { + return (*Module_FoundationalStore)(nil) + } + r := new(Module_FoundationalStore) + r.Identifier = m.Identifier + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_FoundationalStore) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_Input_Source) CloneVT() *Module_Input_Source { + if m == nil { + return (*Module_Input_Source)(nil) + } + r := new(Module_Input_Source) + r.Type = m.Type + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_Input_Source) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_Input_Map) CloneVT() *Module_Input_Map { + if m == nil { + return (*Module_Input_Map)(nil) + } + r := new(Module_Input_Map) + r.ModuleName = m.ModuleName + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_Input_Map) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_Input_Store) CloneVT() *Module_Input_Store { + if m == nil { + return (*Module_Input_Store)(nil) + } + r := new(Module_Input_Store) + r.ModuleName = m.ModuleName + r.Mode = m.Mode + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_Input_Store) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_Input_Params) CloneVT() *Module_Input_Params { + if m == nil { + return (*Module_Input_Params)(nil) + } + r := new(Module_Input_Params) + r.Value = m.Value + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_Input_Params) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_Input) CloneVT() *Module_Input { + if m == nil { + return (*Module_Input)(nil) + } + r := new(Module_Input) + if m.Input != nil { + r.Input = m.Input.(interface{ CloneVT() isModule_Input_Input }).CloneVT() + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_Input) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_Input_Source_) CloneVT() isModule_Input_Input { + if m == nil { + return (*Module_Input_Source_)(nil) + } + r := new(Module_Input_Source_) + r.Source = m.Source.CloneVT() + return r +} + +func (m *Module_Input_Map_) CloneVT() isModule_Input_Input { + if m == nil { + return (*Module_Input_Map_)(nil) + } + r := new(Module_Input_Map_) + r.Map = m.Map.CloneVT() + return r +} + +func (m *Module_Input_Store_) CloneVT() isModule_Input_Input { + if m == nil { + return (*Module_Input_Store_)(nil) + } + r := new(Module_Input_Store_) + r.Store = m.Store.CloneVT() + return r +} + +func (m *Module_Input_Params_) CloneVT() isModule_Input_Input { + if m == nil { + return (*Module_Input_Params_)(nil) + } + r := new(Module_Input_Params_) + r.Params = m.Params.CloneVT() + return r +} + +func (m *Module_Input_FoundationalStore) CloneVT() isModule_Input_Input { + if m == nil { + return (*Module_Input_FoundationalStore)(nil) + } + r := new(Module_Input_FoundationalStore) + r.FoundationalStore = m.FoundationalStore.CloneVT() + return r +} + +func (m *Module_Output) CloneVT() *Module_Output { + if m == nil { + return (*Module_Output)(nil) + } + r := new(Module_Output) + r.Type = m.Type + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module_Output) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module) CloneVT() *Module { + if m == nil { + return (*Module)(nil) + } + r := new(Module) + r.Name = m.Name + r.BinaryIndex = m.BinaryIndex + r.BinaryEntrypoint = m.BinaryEntrypoint + r.Output = m.Output.CloneVT() + r.InitialBlock = m.InitialBlock + r.BlockFilter = m.BlockFilter.CloneVT() + if m.Kind != nil { + r.Kind = m.Kind.(interface{ CloneVT() isModule_Kind }).CloneVT() + } + if rhs := m.Inputs; rhs != nil { + tmpContainer := make([]*Module_Input, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Inputs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Module) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Module_KindMap_) CloneVT() isModule_Kind { + if m == nil { + return (*Module_KindMap_)(nil) + } + r := new(Module_KindMap_) + r.KindMap = m.KindMap.CloneVT() + return r +} + +func (m *Module_KindStore_) CloneVT() isModule_Kind { + if m == nil { + return (*Module_KindStore_)(nil) + } + r := new(Module_KindStore_) + r.KindStore = m.KindStore.CloneVT() + return r +} + +func (m *Module_KindBlockIndex_) CloneVT() isModule_Kind { + if m == nil { + return (*Module_KindBlockIndex_)(nil) + } + r := new(Module_KindBlockIndex_) + r.KindBlockIndex = m.KindBlockIndex.CloneVT() + return r +} + +func (this *Modules) EqualVT(that *Modules) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Modules) != len(that.Modules) { + return false + } + for i, vx := range this.Modules { + vy := that.Modules[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Module{} + } + if q == nil { + q = &Module{} + } + if !p.EqualVT(q) { + return false + } + } + } + if len(this.Binaries) != len(that.Binaries) { + return false + } + for i, vx := range this.Binaries { + vy := that.Binaries[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Binary{} + } + if q == nil { + q = &Binary{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Modules) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Modules) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Binary) EqualVT(that *Binary) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Type != that.Type { + return false + } + if string(this.Content) != string(that.Content) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Binary) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Binary) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_BlockFilter) EqualVT(that *Module_BlockFilter) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Query == nil && that.Query != nil { + return false + } else if this.Query != nil { + if that.Query == nil { + return false + } + if !this.Query.(interface { + EqualVT(isModule_BlockFilter_Query) bool + }).EqualVT(that.Query) { + return false + } + } + if this.Module != that.Module { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_BlockFilter) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_BlockFilter) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_BlockFilter_QueryString) EqualVT(thatIface isModule_BlockFilter_Query) bool { + that, ok := thatIface.(*Module_BlockFilter_QueryString) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if this.QueryString != that.QueryString { + return false + } + return true +} + +func (this *Module_BlockFilter_QueryFromParams) EqualVT(thatIface isModule_BlockFilter_Query) bool { + that, ok := thatIface.(*Module_BlockFilter_QueryFromParams) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.QueryFromParams, that.QueryFromParams; p != q { + if p == nil { + p = &Module_QueryFromParams{} + } + if q == nil { + q = &Module_QueryFromParams{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Module_QueryFromParams) EqualVT(that *Module_QueryFromParams) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_QueryFromParams) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_QueryFromParams) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_KindMap) EqualVT(that *Module_KindMap) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.OutputType != that.OutputType { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_KindMap) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_KindMap) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_KindStore) EqualVT(that *Module_KindStore) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.UpdatePolicy != that.UpdatePolicy { + return false + } + if this.ValueType != that.ValueType { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_KindStore) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_KindStore) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_KindBlockIndex) EqualVT(that *Module_KindBlockIndex) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.OutputType != that.OutputType { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_KindBlockIndex) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_KindBlockIndex) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_FoundationalStore) EqualVT(that *Module_FoundationalStore) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Identifier != that.Identifier { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_FoundationalStore) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_FoundationalStore) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_Input_Source) EqualVT(that *Module_Input_Source) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Type != that.Type { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_Input_Source) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_Input_Source) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_Input_Map) EqualVT(that *Module_Input_Map) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.ModuleName != that.ModuleName { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_Input_Map) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_Input_Map) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_Input_Store) EqualVT(that *Module_Input_Store) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.ModuleName != that.ModuleName { + return false + } + if this.Mode != that.Mode { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_Input_Store) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_Input_Store) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_Input_Params) EqualVT(that *Module_Input_Params) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Value != that.Value { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_Input_Params) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_Input_Params) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_Input) EqualVT(that *Module_Input) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Input == nil && that.Input != nil { + return false + } else if this.Input != nil { + if that.Input == nil { + return false + } + if !this.Input.(interface { + EqualVT(isModule_Input_Input) bool + }).EqualVT(that.Input) { + return false + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_Input) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_Input) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_Input_Source_) EqualVT(thatIface isModule_Input_Input) bool { + that, ok := thatIface.(*Module_Input_Source_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Source, that.Source; p != q { + if p == nil { + p = &Module_Input_Source{} + } + if q == nil { + q = &Module_Input_Source{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Module_Input_Map_) EqualVT(thatIface isModule_Input_Input) bool { + that, ok := thatIface.(*Module_Input_Map_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Map, that.Map; p != q { + if p == nil { + p = &Module_Input_Map{} + } + if q == nil { + q = &Module_Input_Map{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Module_Input_Store_) EqualVT(thatIface isModule_Input_Input) bool { + that, ok := thatIface.(*Module_Input_Store_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Store, that.Store; p != q { + if p == nil { + p = &Module_Input_Store{} + } + if q == nil { + q = &Module_Input_Store{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Module_Input_Params_) EqualVT(thatIface isModule_Input_Input) bool { + that, ok := thatIface.(*Module_Input_Params_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.Params, that.Params; p != q { + if p == nil { + p = &Module_Input_Params{} + } + if q == nil { + q = &Module_Input_Params{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Module_Input_FoundationalStore) EqualVT(thatIface isModule_Input_Input) bool { + that, ok := thatIface.(*Module_Input_FoundationalStore) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.FoundationalStore, that.FoundationalStore; p != q { + if p == nil { + p = &Module_FoundationalStore{} + } + if q == nil { + q = &Module_FoundationalStore{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Module_Output) EqualVT(that *Module_Output) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Type != that.Type { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module_Output) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module_Output) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module) EqualVT(that *Module) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Kind == nil && that.Kind != nil { + return false + } else if this.Kind != nil { + if that.Kind == nil { + return false + } + if !this.Kind.(interface{ EqualVT(isModule_Kind) bool }).EqualVT(that.Kind) { + return false + } + } + if this.Name != that.Name { + return false + } + if this.BinaryIndex != that.BinaryIndex { + return false + } + if this.BinaryEntrypoint != that.BinaryEntrypoint { + return false + } + if len(this.Inputs) != len(that.Inputs) { + return false + } + for i, vx := range this.Inputs { + vy := that.Inputs[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Module_Input{} + } + if q == nil { + q = &Module_Input{} + } + if !p.EqualVT(q) { + return false + } + } + } + if !this.Output.EqualVT(that.Output) { + return false + } + if this.InitialBlock != that.InitialBlock { + return false + } + if !this.BlockFilter.EqualVT(that.BlockFilter) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Module) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Module) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Module_KindMap_) EqualVT(thatIface isModule_Kind) bool { + that, ok := thatIface.(*Module_KindMap_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.KindMap, that.KindMap; p != q { + if p == nil { + p = &Module_KindMap{} + } + if q == nil { + q = &Module_KindMap{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Module_KindStore_) EqualVT(thatIface isModule_Kind) bool { + that, ok := thatIface.(*Module_KindStore_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.KindStore, that.KindStore; p != q { + if p == nil { + p = &Module_KindStore{} + } + if q == nil { + q = &Module_KindStore{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (this *Module_KindBlockIndex_) EqualVT(thatIface isModule_Kind) bool { + that, ok := thatIface.(*Module_KindBlockIndex_) + if !ok { + return false + } + if this == that { + return true + } + if this == nil && that != nil || this != nil && that == nil { + return false + } + if p, q := this.KindBlockIndex, that.KindBlockIndex; p != q { + if p == nil { + p = &Module_KindBlockIndex{} + } + if q == nil { + q = &Module_KindBlockIndex{} + } + if !p.EqualVT(q) { + return false + } + } + return true +} + +func (m *Modules) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Modules) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Modules) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Binaries) > 0 { + for iNdEx := len(m.Binaries) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Binaries[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Modules) > 0 { + for iNdEx := len(m.Modules) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Modules[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *Binary) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Binary) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Binary) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Content) > 0 { + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0x12 + } + if len(m.Type) > 0 { + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_BlockFilter) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_BlockFilter) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_BlockFilter) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Query.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if len(m.Module) > 0 { + i -= len(m.Module) + copy(dAtA[i:], m.Module) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Module))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_BlockFilter_QueryString) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_BlockFilter_QueryString) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + i -= len(m.QueryString) + copy(dAtA[i:], m.QueryString) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.QueryString))) + i-- + dAtA[i] = 0x12 + return len(dAtA) - i, nil +} +func (m *Module_BlockFilter_QueryFromParams) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_BlockFilter_QueryFromParams) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.QueryFromParams != nil { + size, err := m.QueryFromParams.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *Module_QueryFromParams) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_QueryFromParams) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_QueryFromParams) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + return len(dAtA) - i, nil +} + +func (m *Module_KindMap) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_KindMap) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_KindMap) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.OutputType) > 0 { + i -= len(m.OutputType) + copy(dAtA[i:], m.OutputType) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OutputType))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_KindStore) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_KindStore) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_KindStore) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ValueType) > 0 { + i -= len(m.ValueType) + copy(dAtA[i:], m.ValueType) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ValueType))) + i-- + dAtA[i] = 0x12 + } + if m.UpdatePolicy != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.UpdatePolicy)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Module_KindBlockIndex) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_KindBlockIndex) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_KindBlockIndex) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.OutputType) > 0 { + i -= len(m.OutputType) + copy(dAtA[i:], m.OutputType) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OutputType))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_FoundationalStore) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_FoundationalStore) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_FoundationalStore) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Identifier) > 0 { + i -= len(m.Identifier) + copy(dAtA[i:], m.Identifier) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Identifier))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_Input_Source) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_Input_Source) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_Source) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Type) > 0 { + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_Input_Map) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_Input_Map) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_Map) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ModuleName) > 0 { + i -= len(m.ModuleName) + copy(dAtA[i:], m.ModuleName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ModuleName))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_Input_Store) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_Input_Store) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_Store) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Mode != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Mode)) + i-- + dAtA[i] = 0x10 + } + if len(m.ModuleName) > 0 { + i -= len(m.ModuleName) + copy(dAtA[i:], m.ModuleName) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ModuleName))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_Input_Params) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_Input_Params) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_Params) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_Input) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_Input) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Input.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + return len(dAtA) - i, nil +} + +func (m *Module_Input_Source_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_Source_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Source != nil { + size, err := m.Source.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} +func (m *Module_Input_Map_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_Map_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Map != nil { + size, err := m.Map.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *Module_Input_Store_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_Store_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Store != nil { + size, err := m.Store.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *Module_Input_Params_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_Params_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Params != nil { + size, err := m.Params.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *Module_Input_FoundationalStore) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Input_FoundationalStore) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.FoundationalStore != nil { + size, err := m.FoundationalStore.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *Module_Output) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module_Output) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_Output) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Type) > 0 { + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Module) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if vtmsg, ok := m.Kind.(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + } + if m.BlockFilter != nil { + size, err := m.BlockFilter.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x4a + } + if m.InitialBlock != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.InitialBlock)) + i-- + dAtA[i] = 0x40 + } + if m.Output != nil { + size, err := m.Output.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.Inputs) > 0 { + for iNdEx := len(m.Inputs) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Inputs[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.BinaryEntrypoint) > 0 { + i -= len(m.BinaryEntrypoint) + copy(dAtA[i:], m.BinaryEntrypoint) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BinaryEntrypoint))) + i-- + dAtA[i] = 0x2a + } + if m.BinaryIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BinaryIndex)) + i-- + dAtA[i] = 0x20 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Module_KindMap_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_KindMap_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.KindMap != nil { + size, err := m.KindMap.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} +func (m *Module_KindStore_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_KindStore_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.KindStore != nil { + size, err := m.KindStore.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *Module_KindBlockIndex_) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Module_KindBlockIndex_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + i := len(dAtA) + if m.KindBlockIndex != nil { + size, err := m.KindBlockIndex.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + return len(dAtA) - i, nil +} +func (m *Modules) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Modules) > 0 { + for _, e := range m.Modules { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.Binaries) > 0 { + for _, e := range m.Binaries { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *Binary) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Content) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_BlockFilter) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Module) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if vtmsg, ok := m.Query.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *Module_BlockFilter_QueryString) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.QueryString) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + return n +} +func (m *Module_BlockFilter_QueryFromParams) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.QueryFromParams != nil { + l = m.QueryFromParams.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Module_QueryFromParams) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += len(m.unknownFields) + return n +} + +func (m *Module_KindMap) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OutputType) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_KindStore) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UpdatePolicy != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.UpdatePolicy)) + } + l = len(m.ValueType) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_KindBlockIndex) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OutputType) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_FoundationalStore) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Identifier) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_Input_Source) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_Input_Map) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ModuleName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_Input_Store) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ModuleName) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Mode != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Mode)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_Input_Params) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_Input) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if vtmsg, ok := m.Input.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + n += len(m.unknownFields) + return n +} + +func (m *Module_Input_Source_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Source != nil { + l = m.Source.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Module_Input_Map_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Map != nil { + l = m.Map.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Module_Input_Store_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Store != nil { + l = m.Store.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Module_Input_Params_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Params != nil { + l = m.Params.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Module_Input_FoundationalStore) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.FoundationalStore != nil { + l = m.FoundationalStore.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Module_Output) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if vtmsg, ok := m.Kind.(interface{ SizeVT() int }); ok { + n += vtmsg.SizeVT() + } + if m.BinaryIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BinaryIndex)) + } + l = len(m.BinaryEntrypoint) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Inputs) > 0 { + for _, e := range m.Inputs { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Output != nil { + l = m.Output.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.InitialBlock != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.InitialBlock)) + } + if m.BlockFilter != nil { + l = m.BlockFilter.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Module_KindMap_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.KindMap != nil { + l = m.KindMap.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Module_KindStore_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.KindStore != nil { + l = m.KindStore.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Module_KindBlockIndex_) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.KindBlockIndex != nil { + l = m.KindBlockIndex.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + return n +} +func (m *Modules) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Modules: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Modules: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Modules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Modules = append(m.Modules, &Module{}) + if err := m.Modules[len(m.Modules)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Binaries", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Binaries = append(m.Binaries, &Binary{}) + if err := m.Binaries[len(m.Binaries)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Binary) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Binary: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Binary: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + 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 protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + 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 := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_BlockFilter) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_BlockFilter: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_BlockFilter: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Module", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Module = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field QueryString", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Query = &Module_BlockFilter_QueryString{QueryString: string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field QueryFromParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Query.(*Module_BlockFilter_QueryFromParams); ok { + if err := oneof.QueryFromParams.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_QueryFromParams{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Query = &Module_BlockFilter_QueryFromParams{QueryFromParams: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_QueryFromParams) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_QueryFromParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_QueryFromParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_KindMap) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_KindMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_KindMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_KindStore) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_KindStore: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_KindStore: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdatePolicy", wireType) + } + m.UpdatePolicy = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.UpdatePolicy |= Module_KindStore_UpdatePolicy(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValueType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValueType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_KindBlockIndex) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_KindBlockIndex: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_KindBlockIndex: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_FoundationalStore) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_FoundationalStore: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_FoundationalStore: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Identifier", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Identifier = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_Input_Source) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_Input_Source: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_Input_Source: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_Input_Map) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_Input_Map: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_Input_Map: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ModuleName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ModuleName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_Input_Store) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_Input_Store: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_Input_Store: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ModuleName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ModuleName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) + } + m.Mode = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Mode |= Module_Input_Store_Mode(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_Input_Params) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_Input_Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_Input_Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_Input) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_Input: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_Input: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Input.(*Module_Input_Source_); ok { + if err := oneof.Source.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_Input_Source{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Input = &Module_Input_Source_{Source: v} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Input.(*Module_Input_Map_); ok { + if err := oneof.Map.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_Input_Map{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Input = &Module_Input_Map_{Map: v} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Input.(*Module_Input_Store_); ok { + if err := oneof.Store.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_Input_Store{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Input = &Module_Input_Store_{Store: v} + } + iNdEx = postIndex + case 4: + 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 protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Input.(*Module_Input_Params_); ok { + if err := oneof.Params.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_Input_Params{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Input = &Module_Input_Params_{Params: v} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FoundationalStore", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Input.(*Module_Input_FoundationalStore); ok { + if err := oneof.FoundationalStore.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_FoundationalStore{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Input = &Module_Input_FoundationalStore{FoundationalStore: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module_Output) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module_Output: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module_Output: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Module) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Module: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Module: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KindMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Kind.(*Module_KindMap_); ok { + if err := oneof.KindMap.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_KindMap{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Kind = &Module_KindMap_{KindMap: v} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KindStore", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Kind.(*Module_KindStore_); ok { + if err := oneof.KindStore.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_KindStore{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Kind = &Module_KindStore_{KindStore: v} + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BinaryIndex", wireType) + } + m.BinaryIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BinaryIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BinaryEntrypoint", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BinaryEntrypoint = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Inputs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Inputs = append(m.Inputs, &Module_Input{}) + if err := m.Inputs[len(m.Inputs)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Output == nil { + m.Output = &Module_Output{} + } + if err := m.Output.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InitialBlock", wireType) + } + m.InitialBlock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.InitialBlock |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockFilter", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockFilter == nil { + m.BlockFilter = &Module_BlockFilter{} + } + if err := m.BlockFilter.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KindBlockIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if oneof, ok := m.Kind.(*Module_KindBlockIndex_); ok { + if err := oneof.KindBlockIndex.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + v := &Module_KindBlockIndex{} + if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Kind = &Module_KindBlockIndex_{KindBlockIndex: v} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/v1/package_vtproto.pb.go b/pb/sf/substreams/v1/package_vtproto.pb.go new file mode 100644 index 000000000..7b27808a0 --- /dev/null +++ b/pb/sf/substreams/v1/package_vtproto.pb.go @@ -0,0 +1,2087 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/v1/package.proto + +package pbsubstreams + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + anypb1 "github.com/planetscale/vtprotobuf/types/known/anypb" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + descriptorpb "google.golang.org/protobuf/types/descriptorpb" + anypb "google.golang.org/protobuf/types/known/anypb" + io "io" +) + +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) +) + +func (m *Package) CloneVT() *Package { + if m == nil { + return (*Package)(nil) + } + r := new(Package) + r.Version = m.Version + r.Modules = m.Modules.CloneVT() + r.Network = m.Network + r.SinkConfig = (*anypb.Any)((*anypb1.Any)(m.SinkConfig).CloneVT()) + r.SinkModule = m.SinkModule + if rhs := m.ProtoFiles; rhs != nil { + tmpContainer := make([]*descriptorpb.FileDescriptorProto, len(rhs)) + for k, v := range rhs { + if vtpb, ok := interface{}(v).(interface { + CloneVT() *descriptorpb.FileDescriptorProto + }); ok { + tmpContainer[k] = vtpb.CloneVT() + } else { + tmpContainer[k] = proto.Clone(v).(*descriptorpb.FileDescriptorProto) + } + } + r.ProtoFiles = tmpContainer + } + if rhs := m.ModuleMeta; rhs != nil { + tmpContainer := make([]*ModuleMetadata, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ModuleMeta = tmpContainer + } + if rhs := m.PackageMeta; rhs != nil { + tmpContainer := make([]*PackageMetadata, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.PackageMeta = tmpContainer + } + if rhs := m.Image; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Image = tmpBytes + } + if rhs := m.Networks; rhs != nil { + tmpContainer := make(map[string]*NetworkParams, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Networks = tmpContainer + } + if rhs := m.BlockFilters; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.BlockFilters = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Package) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *NetworkParams) CloneVT() *NetworkParams { + if m == nil { + return (*NetworkParams)(nil) + } + r := new(NetworkParams) + if rhs := m.InitialBlocks; rhs != nil { + tmpContainer := make(map[string]uint64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.InitialBlocks = tmpContainer + } + if rhs := m.Params; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Params = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *NetworkParams) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PackageMetadata) CloneVT() *PackageMetadata { + if m == nil { + return (*PackageMetadata)(nil) + } + r := new(PackageMetadata) + r.Version = m.Version + r.Url = m.Url + r.Name = m.Name + r.Doc = m.Doc + r.Description = m.Description + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PackageMetadata) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ModuleMetadata) CloneVT() *ModuleMetadata { + if m == nil { + return (*ModuleMetadata)(nil) + } + r := new(ModuleMetadata) + r.PackageIndex = m.PackageIndex + r.Doc = m.Doc + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ModuleMetadata) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *Package) EqualVT(that *Package) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.ProtoFiles) != len(that.ProtoFiles) { + return false + } + for i, vx := range this.ProtoFiles { + vy := that.ProtoFiles[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &descriptorpb.FileDescriptorProto{} + } + if q == nil { + q = &descriptorpb.FileDescriptorProto{} + } + if equal, ok := interface{}(p).(interface { + EqualVT(*descriptorpb.FileDescriptorProto) bool + }); ok { + if !equal.EqualVT(q) { + return false + } + } else if !proto.Equal(p, q) { + return false + } + } + } + if this.Version != that.Version { + return false + } + if !this.Modules.EqualVT(that.Modules) { + return false + } + if len(this.ModuleMeta) != len(that.ModuleMeta) { + return false + } + for i, vx := range this.ModuleMeta { + vy := that.ModuleMeta[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &ModuleMetadata{} + } + if q == nil { + q = &ModuleMetadata{} + } + if !p.EqualVT(q) { + return false + } + } + } + if len(this.PackageMeta) != len(that.PackageMeta) { + return false + } + for i, vx := range this.PackageMeta { + vy := that.PackageMeta[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &PackageMetadata{} + } + if q == nil { + q = &PackageMetadata{} + } + if !p.EqualVT(q) { + return false + } + } + } + if this.Network != that.Network { + return false + } + if !(*anypb1.Any)(this.SinkConfig).EqualVT((*anypb1.Any)(that.SinkConfig)) { + return false + } + if this.SinkModule != that.SinkModule { + return false + } + if string(this.Image) != string(that.Image) { + return false + } + if len(this.Networks) != len(that.Networks) { + return false + } + for i, vx := range this.Networks { + vy, ok := that.Networks[i] + if !ok { + return false + } + if p, q := vx, vy; p != q { + if p == nil { + p = &NetworkParams{} + } + if q == nil { + q = &NetworkParams{} + } + if !p.EqualVT(q) { + return false + } + } + } + if len(this.BlockFilters) != len(that.BlockFilters) { + return false + } + for i, vx := range this.BlockFilters { + vy, ok := that.BlockFilters[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Package) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Package) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *NetworkParams) EqualVT(that *NetworkParams) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.InitialBlocks) != len(that.InitialBlocks) { + return false + } + for i, vx := range this.InitialBlocks { + vy, ok := that.InitialBlocks[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + if len(this.Params) != len(that.Params) { + return false + } + for i, vx := range this.Params { + vy, ok := that.Params[i] + if !ok { + return false + } + if vx != vy { + return false + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *NetworkParams) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*NetworkParams) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *PackageMetadata) EqualVT(that *PackageMetadata) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Version != that.Version { + return false + } + if this.Url != that.Url { + return false + } + if this.Name != that.Name { + return false + } + if this.Doc != that.Doc { + return false + } + if this.Description != that.Description { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *PackageMetadata) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*PackageMetadata) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ModuleMetadata) EqualVT(that *ModuleMetadata) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.PackageIndex != that.PackageIndex { + return false + } + if this.Doc != that.Doc { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ModuleMetadata) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ModuleMetadata) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *Package) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Package) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Package) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlockFilters) > 0 { + for k := range m.BlockFilters { + v := m.BlockFilters[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x72 + } + } + if len(m.Networks) > 0 { + for k := range m.Networks { + v := m.Networks[k] + baseI := i + size, err := v.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x6a + } + } + if len(m.Image) > 0 { + i -= len(m.Image) + copy(dAtA[i:], m.Image) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Image))) + i-- + dAtA[i] = 0x62 + } + if len(m.SinkModule) > 0 { + i -= len(m.SinkModule) + copy(dAtA[i:], m.SinkModule) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SinkModule))) + i-- + dAtA[i] = 0x5a + } + if m.SinkConfig != nil { + size, err := (*anypb1.Any)(m.SinkConfig).MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.Network) > 0 { + i -= len(m.Network) + copy(dAtA[i:], m.Network) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Network))) + i-- + dAtA[i] = 0x4a + } + if len(m.PackageMeta) > 0 { + for iNdEx := len(m.PackageMeta) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.PackageMeta[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.ModuleMeta) > 0 { + for iNdEx := len(m.ModuleMeta) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.ModuleMeta[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + } + if m.Modules != nil { + size, err := m.Modules.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Version != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x28 + } + if len(m.ProtoFiles) > 0 { + for iNdEx := len(m.ProtoFiles) - 1; iNdEx >= 0; iNdEx-- { + if vtmsg, ok := interface{}(m.ProtoFiles[iNdEx]).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.ProtoFiles[iNdEx]) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded))) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *NetworkParams) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *NetworkParams) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *NetworkParams) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Params) > 0 { + for k := range m.Params { + v := m.Params[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.InitialBlocks) > 0 { + for k := range m.InitialBlocks { + v := m.InitialBlocks[k] + baseI := i + i = protohelpers.EncodeVarint(dAtA, i, uint64(v)) + i-- + dAtA[i] = 0x10 + i -= len(k) + copy(dAtA[i:], k) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *PackageMetadata) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PackageMetadata) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *PackageMetadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x2a + } + if len(m.Doc) > 0 { + i -= len(m.Doc) + copy(dAtA[i:], m.Doc) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Doc))) + i-- + dAtA[i] = 0x22 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a + } + if len(m.Url) > 0 { + i -= len(m.Url) + copy(dAtA[i:], m.Url) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Url))) + i-- + dAtA[i] = 0x12 + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ModuleMetadata) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ModuleMetadata) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ModuleMetadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Doc) > 0 { + i -= len(m.Doc) + copy(dAtA[i:], m.Doc) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Doc))) + i-- + dAtA[i] = 0x12 + } + if m.PackageIndex != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PackageIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Package) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ProtoFiles) > 0 { + for _, e := range m.ProtoFiles { + if size, ok := interface{}(e).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(e) + } + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if m.Version != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Version)) + } + if m.Modules != nil { + l = m.Modules.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.ModuleMeta) > 0 { + for _, e := range m.ModuleMeta { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + if len(m.PackageMeta) > 0 { + for _, e := range m.PackageMeta { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + l = len(m.Network) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.SinkConfig != nil { + l = (*anypb1.Any)(m.SinkConfig).SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.SinkModule) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Image) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if len(m.Networks) > 0 { + for k, v := range m.Networks { + _ = k + _ = v + l = 0 + if v != nil { + l = v.SizeVT() + } + l += 1 + protohelpers.SizeOfVarint(uint64(l)) + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + if len(m.BlockFilters) > 0 { + for k, v := range m.BlockFilters { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *NetworkParams) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.InitialBlocks) > 0 { + for k, v := range m.InitialBlocks { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + protohelpers.SizeOfVarint(uint64(v)) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + if len(m.Params) > 0 { + for k, v := range m.Params { + _ = k + _ = v + mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) + n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *PackageMetadata) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Url) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Doc) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ModuleMetadata) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PackageIndex != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.PackageIndex)) + } + l = len(m.Doc) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Package) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Package: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Package: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProtoFiles", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProtoFiles = append(m.ProtoFiles, &descriptorpb.FileDescriptorProto{}) + if unmarshal, ok := interface{}(m.ProtoFiles[len(m.ProtoFiles)-1]).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.ProtoFiles[len(m.ProtoFiles)-1]); err != nil { + return err + } + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Modules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Modules == nil { + m.Modules = &Modules{} + } + if err := m.Modules.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ModuleMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ModuleMeta = append(m.ModuleMeta, &ModuleMetadata{}) + if err := m.ModuleMeta[len(m.ModuleMeta)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PackageMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PackageMeta = append(m.PackageMeta, &PackageMetadata{}) + if err := m.PackageMeta[len(m.PackageMeta)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Network = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SinkConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SinkConfig == nil { + m.SinkConfig = &anypb.Any{} + } + if err := (*anypb1.Any)(m.SinkConfig).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SinkModule", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SinkModule = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Image = append(m.Image[:0], dAtA[iNdEx:postIndex]...) + if m.Image == nil { + m.Image = []byte{} + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Networks == nil { + m.Networks = make(map[string]*NetworkParams) + } + var mapkey string + var mapvalue *NetworkParams + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return protohelpers.ErrInvalidLength + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &NetworkParams{} + if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Networks[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockFilters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockFilters == nil { + m.BlockFilters = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.BlockFilters[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NetworkParams) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: NetworkParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NetworkParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitialBlocks", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.InitialBlocks == nil { + m.InitialBlocks = make(map[string]uint64) + } + var mapkey string + var mapvalue uint64 + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.InitialBlocks[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Params == nil { + m.Params = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return protohelpers.ErrInvalidLength + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Params[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PackageMetadata) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: PackageMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PackageMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Url = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Doc", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Doc = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ModuleMetadata) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: ModuleMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ModuleMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PackageIndex", wireType) + } + m.PackageIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PackageIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Doc", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Doc = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pb/sf/substreams/v1/test/test_vtproto.pb.go b/pb/sf/substreams/v1/test/test_vtproto.pb.go new file mode 100644 index 000000000..2957d4195 --- /dev/null +++ b/pb/sf/substreams/v1/test/test_vtproto.pb.go @@ -0,0 +1,779 @@ +// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. +// protoc-gen-go-vtproto version: v0.6.0 +// source: sf/substreams/v1/test/test.proto + +package pbsubstreamstest + +import ( + fmt "fmt" + protohelpers "github.com/planetscale/vtprotobuf/protohelpers" + proto "google.golang.org/protobuf/proto" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" +) + +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) +) + +func (m *Block) CloneVT() *Block { + if m == nil { + return (*Block)(nil) + } + r := new(Block) + r.Id = m.Id + r.Number = m.Number + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Block) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MapResult) CloneVT() *MapResult { + if m == nil { + return (*MapResult)(nil) + } + r := new(MapResult) + r.BlockNumber = m.BlockNumber + r.BlockHash = m.BlockHash + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MapResult) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Boolean) CloneVT() *Boolean { + if m == nil { + return (*Boolean)(nil) + } + r := new(Boolean) + r.Result = m.Result + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Boolean) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Array) CloneVT() *Array { + if m == nil { + return (*Array)(nil) + } + r := new(Array) + if rhs := m.Result; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Result = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Array) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (this *Block) EqualVT(that *Block) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Id != that.Id { + return false + } + if this.Number != that.Number { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Block) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Block) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *MapResult) EqualVT(that *MapResult) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.BlockNumber != that.BlockNumber { + return false + } + if this.BlockHash != that.BlockHash { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *MapResult) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*MapResult) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Boolean) EqualVT(that *Boolean) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Result != that.Result { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Boolean) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Boolean) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Array) EqualVT(that *Array) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Result) != len(that.Result) { + return false + } + for i, vx := range this.Result { + vy := that.Result[i] + if vx != vy { + return false + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Array) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Array) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *Block) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Block) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Block) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Number != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Number)) + i-- + dAtA[i] = 0x10 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MapResult) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MapResult) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *MapResult) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x12 + } + if m.BlockNumber != 0 { + i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BlockNumber)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Boolean) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Boolean) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Boolean) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Result { + i-- + if m.Result { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Array) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Array) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Array) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Result) > 0 { + for iNdEx := len(m.Result) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Result[iNdEx]) + copy(dAtA[i:], m.Result[iNdEx]) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Result[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *Block) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + if m.Number != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.Number)) + } + n += len(m.unknownFields) + return n +} + +func (m *MapResult) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockNumber != 0 { + n += 1 + protohelpers.SizeOfVarint(uint64(m.BlockNumber)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *Boolean) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Result { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *Array) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Result) > 0 { + for _, s := range m.Result { + l = len(s) + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *Block) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Block: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + m.Number = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Number |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MapResult) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: MapResult: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MapResult: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + m.BlockNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Boolean) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Boolean: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Boolean: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Result = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Array) UnmarshalVT(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 protohelpers.ErrIntOverflow + } + 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: Array: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Array: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + 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 protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Result = append(m.Result, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} diff --git a/pipeline/pipeline.go b/pipeline/pipeline.go index 1f113b553..3e8f029b1 100644 --- a/pipeline/pipeline.go +++ b/pipeline/pipeline.go @@ -135,6 +135,7 @@ type Pipeline struct { blockStepMap map[bstream.StepType]uint64 workerPoolFactory work.WorkerPoolFactory checkPendingShutdown func() bool + bufferSize int } func New( @@ -153,6 +154,7 @@ func New( executionTimeout time.Duration, checkPendingShutdown func() bool, foundationalEndpoints map[string]string, + bufferSize int, opts ...Option, ) *Pipeline { pipe := &Pipeline{ @@ -178,6 +180,7 @@ func New( workerPoolFactory: workerPoolFactory, checkPendingShutdown: checkPendingShutdown, moduleNameToStage: make(map[string]int), + bufferSize: bufferSize, } for _, opt := range opts { opt(pipe) @@ -505,6 +508,7 @@ func (p *Pipeline) runParallelProcess(ctx context.Context, reqPlan *plan.Request p.respFunc, p.stores.configs, noopMode, + p.bufferSize, ) if err != nil { return nil, fmt.Errorf("building parallel processor: %w", err) diff --git a/proto/sf/substreams/rpc/v2/service.proto b/proto/sf/substreams/rpc/v2/service.proto index fbaa383f2..ccecc9c47 100644 --- a/proto/sf/substreams/rpc/v2/service.proto +++ b/proto/sf/substreams/rpc/v2/service.proto @@ -85,6 +85,7 @@ message Response { BlockScopedData block_scoped_data = 3; BlockUndoSignal block_undo_signal = 4; Error fatal_error = 5; + BlockScopedDatas block_scoped_datas = 6; // Available only in developer mode, and only if `debug_initial_store_snapshot_for_modules` is set. InitialSnapshotData debug_snapshot_data = 10; @@ -103,6 +104,10 @@ message BlockUndoSignal { string last_valid_cursor = 2; } +message BlockScopedDatas { + repeated BlockScopedData items = 1; +} + message BlockScopedData { MapModuleOutput output = 1; sf.substreams.v1.Clock clock = 2; diff --git a/protodecode/vtcodec.go b/protodecode/vtcodec.go new file mode 100644 index 000000000..544af6118 --- /dev/null +++ b/protodecode/vtcodec.go @@ -0,0 +1,43 @@ +package protodecode + +import ( + "fmt" + + "google.golang.org/protobuf/proto" +) + +type PreferredVTCodec struct{} + +type vtprotoMessage interface { + MarshalVT() ([]byte, error) + UnmarshalVT([]byte) error +} + +func (PreferredVTCodec) Marshal(v any) ([]byte, error) { + vt, ok := v.(vtprotoMessage) + if !ok { + nonvt, ok := v.(proto.Message) + if ok { + return proto.Marshal(nonvt) + } + return nil, fmt.Errorf("failed to marshal, message is %T (missing proto or vtprotobuf helpers)", v) + } + return vt.MarshalVT() +} + +func (PreferredVTCodec) Unmarshal(data []byte, v any) error { + vt, ok := v.(vtprotoMessage) + if !ok { + nonvt, ok := v.(proto.Message) + if ok { + return proto.Unmarshal(data, nonvt) + } + + return fmt.Errorf("failed to unmarshal, message is %T (missing proto or vtprotobuf helpers)", v) + } + return vt.UnmarshalVT(data) +} + +func (PreferredVTCodec) Name() string { + return "proto" +} diff --git a/service/connect/service.go b/service/connect/service.go new file mode 100644 index 000000000..7fc7450c4 --- /dev/null +++ b/service/connect/service.go @@ -0,0 +1,91 @@ +package connect + +import ( + "context" + "fmt" + "net/http" + + "connectrpc.com/connect" + pbsubstreamsrpc "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2" + "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2/pbsubstreamsrpcv2connect" + pbsubstreamsrpcv3 "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v3" + "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v3/pbsubstreamsrpcv3connect" + pbsubstreams "github.com/streamingfast/substreams/pb/sf/substreams/v1" + "github.com/streamingfast/substreams/reqctx" + "google.golang.org/grpc" + "google.golang.org/grpc/metadata" +) + +type Tier1Service interface { + BlocksAny( + ctx context.Context, + request *pbsubstreamsrpc.Request, + header http.Header, + protocol string, + pkg *pbsubstreams.Package, + stream grpc.ServerStream, + ) error +} + +type Service struct { + inner Tier1Service +} + +func NewService(inner Tier1Service) *Service { + return &Service{inner: inner} +} + +func (s *Service) Blocks( + ctx context.Context, + req *connect.Request[pbsubstreamsrpc.Request], + stream *connect.ServerStream[pbsubstreamsrpc.Response], +) error { + return s.inner.BlocksAny(ctx, req.Msg, req.Header(), pbsubstreamsrpcv2connect.StreamBlocksProcedure, nil, &serverStreamWrapper{stream, ctx}) +} + +func (s *Service) BlocksV3( + ctx context.Context, + req *connect.Request[pbsubstreamsrpcv3.Request], + stream *connect.ServerStream[pbsubstreamsrpc.Response], +) error { + if req.Msg.Package == nil { + return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("package is required")) + } + + ctx = reqctx.WithSpkg(ctx, req.Msg.Package) + + v2req, err := req.Msg.ToV2() + if err != nil { + return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("failed to convert request to v2: %w", err)) + } + + return s.inner.BlocksAny(ctx, v2req, req.Header(), pbsubstreamsrpcv3connect.StreamBlocksProcedure, req.Msg.Package, &serverStreamWrapper{stream, ctx}) +} + +type serverStreamWrapper struct { + *connect.ServerStream[pbsubstreamsrpc.Response] + ctx context.Context +} + +func (w *serverStreamWrapper) SetHeader(metadata.MD) error { + return nil +} + +func (w *serverStreamWrapper) SendHeader(metadata.MD) error { + return nil +} + +func (w *serverStreamWrapper) SetTrailer(metadata.MD) { +} + +func (w *serverStreamWrapper) Context() context.Context { + return w.ctx +} + +func (w *serverStreamWrapper) SendMsg(m interface{}) error { + return w.ServerStream.Send(m.(*pbsubstreamsrpc.Response)) +} + +func (w *serverStreamWrapper) RecvMsg(m interface{}) error { + return fmt.Errorf("not implemented") +} diff --git a/service/server.go b/service/server.go index 3c8eeaf3b..ff9bd2200 100644 --- a/service/server.go +++ b/service/server.go @@ -2,45 +2,44 @@ package service import ( "context" + "net" "net/http" "net/url" "strings" + "time" "connectrpc.com/connect" compress "github.com/klauspost/connect-compress/v2" + _ "github.com/mostynb/go-grpc-compression/experimental/s2" + _ "github.com/mostynb/go-grpc-compression/lz4" + _ "github.com/mostynb/go-grpc-compression/zstd" + _ "github.com/planetscale/vtprotobuf/codec/grpc" "github.com/streamingfast/dauth" dauthconnect "github.com/streamingfast/dauth/middleware/connect" dauthgrpc "github.com/streamingfast/dauth/middleware/grpc" dgrpcserver "github.com/streamingfast/dgrpc/server" connectweb "github.com/streamingfast/dgrpc/server/connectrpc" "github.com/streamingfast/dgrpc/server/factory" + "github.com/streamingfast/dgrpc/server/standard" pbssinternal "github.com/streamingfast/substreams/pb/sf/substreams/intern/v2" pbsubstreamsrpc "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2" "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2/pbsubstreamsrpcv2connect" pbsubstreamsrpcv3 "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v3" "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v3/pbsubstreamsrpcv3connect" + "github.com/streamingfast/substreams/protodecode" + tier1Connect "github.com/streamingfast/substreams/service/connect" "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc" "go.opentelemetry.io/otel" "go.uber.org/zap" + "golang.org/x/net/http2" + "golang.org/x/net/http2/h2c" "google.golang.org/grpc" + "google.golang.org/grpc/encoding" + _ "google.golang.org/grpc/experimental" ) -func GetCommonServerOptions(listenAddr string, logger *zap.Logger, healthcheck dgrpcserver.HealthCheck) []dgrpcserver.Option { - tracerProvider := otel.GetTracerProvider() - options := []dgrpcserver.Option{ - dgrpcserver.WithLogger(logger), - dgrpcserver.WithHealthCheck(dgrpcserver.HealthCheckOverGRPC|dgrpcserver.HealthCheckOverHTTP, healthcheck), - dgrpcserver.WithGRPCServerOptions( - grpc.StatsHandler(otelgrpc.NewServerHandler(otelgrpc.WithTracerProvider(tracerProvider))), - grpc.MaxRecvMsgSize(1024*1024*1024), - ), - } - if strings.Contains(listenAddr, "*") { - options = append(options, dgrpcserver.WithInsecureServer()) - } else { - options = append(options, dgrpcserver.WithPlainTextServer()) - } - return options +func init() { + encoding.RegisterCodec(protodecode.PreferredVTCodec{}) } type streamHandlerV3 func(ctx context.Context, req *connect.Request[pbsubstreamsrpcv3.Request], stream *connect.ServerStream[pbsubstreamsrpc.Response]) error @@ -49,91 +48,201 @@ func (h streamHandlerV3) Blocks(ctx context.Context, req *connect.Request[pbsubs return h(ctx, req, stream) } +type v3Adapter struct { + *Tier1Service +} + +func (a *v3Adapter) Blocks(req *pbsubstreamsrpcv3.Request, srv pbsubstreamsrpcv3.Stream_BlocksServer) error { + return a.BlocksV3(req, srv) +} + func ListenTier1( - listenAddr string, + listenAddresses []string, svc *Tier1Service, - infoService pbsubstreamsrpcv2connect.EndpointInfoHandler, + connectSvc *tier1Connect.Service, + infoService pbsubstreamsrpc.EndpointInfoServer, + infoServiceConnect pbsubstreamsrpcv2connect.EndpointInfoHandler, auth dauth.Authenticator, logger *zap.Logger, healthcheck dgrpcserver.HealthCheck, + enforceCompression bool, ) (err error) { - done := make(chan struct{}) - var servers []*connectweb.ConnectWebServer - for _, addr := range strings.Split(listenAddr, ",") { - // note: some of these common options don't work with connectWeb - options := GetCommonServerOptions(addr, logger, healthcheck) + grpcServer := grpcServer(svc, infoService, auth, healthcheck, enforceCompression, logger) + connectServer := connectServer(connectSvc, infoServiceConnect, auth, healthcheck, enforceCompression, logger) - options = append(options, dgrpcserver.WithConnectInterceptor(dauthconnect.NewAuthInterceptor(auth, logger))) - options = append(options, dgrpcserver.WithConnectStrictContentType(false)) - options = append(options, dgrpcserver.WithConnectReflection(pbsubstreamsrpcv2connect.StreamName)) - options = append(options, dgrpcserver.WithConnectReflection(pbsubstreamsrpcv3connect.StreamName)) - options = append(options, dgrpcserver.WithConnectReflection(pbsubstreamsrpcv3connect.StreamName)) + mux := http.NewServeMux() + mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { + contentType := r.Header.Get("Content-Type") + logger.Info("handling request", zap.String("content-type", contentType)) - //todo: move compression to dgrpc :-( + if strings.HasPrefix(contentType, "application/grpc") || strings.HasPrefix(contentType, "application/grpc-web") { + logger.Debug("forwarding gRPC request") + grpcServer.ServeHTTP(w, r) - streamHandlerGetter := func(opts ...connect.HandlerOption) (string, http.Handler) { - var o []connect.HandlerOption - for _, opt := range opts { - o = append(o, opt) - } - o = append(o, compress.WithAll(compress.LevelBalanced)) - return pbsubstreamsrpcv2connect.NewStreamHandler(svc, o...) + return } + if strings.HasPrefix(contentType, "application/connect") || contentType == "application/json" || strings.Contains(contentType, "json") { // loose match for safety + logger.Debug("forwarding gRPC-Web request") + connectServer.ServeHTTP(w, r) + return - streamHandlerGetterV3 := func(opts ...connect.HandlerOption) (string, http.Handler) { - handler := streamHandlerV3(svc.BlocksV3) - var o []connect.HandlerOption - for _, opt := range opts { - o = append(o, opt) - } - o = append(o, compress.WithAll(compress.LevelBalanced)) - return pbsubstreamsrpcv3connect.NewStreamHandler(handler, o...) } - handlerGetters := []connectweb.HandlerGetter{streamHandlerGetter, streamHandlerGetterV3} + http.Error(w, "Unsupported Content-Type for RPC", http.StatusUnsupportedMediaType) + }) + + compressionHandler := standard.CompressionHandler(enforceCompression, mux) + + rootMux := http.NewServeMux() + rootMux.Handle("/healthz", grpcServer.HealthHandler()) + rootMux.Handle("/", compressionHandler) + + for _, addr := range listenAddresses { + go func() { + + h2s := &http2.Server{ + MaxConcurrentStreams: 1000, + } + handler := h2c.NewHandler(rootMux, h2s) + + if strings.Contains(addr, "*") { + cleanAddr := strings.ReplaceAll(addr, "*", "") + tcpListener, err := net.Listen("tcp", cleanAddr) + if err != nil { + logger.Error("failed to start secure grpc server", zap.Error(err)) + grpcServer.Shutdown(0) + return + } + + errorLogger, err := zap.NewStdLogAt(logger, zap.ErrorLevel) + if err != nil { + logger.Error("failed to start secure grpc server", zap.Error(err)) + grpcServer.Shutdown(0) + return + } + + httpServer := &http.Server{ + Handler: handler, + ErrorLog: errorLogger, + TLSConfig: dgrpcserver.SecuredByBuiltInSelfSignedCertificate().AsTLSConfig(), + } - if infoService != nil { - infoHandlerGetter := func(opts ...connect.HandlerOption) (string, http.Handler) { + logger.Info("serving gRPC (over HTTP router) (secure)", zap.String("listen_addr", addr)) + if err := httpServer.ServeTLS(tcpListener, "", ""); err != nil { + logger.Error("failed to start secure grpc server", zap.Error(err)) + grpcServer.Shutdown(0) + return + } - var o []connect.HandlerOption - for _, opt := range opts { - o = append(o, opt) + } else { + logger.Info("serving gRPC (over HTTP router) (plain-text)", zap.String("listen_addr", addr)) + if err := http.ListenAndServe(addr, handler); err != nil { + logger.Error("failed to start secure proxy server", zap.Error(err)) + grpcServer.Shutdown(0) } - o = append(o, compress.WithAll(compress.LevelBalanced)) - out, outh := pbsubstreamsrpcv2connect.NewEndpointInfoHandler(infoService, o...) - return out, outh } - handlerGetters = append(handlerGetters, infoHandlerGetter) - } - options = append(options, dgrpcserver.WithConnectPermissiveCORS()) - srv := connectweb.New(handlerGetters, options...) - svc.OnTerminating(func(err error) { - logger.Info("Tier1Service is terminating") - srv.Shutdown(err) - }) - servers = append(servers, srv) - cleanAddr := strings.ReplaceAll(addr, "*", "") - go func() { - srv.Launch(cleanAddr) - done <- struct{}{} }() } - <-done - for _, srv := range servers { - srv.Shutdown(nil) + logger.Info("started") + + if grpcServer != nil { + <-grpcServer.Terminating() + logger.Info("gRPC server terminated", zap.Error(grpcServer.Error())) + } + if connectServer != nil { + <-connectServer.Terminating() + logger.Info("gRPC server terminated", zap.Error(connectServer.Error())) + } + + return +} + +func grpcServer( + service *Tier1Service, + infoService pbsubstreamsrpc.EndpointInfoServer, + auth dauth.Authenticator, + healthcheck dgrpcserver.HealthCheck, + enforceCompression bool, + logger *zap.Logger, +) dgrpcserver.Server { + options := GetCommonServerOptions(logger, healthcheck, enforceCompression) + options = append(options, dgrpcserver.WithPostUnaryInterceptor(dauthgrpc.UnaryAuthChecker(auth, logger))) + options = append(options, dgrpcserver.WithPostStreamInterceptor(dauthgrpc.StreamAuthChecker(auth, logger))) + + server := factory.ServerFromOptions(options...) + pbsubstreamsrpc.RegisterStreamServer(server.ServiceRegistrar(), service) + pbsubstreamsrpcv3.RegisterStreamServer(server.ServiceRegistrar(), &v3Adapter{service}) + if infoService != nil { + pbsubstreamsrpc.RegisterEndpointInfoServer(server.ServiceRegistrar(), infoService) } - for _, srv := range servers { - <-srv.Terminated() - if e := srv.Err(); e != nil { - err = e + return server + +} + +func connectServer( + service *tier1Connect.Service, + infoService pbsubstreamsrpcv2connect.EndpointInfoHandler, + auth dauth.Authenticator, + healthcheck dgrpcserver.HealthCheck, + enforceCompression bool, + logger *zap.Logger, +) dgrpcserver.Server { + options := GetConnectCommonServerOptions(logger, healthcheck, enforceCompression) + + options = append(options, dgrpcserver.WithConnectInterceptor(dauthconnect.NewAuthInterceptor(auth, logger))) + options = append(options, dgrpcserver.WithConnectStrictContentType(false)) + options = append(options, dgrpcserver.WithConnectReflection(pbsubstreamsrpcv2connect.StreamName)) + options = append(options, dgrpcserver.WithConnectReflection(pbsubstreamsrpcv3connect.StreamName)) + options = append(options, dgrpcserver.WithConnectReflection(pbsubstreamsrpcv3connect.StreamName)) + + //todo: move compression to dgrpc :-( + + streamHandlerGetter := func(opts ...connect.HandlerOption) (string, http.Handler) { + var o []connect.HandlerOption + for _, opt := range opts { + o = append(o, opt) } + o = append(o, compress.WithAll(compress.LevelBalanced)) + return pbsubstreamsrpcv2connect.NewStreamHandler(service, o...) } - return + streamHandlerGetterV3 := func(opts ...connect.HandlerOption) (string, http.Handler) { + handler := streamHandlerV3(service.BlocksV3) + var o []connect.HandlerOption + for _, opt := range opts { + o = append(o, opt) + } + o = append(o, compress.WithAll(compress.LevelBalanced)) + return pbsubstreamsrpcv3connect.NewStreamHandler(handler, o...) + } + + handlerGetters := []connectweb.HandlerGetter{streamHandlerGetter, streamHandlerGetterV3} + + if infoService != nil { + infoHandlerGetter := func(opts ...connect.HandlerOption) (string, http.Handler) { + + var o []connect.HandlerOption + for _, opt := range opts { + o = append(o, opt) + } + o = append(o, compress.WithAll(compress.LevelBalanced)) + out, outh := pbsubstreamsrpcv2connect.NewEndpointInfoHandler(infoService, o...) + return out, outh + } + handlerGetters = append(handlerGetters, infoHandlerGetter) + } + + options = append(options, dgrpcserver.WithConnectPermissiveCORS()) + server := connectweb.New(handlerGetters, options...) + server.OnTerminating(func(err error) { + logger.Info("Tier1Service is terminating") + server.Shutdown(time.Duration(0)) + }) + return server } func ListenTier2( @@ -143,8 +252,9 @@ func ListenTier2( auth dauth.Authenticator, logger *zap.Logger, healthcheck dgrpcserver.HealthCheck, + enforceCompression bool, ) (err error) { - options := GetCommonServerOptions(addr, logger, healthcheck) + options := GetCommonServerOptions(logger, healthcheck, enforceCompression) if serviceDiscoveryURL != nil { options = append(options, dgrpcserver.WithServiceDiscoveryURL(serviceDiscoveryURL)) } @@ -152,6 +262,11 @@ func ListenTier2( dgrpcserver.WithPostUnaryInterceptor(dauthgrpc.UnaryAuthChecker(auth, logger)), dgrpcserver.WithPostStreamInterceptor(dauthgrpc.StreamAuthChecker(auth, logger)), ) + if strings.Contains(addr, "*") { + options = append(options, dgrpcserver.WithInsecureServer()) + } else { + options = append(options, dgrpcserver.WithPlainTextServer()) + } grpcServer := factory.ServerFromOptions(options...) pbssinternal.RegisterSubstreamsServer(grpcServer.ServiceRegistrar(), svc) @@ -173,3 +288,34 @@ func ListenTier2( return } + +func GetCommonServerOptions(logger *zap.Logger, healthcheck dgrpcserver.HealthCheck, enforceCompression bool) []dgrpcserver.Option { + tracerProvider := otel.GetTracerProvider() + options := []dgrpcserver.Option{ + + dgrpcserver.WithLogger(logger), + dgrpcserver.WithHealthCheck(dgrpcserver.HealthCheckOverGRPC|dgrpcserver.HealthCheckOverHTTP, healthcheck), + dgrpcserver.WithGRPCServerOptions( + grpc.StatsHandler(otelgrpc.NewServerHandler(otelgrpc.WithTracerProvider(tracerProvider))), + grpc.MaxRecvMsgSize(1024*1024*1024), + ), + } + if enforceCompression { + options = append(options, dgrpcserver.WithEnforceCompression()) + } + + return options +} + +func GetConnectCommonServerOptions(logger *zap.Logger, healthcheck dgrpcserver.HealthCheck, enforceCompression bool) []dgrpcserver.Option { + tracerProvider := otel.GetTracerProvider() + options := []dgrpcserver.Option{ + dgrpcserver.WithLogger(logger), + dgrpcserver.WithHealthCheck(dgrpcserver.HealthCheckOverGRPC|dgrpcserver.HealthCheckOverHTTP, healthcheck), + dgrpcserver.WithGRPCServerOptions( + grpc.StatsHandler(otelgrpc.NewServerHandler(otelgrpc.WithTracerProvider(tracerProvider))), + grpc.MaxRecvMsgSize(1024*1024*1024), + ), + } + return options +} diff --git a/service/testing.go b/service/testing.go index 25fe483b1..f49585d86 100644 --- a/service/testing.go +++ b/service/testing.go @@ -44,7 +44,7 @@ func (s *Tier1Service) TestBlocks(ctx context.Context, isSubRequest bool, reques return stream.NewErrInvalidArg("%s", err.Error()) } - return s.blocks(ctx, nil, request, nil, execGraph, respFunc, metrics.NewReqStats(&metrics.Config{}, nil, nil, zap.NewNop()), nil) + return s.blocks(ctx, nil, request, nil, execGraph, respFunc, metrics.NewReqStats(&metrics.Config{}, nil, nil, zap.NewNop()), nil, 0) } func TestNewServiceTier2(moduleExecutionTracing bool, streamFactoryFunc StreamFactoryFunc) *Tier2Service { diff --git a/service/tier1.go b/service/tier1.go index 2ebd1e74c..731d2a7e5 100644 --- a/service/tier1.go +++ b/service/tier1.go @@ -40,7 +40,6 @@ import ( "github.com/streamingfast/substreams/orchestrator/plan" "github.com/streamingfast/substreams/orchestrator/work" pbsubstreamsrpc "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2" - pbsubstreamsrpcv2connect "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v2/pbsubstreamsrpcv2connect" pbsubstreamsrpcv3 "github.com/streamingfast/substreams/pb/sf/substreams/rpc/v3" pbsubstreams "github.com/streamingfast/substreams/pb/sf/substreams/v1" "github.com/streamingfast/substreams/pipeline" @@ -56,7 +55,10 @@ import ( ttrace "go.opentelemetry.io/otel/trace" "go.uber.org/zap" "go.uber.org/zap/zapcore" + "google.golang.org/grpc" "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" ) @@ -64,7 +66,6 @@ var errShuttingDown = errors.New("endpoint is shutting down, please reconnect") type Tier1Service struct { *shutter.Shutter - pbsubstreamsrpcv2connect.UnimplementedStreamHandler activeRequestsWG sync.WaitGroup blockType string @@ -84,13 +85,14 @@ type Tier1Service struct { resolveCursor pipeline.CursorResolver getHeadBlock func() (uint64, error) - enforceCompression bool - activeRequestsSoftLimit int - activeRequestsHardLimit int - tier2RequestParameters reqctx.Tier2RequestParameters - foundationalEndpoints map[string]string - sessionPool dsession.SessionPool - activeRequestsManager *active_requests.ActiveRequestsManager // we keep a list of current requests for the debugAPI and to manage memory + enforceCompression bool + activeRequestsSoftLimit int + activeRequestsHardLimit int + tier2RequestParameters reqctx.Tier2RequestParameters + foundationalEndpoints map[string]string + sessionPool dsession.SessionPool + activeRequestsManager *active_requests.ActiveRequestsManager // we keep a list of current requests for the debugAPI and to manage memory + execOutMessageBufferSize int } func getBlockTypeFromStreamFactory(sf *StreamFactory) (string, error) { @@ -157,6 +159,7 @@ func NewTier1( activeRequestsSoftLimit int, activeRequestsHardLimit int, sharedCacheSize uint64, + outputBundleSize uint64, sessionPool dsession.SessionPool, foundationalEndpoints map[string]string, opts ...Option, @@ -199,21 +202,22 @@ func NewTier1( logger.Info("launching tier1 service", zap.Reflect("client_config", substreamsClientConfig), zap.String("block_type", blockType), zap.Bool("with_live", hub != nil)) s := &Tier1Service{ - Shutter: shutter.New(), - runtimeConfig: runtimeConfig, - blockType: blockType, - tracer: tracing.GetTracer(), - resolveCursor: pipeline.NewCursorResolver(hub, mergedBlocksStore, forkedBlocksStore), - logger: logger, - appSetIsReadyState: appSetIsReadyState, - tier2RequestParameters: tier2RequestParameters, - blockExecutionTimeout: 3 * time.Minute, - enforceCompression: enforceCompression, - activeRequestsSoftLimit: activeRequestsSoftLimit, - activeRequestsHardLimit: activeRequestsHardLimit, - foundationalEndpoints: foundationalEndpoints, - sessionPool: sessionPool, - activeRequestsManager: active_requests.NewActiveRequestsManager(logger), + Shutter: shutter.New(), + runtimeConfig: runtimeConfig, + blockType: blockType, + tracer: tracing.GetTracer(), + resolveCursor: pipeline.NewCursorResolver(hub, mergedBlocksStore, forkedBlocksStore), + logger: logger, + appSetIsReadyState: appSetIsReadyState, + tier2RequestParameters: tier2RequestParameters, + blockExecutionTimeout: 3 * time.Minute, + enforceCompression: enforceCompression, + activeRequestsSoftLimit: activeRequestsSoftLimit, + activeRequestsHardLimit: activeRequestsHardLimit, + foundationalEndpoints: foundationalEndpoints, + sessionPool: sessionPool, + activeRequestsManager: active_requests.NewActiveRequestsManager(logger), + execOutMessageBufferSize: int(outputBundleSize), } s.OnTerminating(func(_ error) { s.activeRequestsWG.Wait() @@ -287,25 +291,39 @@ func NewTier1( return s, nil } -func (s *Tier1Service) BlocksV3( - ctx context.Context, - req *connect.Request[pbsubstreamsrpcv3.Request], - stream *connect.ServerStream[pbsubstreamsrpc.Response], -) error { - r := req.Msg +func metadataToHeader(ctx context.Context) http.Header { + md, _ := metadata.FromIncomingContext(ctx) + h := http.Header{} + for k, vvs := range md { + hk := http.CanonicalHeaderKey(k) + for _, vv := range vvs { + h.Add(hk, vv) + } + } + return h +} + +func (s *Tier1Service) Blocks(req *pbsubstreamsrpc.Request, srv pbsubstreamsrpc.Stream_BlocksServer) error { + ctx := srv.Context() + header := metadataToHeader(ctx) + protocol := "/sf.substreams.rpc.v2.Stream/Blocks" + return s.BlocksAny(ctx, req, header, protocol, nil, srv) +} - _, err := manifest.ApplyPackageTransformations(r.Package, false, r.Network, r.OutputModule, r.Params) +func (s *Tier1Service) BlocksV3(req *pbsubstreamsrpcv3.Request, srv pbsubstreamsrpcv3.Stream_BlocksServer) error { + _, err := manifest.ApplyPackageTransformations(req.Package, false, req.Network, req.OutputModule, req.Params) if err != nil { - return err + return status.Errorf(codes.InvalidArgument, "%v", err) } - - ctx = reqctx.WithSpkg(ctx, r.Package) // passing by context is simpler for now, this could be cleaned up - reqV2, err := r.ToV2() + ctx := srv.Context() + ctx = reqctx.WithSpkg(ctx, req.Package) + v2req, err := req.ToV2() if err != nil { - return fmt.Errorf("failed to convert request to v2: %w", err) + return status.Errorf(codes.InvalidArgument, "failed to convert request to v2: %s", err) } - - return s.BlocksAny(ctx, reqV2, req.Header(), "/sf.substreams.rpc.v3.Stream/Blocks", r.Package, stream) + header := metadataToHeader(ctx) + protocol := "/sf.substreams.rpc.v3.Stream/Blocks" + return s.BlocksAny(ctx, v2req, header, protocol, req.Package, srv) } type usedStore struct { @@ -331,27 +349,19 @@ func (s *UsedFoundationalStore) MarshalLogObject(e zapcore.ObjectEncoder) error return nil } -func (s *Tier1Service) Blocks( - ctx context.Context, - req *connect.Request[pbsubstreamsrpc.Request], - stream *connect.ServerStream[pbsubstreamsrpc.Response], -) (serverErr error) { - return s.BlocksAny(ctx, req.Msg, req.Header(), "/sf.substreams.rpc.v2.Stream/Blocks", nil, stream) -} - func (s *Tier1Service) BlocksAny( ctx context.Context, request *pbsubstreamsrpc.Request, header http.Header, protocol string, pkg *pbsubstreams.Package, - stream *connect.ServerStream[pbsubstreamsrpc.Response], + stream grpc.ServerStream, ) (serverErr error) { - if s.IsTerminating() { serverErr = connect.NewError(connect.CodeUnavailable, errShuttingDown) return } + s.activeRequestsWG.Add(1) defer func() { if reason, countAsRejected := metrics.IsRejectedRequestError(serverErr); countAsRejected { @@ -398,18 +408,12 @@ func (s *Tier1Service) BlocksAny( ctx, span := reqctx.WithSpan(ctx, "substreams/tier1/request") defer span.EndWithErr(&err) - var compressed bool - if matchHeader(header) { - compressed = true - } - fields := []zap.Field{ zap.String("protocol", protocol), zap.Int64("start_block", request.StartBlockNum), zap.Uint64("stop_block", request.StopBlockNum), zap.String("cursor", request.StartCursor), zap.String("output_module", request.OutputModule), - zap.Bool("compressed", compressed), zap.Bool("final_blocks_only", request.FinalBlocksOnly), zap.Bool("production_mode", request.ProductionMode), zap.Bool("noop_mode", request.NoopMode), @@ -417,13 +421,6 @@ func (s *Tier1Service) BlocksAny( zap.Bool("partial_blocks", request.PartialBlocks), } - if s.enforceCompression && !compressed { - err := connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("your client does not accept gzip- or zstd-compressed streams. Check how to enable it on your gRPC or ConnectRPC client")) - fields = append(fields, zap.Error(err)) - logger.Info("refusing Substreams Blocks request", fields...) - return err - } - if request.Modules == nil { err := connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("missing modules in request")) fields = append(fields, zap.Error(err)) @@ -591,7 +588,7 @@ func (s *Tier1Service) BlocksAny( runningContext = reqctx.WithCancelFunc(runningContext, cancelRunning) // we pass this down so that the 'workerPool/requestPool' can cancel the running context respFunc := tier1ResponseHandler(respContext, &mut, logger, stream, request.NoopMode, reqStats, request.DevOutputModules) - err = s.blocks(runningContext, cancelRunning, request, header, execGraph, respFunc, reqStats, fields) + err = s.blocks(runningContext, cancelRunning, request, header, execGraph, respFunc, reqStats, fields, s.execOutMessageBufferSize) if connectError := toConnectError(runningContext, err); connectError != nil { switch connect.CodeOf(connectError) { @@ -612,6 +609,21 @@ func (s *Tier1Service) BlocksAny( return nil } +func compressorsFromHeader(header http.Header) (out map[string]bool) { + out = make(map[string]bool) + for k, v := range header { + petitK := strings.ToLower(k) + if petitK == "grpc-accept-encoding" || petitK == "connect-accept-encoding" || petitK == "accept-encoding" { + for _, vv := range v { + for _, vvv := range strings.Split(vv, ",") { + out[strings.ToLower(vvv)] = true + } + } + } + } + return +} + // writePackage writes the spkg to the module cache if it doesn't exist: // - `substreams.spkg.zst` if it comes from a substreams.rpc.v3 request (package is complete with metadata) // - `substreams.partial.spkg.zst` if it comes from a substreams.rpc.v2 request (package is partial, missing protobuf definitions and other metadata) @@ -666,7 +678,7 @@ func (s *Tier1Service) writeLastUsed(ctx context.Context, execGraph *exec.Graph, var IsValidCacheTag = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`).MatchString -func (s *Tier1Service) blocks(ctx context.Context, cancelRunning context.CancelCauseFunc, request *pbsubstreamsrpc.Request, header http.Header, execGraph *exec.Graph, respFunc substreams.ResponseFunc, reqStats *metrics.Stats, logFields []zap.Field) (err error) { +func (s *Tier1Service) blocks(ctx context.Context, cancelRunning context.CancelCauseFunc, request *pbsubstreamsrpc.Request, header http.Header, execGraph *exec.Graph, respFunc substreams.ResponseFunc, reqStats *metrics.Stats, logFields []zap.Field, execOutMessageBufferSize int) (err error) { chainFirstStreamableBlock := bstream.GetProtocolFirstStreamableBlock if request.StartBlockNum > 0 && request.StartBlockNum < int64(chainFirstStreamableBlock) { return bsstream.NewErrInvalidArg("invalid start block %d, must be >= %d (the first streamable block of the chain)", request.StartBlockNum, chainFirstStreamableBlock) @@ -835,6 +847,7 @@ func (s *Tier1Service) blocks(ctx context.Context, cancelRunning context.CancelC return s.IsTerminating() // pipeline starts draining when the service is actually terminating, (after the global shutdown-signal-delay) }, s.foundationalEndpoints, + execOutMessageBufferSize, opts..., ) @@ -1088,7 +1101,15 @@ func configureLiveBackFillerFromQuickload(ctx context.Context, segmentSize uint6 return nil } -func tier1ResponseHandler(ctx context.Context, mut *sync.Mutex, logger *zap.Logger, streamSrv *connect.ServerStream[pbsubstreamsrpc.Response], noop bool, stats *metrics.Stats, debugOutputForModules []string) substreams.ResponseFunc { +func tier1ResponseHandler( + ctx context.Context, + mut *sync.Mutex, + logger *zap.Logger, + streamSrv grpc.ServerStream, + noop bool, + stats *metrics.Stats, + debugOutputForModules []string, +) substreams.ResponseFunc { auth := dauth.FromContext(ctx) organizationID := auth.OrganizationID() apiKeyID := auth.APIKeyID() @@ -1112,6 +1133,7 @@ func tier1ResponseHandler(ctx context.Context, mut *sync.Mutex, logger *zap.Logg } } + //var buffer []*pbsubstreamsrpc.BlockScopedData return func(respAny substreams.ResponseFromAnyTier) error { resp := respAny.(*pbsubstreamsrpc.Response) mut.Lock() @@ -1153,7 +1175,7 @@ func tier1ResponseHandler(ctx context.Context, mut *sync.Mutex, logger *zap.Logg egressBytes := proto.Size(resp) begin := time.Now() - if err := streamSrv.Send(resp); err != nil { + if err := streamSrv.SendMsg(resp); err != nil { logger.Info("unable to send block probably due to client disconnecting", zap.String("user_id", organizationID), zap.String("api_key_id", apiKeyID), zap.Error(err)) return connect.NewError(connect.CodeUnavailable, err) } @@ -1360,28 +1382,6 @@ func toConnectError(ctx context.Context, err error) error { return connect.NewError(connect.CodeInternal, err) } -// must be lowercase -var compressionHeader = map[string]map[string]bool{ - "grpc-accept-encoding": {"gzip": true, "zstd": true}, - "connect-accept-encoding": {"gzip": true, "zstd": true}, - "accept-encoding": {"gzip": true}, // HTTP encoding for connect+proto in browser -} - -func matchHeader(header http.Header) bool { - for k, v := range header { - if validEncodings, ok := compressionHeader[strings.ToLower(k)]; ok { - for _, vv := range v { - for _, vvv := range strings.Split(vv, ",") { - if validEncodings[strings.TrimSpace(strings.ToLower(vvv))] { - return true - } - } - } - } - } - return false -} - type overloadingStatus struct { // set only if either soft or hard limit set is > 0 activeRequestCount int diff --git a/service/tier2.go b/service/tier2.go index 1269a2ea2..5702b37b1 100644 --- a/service/tier2.go +++ b/service/tier2.go @@ -521,6 +521,7 @@ func (s *Tier2Service) processRange(ctx context.Context, request *pbssinternal.P s.blockExecutionTimeout, s.checkPendingShutdown, request.FoundationalStoreEndpoints, + 0, opts..., ) diff --git a/sink/sinker.go b/sink/sinker.go index d1eef9661..85200e688 100644 --- a/sink/sinker.go +++ b/sink/sinker.go @@ -28,6 +28,7 @@ import ( "go.uber.org/zap" "google.golang.org/grpc" "google.golang.org/grpc/codes" + _ "google.golang.org/grpc/experimental" "google.golang.org/grpc/metadata" "google.golang.org/protobuf/proto" ) @@ -481,6 +482,9 @@ func (s *Sinker) doRequest( s.Logger.Debug("launching substreams request", zap.Int64("start_block", req.StartBlockNum), zap.Stringer("cursor", activeCursor)) receivedDataMessage := false + //md := metadata.Pairs("grpc-accept-encoding", "s2,identity") + //ctx = metadata.NewOutgoingContext(ctx, md) + var stream grpc.ServerStreamingClient[pbsubstreamsrpc.Response] var err error @@ -629,76 +633,20 @@ func (s *Sinker) doRequest( s.Logger.Debug("received response Progress", zap.Reflect("progress", r)) } + case *pbsubstreamsrpc.Response_BlockScopedDatas: + for idx, item := range r.BlockScopedDatas.Items { + if activeCursor, receivedDataMessage, err = s.processBlockScopedData(ctx, handler, item, idx == 0, beforeReceive, &prevBlockTime, activeCursor); err != nil { + return activeCursor, receivedDataMessage, err + } + afterReceive = time.Now() + lastMessageWasData = true + } case *pbsubstreamsrpc.Response_BlockScopedData: - receivedDataMessage = true - if cursorLivenessChecker, ok := s.LivenessChecker.(*CursorBasedLivenessChecker); ok { - cursorLivenessChecker.CheckCursor(r.BlockScopedData.Cursor) + if activeCursor, receivedDataMessage, err = s.processBlockScopedData(ctx, handler, r.BlockScopedData, true, beforeReceive, &prevBlockTime, activeCursor); err != nil { + return activeCursor, receivedDataMessage, err } - afterReceive = time.Now() lastMessageWasData = true - AvgBlockWaitTime.AddElapsedTime(beforeReceive) - BlockWaitTime.SetFloat64(AvgBlockWaitTime.Average().Seconds()) - - blockTime := r.BlockScopedData.Clock.Timestamp.AsTime() - if !prevBlockTime.IsZero() { - AvgBlockTimeDelta.AddDuration(blockTime.Sub(prevBlockTime)) - BlockTimeDelta.SetFloat64(AvgBlockTimeDelta.Average().Seconds()) - } - prevBlockTime = blockTime - - block := bstream.NewBlockRef(r.BlockScopedData.Clock.Id, r.BlockScopedData.Clock.Number) - moduleOutput := r.BlockScopedData.Output - - if s.Tracer.Enabled() { - s.Logger.Debug("received response BlockScopedData", zap.Stringer("at", block), zap.String("module_name", moduleOutput.Name), zap.Int("payload_bytes", len(moduleOutput.MapOutput.Value))) - } - - // We record our stats before the buffer action, so user sees state of "stream" and not state of buffer - s.stats.RecordBlock(block) - HeadBlockNumber.SetUint64(block.Num()) - HeadBlockTimeDrift.SetBlockTime(r.BlockScopedData.Clock.Timestamp.AsTime()) - DataMessageCount.Inc() - ServerEgressBytes.AddInt(proto.Size(r.BlockScopedData)) - BackprocessingCompletion.SetUint64(1) - - cursor, err := NewCursor(r.BlockScopedData.Cursor) - if err != nil { - return activeCursor, receivedDataMessage, fmt.Errorf("invalid received cursor, 'bstream' library in here is probably not up to date: %w", err) - } - - activeCursor = cursor - - var dataToProcess []*pbsubstreamsrpc.BlockScopedData - if s.buffer == nil { - // No buffering, process directly - dataToProcess = []*pbsubstreamsrpc.BlockScopedData{r.BlockScopedData} - } else { - dataToProcess, err = s.buffer.HandleBlockScopedData(r.BlockScopedData) - if err != nil { - return activeCursor, receivedDataMessage, fmt.Errorf("buffer add block data: %w", err) - } - } - - for _, blockScopedData := range dataToProcess { - currentCursor, err := NewCursor(blockScopedData.Cursor) - if err != nil { - return activeCursor, receivedDataMessage, fmt.Errorf("invalid received cursor, 'bstream' library in here is probably not up to date: %w", err) - } - - var isLive *bool - if s.LivenessChecker != nil { - isLive = &blockNotLive - if s.LivenessChecker.IsLive(blockScopedData.Clock) { - isLive = &liveBlock - } - s.stats.SetLiveness(isLive) - } - - if err := handler.HandleBlockScopedData(ctx, blockScopedData, isLive, currentCursor); err != nil { - return activeCursor, receivedDataMessage, fmt.Errorf("handle BlockScopedData message at block %s: %w", block, err) - } - } case *pbsubstreamsrpc.Response_BlockUndoSignal: undoSignal := r.BlockUndoSignal @@ -776,6 +724,89 @@ func (s *Sinker) doRequest( } } +func (s *Sinker) processBlockScopedData( + ctx context.Context, + handler SinkerHandler, + data *pbsubstreamsrpc.BlockScopedData, + isFirstItem bool, + beforeReceive time.Time, + prevBlockTime *time.Time, + activeCursor *Cursor, +) (newCursor *Cursor, receivedDataMessage bool, err error) { + receivedDataMessage = true + if cursorLivenessChecker, ok := s.LivenessChecker.(*CursorBasedLivenessChecker); ok { + cursorLivenessChecker.CheckCursor(data.Cursor) + } + + if isFirstItem { + AvgBlockWaitTime.AddElapsedTime(beforeReceive) + BlockWaitTime.SetFloat64(AvgBlockWaitTime.Average().Seconds()) + } + + blockTime := data.Clock.Timestamp.AsTime() + if !prevBlockTime.IsZero() { + AvgBlockTimeDelta.AddDuration(blockTime.Sub(*prevBlockTime)) + BlockTimeDelta.SetFloat64(AvgBlockTimeDelta.Average().Seconds()) + } + *prevBlockTime = blockTime + + block := bstream.NewBlockRef(data.Clock.Id, data.Clock.Number) + moduleOutput := data.Output + + if s.Tracer.Enabled() { + s.Logger.Debug("received response BlockScopedData", zap.Stringer("at", block), zap.String("module_name", moduleOutput.Name), zap.Int("payload_bytes", len(moduleOutput.MapOutput.Value))) + } + + // We record our stats before the buffer action, so user sees state of "stream" and not state of buffer + s.stats.RecordBlock(block) + HeadBlockNumber.SetUint64(block.Num()) + HeadBlockTimeDrift.SetBlockTime(data.Clock.Timestamp.AsTime()) + DataMessageCount.Inc() + ServerEgressBytes.AddInt(proto.Size(data)) + BackprocessingCompletion.SetUint64(1) + + cursor, err := NewCursor(data.Cursor) + if err != nil { + return activeCursor, receivedDataMessage, fmt.Errorf("invalid received cursor, 'bstream' library in here is probably not up to date: %w", err) + } + + activeCursor = cursor + + var dataToProcess []*pbsubstreamsrpc.BlockScopedData + if s.buffer == nil { + // No buffering, process directly + dataToProcess = []*pbsubstreamsrpc.BlockScopedData{data} + } else { + var err error + dataToProcess, err = s.buffer.HandleBlockScopedData(data) + if err != nil { + return activeCursor, receivedDataMessage, fmt.Errorf("buffer add block data: %w", err) + } + } + + for _, blockScopedData := range dataToProcess { + currentCursor, err := NewCursor(blockScopedData.Cursor) + if err != nil { + return activeCursor, receivedDataMessage, fmt.Errorf("invalid received cursor, 'bstream' library in here is probably not up to date: %w", err) + } + + var isLive *bool + if s.LivenessChecker != nil { + isLive = &blockNotLive + if s.LivenessChecker.IsLive(blockScopedData.Clock) { + isLive = &liveBlock + } + s.stats.SetLiveness(isLive) + } + + if err := handler.HandleBlockScopedData(ctx, blockScopedData, isLive, currentCursor); err != nil { + return activeCursor, receivedDataMessage, fmt.Errorf("handle BlockScopedData message at block %s: %w", block, err) + } + } + + return activeCursor, true, nil +} + func stageString(i uint32) string { return fmt.Sprintf("stage %d", i) } diff --git a/tests_e2e/go.mod b/tests_e2e/go.mod index acda185b1..8f6204de0 100644 --- a/tests_e2e/go.mod +++ b/tests_e2e/go.mod @@ -4,7 +4,7 @@ go 1.25.0 require ( github.com/docker/docker v28.2.2+incompatible - github.com/streamingfast/bstream v0.0.2-0.20260204202442-c5bd9b2dffea + github.com/streamingfast/bstream v0.0.2-0.20260211203220-e95f72b706fa github.com/streamingfast/dauth v0.0.0-20251218134044-fb716c7172b4 github.com/streamingfast/dmetering v0.0.0-20251027175535-4fd530934b97 github.com/streamingfast/dmetrics v0.0.0-20260109212625-35256f512c62 @@ -150,6 +150,7 @@ require ( github.com/paulbellamy/ratecounter v0.2.0 // indirect github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect github.com/pelletier/go-toml/v2 v2.0.6 // indirect + github.com/pierrec/lz4/v4 v4.1.21 // indirect github.com/pinax-network/graph-networks-libs/packages/golang v0.7.0 // indirect github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect github.com/pkg/errors v0.9.1 // indirect @@ -179,7 +180,7 @@ require ( github.com/streamingfast/cli v0.0.4-0.20250815192146-d8a233ec3d0b // indirect github.com/streamingfast/dbin v0.9.1-0.20231117225723-59790c798e2c // indirect github.com/streamingfast/derr v0.0.0-20250814163534-bd7407bd89d7 // indirect - github.com/streamingfast/dgrpc v0.0.0-20251218142640-027692a12722 // indirect + github.com/streamingfast/dgrpc v0.0.0-20260211171202-db61f19b4ebd // indirect github.com/streamingfast/dstore v0.1.3-0.20260113210117-94d66eda2027 // indirect github.com/streamingfast/dummy-blockchain v1.7.3 // indirect github.com/streamingfast/firehose-ethereum/types v0.0.0-20251113151010-c9c94d64348a // indirect diff --git a/tests_e2e/go.sum b/tests_e2e/go.sum index 5b2426233..8c5fbf9ac 100644 --- a/tests_e2e/go.sum +++ b/tests_e2e/go.sum @@ -467,6 +467,8 @@ github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 h1:onHthvaw9LFnH4t2D github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y= github.com/pelletier/go-toml/v2 v2.0.6 h1:nrzqCb7j9cDFj2coyLNLaZuJTLjWjlaz6nvTvIwycIU= github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek= +github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ= +github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= github.com/pinax-network/graph-networks-libs/packages/golang v0.7.0 h1:chRRgzgzmFzICbB/8ybY1IDqvxVgjV415M0AsIYmUHQ= github.com/pinax-network/graph-networks-libs/packages/golang v0.7.0/go.mod h1:G76L6ql7YCygVzN45BmtSBqA+qwcDuFWMM42tDnGJbE= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= @@ -528,8 +530,8 @@ github.com/spf13/viper v1.15.0 h1:js3yy885G8xwJa6iOISGFwd+qlUo5AvyXb7CiihdtiU= github.com/spf13/viper v1.15.0/go.mod h1:fFcTBJxvhhzSJiZy8n+PeW6t8l+KeT/uTARa0jHOQLA= github.com/spiffe/go-spiffe/v2 v2.6.0 h1:l+DolpxNWYgruGQVV0xsfeya3CsC7m8iBzDnMpsbLuo= github.com/spiffe/go-spiffe/v2 v2.6.0/go.mod h1:gm2SeUoMZEtpnzPNs2Csc0D/gX33k1xIx7lEzqblHEs= -github.com/streamingfast/bstream v0.0.2-0.20260204202442-c5bd9b2dffea h1:3es4i3DiOMvy/B+leJzuGGbIbzQVKik0P25cgZI5e04= -github.com/streamingfast/bstream v0.0.2-0.20260204202442-c5bd9b2dffea/go.mod h1:0sed+gw+d62tBsGl5omaB1m14Gmfvb3YAs4epHuL1YU= +github.com/streamingfast/bstream v0.0.2-0.20260211203220-e95f72b706fa h1:ih8oxMICJfr/WVoowKeyATHvZ0lbU8+tQCDCgkwJMGU= +github.com/streamingfast/bstream v0.0.2-0.20260211203220-e95f72b706fa/go.mod h1:9NVnl3l3Wljoll+cQb8sccVa078E1m1CgBCFzttGha0= github.com/streamingfast/cli v0.0.4-0.20250815192146-d8a233ec3d0b h1:ztYeX3/5rg2tV2EU7edcrcHzMz6wUbdJB+LqCrP5W8s= github.com/streamingfast/cli v0.0.4-0.20250815192146-d8a233ec3d0b/go.mod h1:o9R/tjNON01X2mgWL5qirl2MV6xQ4EZI5D504ST3K/M= github.com/streamingfast/dauth v0.0.0-20251218134044-fb716c7172b4 h1:qJmiXzqs3T7124+FXEnhPgK/3fbSjqjQuBTdIrUk4Oc= @@ -538,8 +540,8 @@ github.com/streamingfast/dbin v0.9.1-0.20231117225723-59790c798e2c h1:6WjE2yInE+ github.com/streamingfast/dbin v0.9.1-0.20231117225723-59790c798e2c/go.mod h1:dbfiy9ORrL8c6ldSq+L0H9pg8TOqqu/FsghsgUEWK54= github.com/streamingfast/derr v0.0.0-20250814163534-bd7407bd89d7 h1:KeyhmbdPhEzot+On1XrHSAOmRoeyIRiM0EkGQAqnVxI= github.com/streamingfast/derr v0.0.0-20250814163534-bd7407bd89d7/go.mod h1:QSm/AfaDsE0k1xBYi0lW580YJ/WDV/FKZI628tkZR0Y= -github.com/streamingfast/dgrpc v0.0.0-20251218142640-027692a12722 h1:gZcPR64H5aWs49bLDoNTjhsedTfva7fAIei891LL0C8= -github.com/streamingfast/dgrpc v0.0.0-20251218142640-027692a12722/go.mod h1:NbkvenEHfjQpUBRHTCp/tp0Ayjp5hDzzkv/Ve9Uka1I= +github.com/streamingfast/dgrpc v0.0.0-20260211171202-db61f19b4ebd h1:LRu2q7HnzkU/G+K3/m1VrXDszUS8G47v9qAuDI56BXQ= +github.com/streamingfast/dgrpc v0.0.0-20260211171202-db61f19b4ebd/go.mod h1:NQH6mtw4wGmYanNywYMbmTZcMbvJCVYX/7pFwiiGinI= github.com/streamingfast/dmetering v0.0.0-20251027175535-4fd530934b97 h1:rXZYa87AFt+kluwe4McC9jZgx/eRNSlOkWQaIj9Yv4w= github.com/streamingfast/dmetering v0.0.0-20251027175535-4fd530934b97/go.mod h1:UqWuX3REU/IInBUaymFN2eLjuvz+/0SsoUFjeQlLNyI= github.com/streamingfast/dmetrics v0.0.0-20260109212625-35256f512c62 h1:Tb4T34ImY7qvyrmW53/9ca5CxrXRThuFP1qx64i6FGk= diff --git a/types.go b/types.go index bdc39ff02..d264a6d72 100644 --- a/types.go +++ b/types.go @@ -18,6 +18,11 @@ func NewBlockScopedDataResponse(in *pbsubstreamsrpc.BlockScopedData) *pbsubstrea Message: &pbsubstreamsrpc.Response_BlockScopedData{BlockScopedData: in}, } } +func NewBlockScopedDatasResponse(in *pbsubstreamsrpc.BlockScopedDatas) *pbsubstreamsrpc.Response { + return &pbsubstreamsrpc.Response{ + Message: &pbsubstreamsrpc.Response_BlockScopedDatas{BlockScopedDatas: in}, + } +} func NewBlockScopedDataInternResponse(in *pbssinternal.BlockScopedData) *pbssinternal.ProcessRangeResponse { return &pbssinternal.ProcessRangeResponse{ Type: &pbssinternal.ProcessRangeResponse_BlockScopedData{BlockScopedData: in},