diff --git a/Makefile b/Makefile index 57721c1..352f805 100644 --- a/Makefile +++ b/Makefile @@ -30,7 +30,7 @@ cover: deps: @echo "--> Installing dependencies" @go mod download -# @make proto-gen + @make proto-gen @go mod tidy .PHONY: deps @@ -65,17 +65,14 @@ test: vet @go test -v -race -covermode=atomic -coverprofile=coverage.txt $(pkgs) -run $(run) -count=$(count) .PHONY: test -# protobuf related targets will be uncommented while working on https://github.com/rollkit/go-da/issues/5 - ## proto-gen: Generate protobuf files. Requires docker. proto-gen: @echo "--> Generating Protobuf files" -# ./proto/get_deps.sh -# ./proto/gen.sh -#.PHONY: proto-gen -# + ./proto/gen.sh +.PHONY: proto-gen + ## proto-lint: Lint protobuf files. Requires docker. proto-lint: @echo "--> Linting Protobuf files" -# @$(DOCKER_BUF) lint --error-format=json -#.PHONY: proto-lint + @$(DOCKER_BUF) lint --error-format=json +.PHONY: proto-lint diff --git a/buf.gen.yaml b/buf.gen.yaml new file mode 100644 index 0000000..121e7f5 --- /dev/null +++ b/buf.gen.yaml @@ -0,0 +1,10 @@ +version: v1beta1 + +# The plugins to run. +plugins: + # The name of the plugin. + - name: gogofaster + # The the relative output directory. + out: types/pb + # Any options to provide to the plugin. + opt: plugins=grpc,paths=source_relative diff --git a/buf.yaml b/buf.yaml new file mode 100644 index 0000000..fc7ba0b --- /dev/null +++ b/buf.yaml @@ -0,0 +1,27 @@ +version: v1beta1 + +build: + roots: + - proto + - third_party/proto +lint: + use: + - DEFAULT + - COMMENTS + - FILE_LOWER_SNAKE_CASE + except: + - COMMENT_ENUM + - COMMENT_ENUM_VALUE + - COMMENT_MESSAGE + - COMMENT_RPC + - COMMENT_SERVICE + - COMMENT_FIELD + - PACKAGE_VERSION_SUFFIX + - RPC_REQUEST_STANDARD_NAME + - SERVICE_SUFFIX + - UNARY_RPC + ignore: + - tendermint +breaking: + use: + - FILE diff --git a/da_test.go b/da_test.go index 95c4a47..8dde143 100644 --- a/da_test.go +++ b/da_test.go @@ -1,136 +1,12 @@ package da_test import ( - "bytes" "testing" - "time" "github.com/rollkit/go-da/test" - - "github.com/stretchr/testify/assert" - - "github.com/rollkit/go-da" ) func TestDummyDA(t *testing.T) { dummy := test.NewDummyDA() - RunDATestSuite(t, dummy) -} - -func RunDATestSuite(t *testing.T, dummy *test.DummyDA) { - t.Run("Basic DA test", func(t *testing.T) { - BasicDATest(t, dummy) - }) - t.Run("Get IDs and all data", func(t *testing.T) { - GetIDsTest(t, dummy) - }) - t.Run("Check Errors", func(t *testing.T) { - CheckErrors(t, dummy) - }) -} - -// TODO(tzdybal): how to get rid of this?! -type Blob = da.Blob -type ID = da.ID - -func BasicDATest(t *testing.T, da da.DA) { - msg1 := []byte("message 1") - msg2 := []byte("message 2") - - id1, proof1, err := da.Submit([]Blob{msg1}) - assert.NoError(t, err) - assert.NotEmpty(t, id1) - assert.NotEmpty(t, proof1) - - id2, proof2, err := da.Submit([]Blob{msg2}) - assert.NoError(t, err) - assert.NotEmpty(t, id2) - assert.NotEmpty(t, proof2) - - id3, proof3, err := da.Submit([]Blob{msg1}) - assert.NoError(t, err) - assert.NotEmpty(t, id3) - assert.NotEmpty(t, proof3) - - assert.NotEqual(t, id1, id2) - assert.NotEqual(t, id1, id3) - - ret, err := da.Get(id1) - assert.NoError(t, err) - assert.Equal(t, []Blob{msg1}, ret) - - commitment1, err := da.Commit([]Blob{msg1}) - assert.NoError(t, err) - assert.NotEmpty(t, commitment1) - - commitment2, err := da.Commit([]Blob{msg2}) - assert.NoError(t, err) - assert.NotEmpty(t, commitment2) - - oks, err := da.Validate(id1, proof1) - assert.NoError(t, err) - assert.NotEmpty(t, oks) - for _, ok := range oks { - assert.True(t, ok) - } - - oks, err = da.Validate(id2, proof2) - assert.NoError(t, err) - assert.NotEmpty(t, oks) - for _, ok := range oks { - assert.True(t, ok) - } - - oks, err = da.Validate(id1, proof2) - assert.NoError(t, err) - assert.NotEmpty(t, oks) - for _, ok := range oks { - assert.False(t, ok) - } - - oks, err = da.Validate(id2, proof1) - assert.NoError(t, err) - assert.NotEmpty(t, oks) - for _, ok := range oks { - assert.False(t, ok) - } -} - -func CheckErrors(t *testing.T, da da.DA) { - blob, err := da.Get([]ID{[]byte("invalid")}) - assert.Error(t, err) - assert.Empty(t, blob) -} - -func GetIDsTest(t *testing.T, da da.DA) { - msgs := [][]byte{[]byte("msg1"), []byte("msg2"), []byte("msg3")} - - ids, proofs, err := da.Submit(msgs) - assert.NoError(t, err) - assert.Len(t, ids, len(msgs)) - assert.Len(t, proofs, len(msgs)) - - found := false - end := time.Now().Add(1 * time.Second) - for i := uint64(1); !found && !time.Now().After(end); i++ { - ret, err := da.GetIDs(i) - if err != nil { - t.Error("failed to get IDs:", err) - } - if len(ret) > 0 { - blobs, err := da.Get(ret) - assert.NoError(t, err) - - if len(blobs) == len(msgs) { - found = true - for b := 0; b < len(blobs); b++ { - if !bytes.Equal(blobs[b], msgs[b]) { - found = false - } - } - } - } - } - - assert.True(t, found) + test.RunDATestSuite(t, dummy) } diff --git a/go.mod b/go.mod index 3eee911..f56607a 100644 --- a/go.mod +++ b/go.mod @@ -2,10 +2,20 @@ module github.com/rollkit/go-da go 1.21.1 -require github.com/stretchr/testify v1.8.4 +require ( + github.com/gogo/protobuf v1.3.2 + github.com/stretchr/testify v1.8.4 + google.golang.org/grpc v1.58.3 +) require ( github.com/davecgh/go-spew v1.1.1 // indirect + github.com/golang/protobuf v1.5.3 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect + golang.org/x/net v0.12.0 // indirect + golang.org/x/sys v0.10.0 // indirect + golang.org/x/text v0.11.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98 // indirect + google.golang.org/protobuf v1.31.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index fa4b6e6..1a664ce 100644 --- a/go.sum +++ b/go.sum @@ -1,9 +1,60 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50= +golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA= +golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4= +golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98 h1:bVf09lpb+OJbByTj913DRJioFFAjf/ZGxEz7MajTp2U= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98/go.mod h1:TUfxEVdsvPg18p6AslUXFoLdpED4oBnGwyqk3dV1XzM= +google.golang.org/grpc v1.58.3 h1:BjnpXut1btbtgN/6sp+brB2Kbm2LjNXnidYujAVbSoQ= +google.golang.org/grpc v1.58.3/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= +google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/proto/da/da.proto b/proto/da/da.proto new file mode 100644 index 0000000..4e42c56 --- /dev/null +++ b/proto/da/da.proto @@ -0,0 +1,92 @@ +syntax = "proto3"; +package da; + +// DAService is the protobuf service definition for interaction with Data Availability layers. +service DAService { + // Get returns Blob for each given ID, or an error. + rpc Get(GetRequest) returns (GetResponse) {} + + // GetIDs returns IDs of all Blobs located in DA at given height. + rpc GetIDs(GetIDsRequest) returns (GetIDsResponse) {} + + // Commit creates a Commitment for each given Blob. + rpc Commit(CommitRequest) returns (CommitResponse) {} + + // Submit submits the given Blobs to Data Availability layer. + rpc Submit(SubmitRequest) returns (SubmitResponse) {} + + // Validate validates Commitments against corresponding Proofs. This should be possible without retrieving Blob. + rpc Validate(ValidateRequest) returns (ValidateResponse) {} +} + +// Blob is the data submitted/received from DA interface. +message Blob { + bytes value = 1; +} + +// ID should contain serialized data required by the implementation to find blob in Data Availability layer. +message ID { + bytes value = 1; +} + +// Commitment should contain serialized cryptographic commitment to Blob value. +message Commitment { + bytes value = 1; +} + +// Proof should contain serialized proof of inclusion (publication) of Blob in Data Availability layer. +message Proof { + bytes value = 1; +} + +// GetRequest is the request type for the Get rpc method. +message GetRequest { + repeated ID ids = 1; +} + +// GetResponse is the response type for the Get rpc method. +message GetResponse { + repeated Blob blobs = 1; +} + +// GetIDsRequest is the request type for the GetIDs rpc method. +message GetIDsRequest { + uint64 height = 1; +} + +// GetIDsResponse is the response type for the GetIDs rpc method. +message GetIDsResponse { + repeated ID ids = 1; +} + +// CommitRequest is the request type for the Commit rpc method. +message CommitRequest { + repeated Blob blobs = 1; +} + +// CommitResponse is the response type for the Commit rpc method. +message CommitResponse { + repeated Commitment commitments = 1; +} + +// SubmitRequest is the request type for the Submit rpc method. +message SubmitRequest { + repeated Blob blobs = 1; +} + +// SubmitResponse is the response type for the Submit rpc method. +message SubmitResponse { + repeated ID ids = 1; + repeated Proof proofs = 2; +} + +// ValidateRequest is the request type for the Validate rpc method. +message ValidateRequest { + repeated ID ids = 1; + repeated Proof proofs = 2; +} + +// ValidateResponse is the response type for the Validate rpc method. +message ValidateResponse { + repeated bool results = 1; +} \ No newline at end of file diff --git a/proto/gen.sh b/proto/gen.sh new file mode 100755 index 0000000..a34875d --- /dev/null +++ b/proto/gen.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +# see: https://stackoverflow.com/a/246128 +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"/.. +TARGET_DIR=./types/pb + +cd $SCRIPT_DIR +mkdir -p $TARGET_DIR +rm -rf $TARGET_DIR/* +docker run -u $UID:$(id -g) -e XDG_CACHE_HOME=/tmp/.cache -v $PWD:/workspace --workdir /workspace tendermintdev/docker-build-proto sh ./proto/protoc.sh \ No newline at end of file diff --git a/proto/protoc.sh b/proto/protoc.sh new file mode 100644 index 0000000..562ac0d --- /dev/null +++ b/proto/protoc.sh @@ -0,0 +1,5 @@ +#!/usr/bin/env bash + +set -eo pipefail + +buf generate --path="./proto/da" --template="buf.gen.yaml" --config="buf.yaml" \ No newline at end of file diff --git a/proxy/client.go b/proxy/client.go new file mode 100644 index 0000000..d3580e0 --- /dev/null +++ b/proxy/client.go @@ -0,0 +1,110 @@ +package proxy + +import ( + "context" + + "google.golang.org/grpc" + + "github.com/rollkit/go-da" + pbda "github.com/rollkit/go-da/types/pb/da" +) + +// Client is a gRPC proxy client for DA interface. +type Client struct { + conn *grpc.ClientConn + + client pbda.DAServiceClient +} + +// NewClient returns new Client instance. +func NewClient() *Client { + return &Client{} +} + +// Start connects Client to target, with given options. +func (c *Client) Start(target string, opts ...grpc.DialOption) (err error) { + c.conn, err = grpc.Dial(target, opts...) + if err != nil { + return err + } + c.client = pbda.NewDAServiceClient(c.conn) + + return nil +} + +// Stop gently closes Client connection. +func (c *Client) Stop() error { + return c.conn.Close() +} + +// Get returns Blob for each given ID, or an error. +func (c *Client) Get(ids []da.ID) ([]da.Blob, error) { + req := &pbda.GetRequest{ + Ids: make([]*pbda.ID, len(ids)), + } + for i := range ids { + req.Ids[i] = &pbda.ID{Value: ids[i]} + } + resp, err := c.client.Get(context.TODO(), req) + if err != nil { + return nil, err + } + + return blobsPB2DA(resp.Blobs), nil +} + +// GetIDs returns IDs of all Blobs located in DA at given height. +func (c *Client) GetIDs(height uint64) ([]da.ID, error) { + req := &pbda.GetIDsRequest{Height: height} + resp, err := c.client.GetIDs(context.TODO(), req) + if err != nil { + return nil, err + } + + return idsPB2DA(resp.Ids), nil +} + +// Commit creates a Commitment for each given Blob. +func (c *Client) Commit(blobs []da.Blob) ([]da.Commitment, error) { + req := &pbda.CommitRequest{ + Blobs: blobsDA2PB(blobs), + } + + resp, err := c.client.Commit(context.TODO(), req) + if err != nil { + return nil, err + } + + return commitsPB2DA(resp.Commitments), nil +} + +// Submit submits the Blobs to Data Availability layer. +func (c *Client) Submit(blobs []da.Blob) ([]da.ID, []da.Proof, error) { + req := &pbda.SubmitRequest{ + Blobs: blobsDA2PB(blobs), + } + + resp, err := c.client.Submit(context.TODO(), req) + if err != nil { + return nil, nil, err + } + + ids := make([]da.ID, len(resp.Ids)) + proofs := make([]da.Proof, len(resp.Proofs)) + for i := range resp.Ids { + ids[i] = resp.Ids[i].Value + proofs[i] = resp.Proofs[i].Value + } + + return ids, proofs, nil +} + +// Validate validates Commitments against the corresponding Proofs. This should be possible without retrieving the Blobs. +func (c *Client) Validate(ids []da.ID, proofs []da.Proof) ([]bool, error) { + req := &pbda.ValidateRequest{ + Ids: idsDA2PB(ids), + Proofs: proofsDA2PB(proofs), + } + resp, err := c.client.Validate(context.TODO(), req) + return resp.Results, err +} diff --git a/proxy/proxy_test.go b/proxy/proxy_test.go new file mode 100644 index 0000000..0322678 --- /dev/null +++ b/proxy/proxy_test.go @@ -0,0 +1,28 @@ +package proxy_test + +import ( + "net" + "testing" + + "github.com/stretchr/testify/require" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials/insecure" + + "github.com/rollkit/go-da/proxy" + "github.com/rollkit/go-da/test" +) + +func TestProxy(t *testing.T) { + dummy := test.NewDummyDA() + server := proxy.NewServer(dummy, grpc.Creds(insecure.NewCredentials())) + lis, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + go func() { + _ = server.Serve(lis) + }() + + client := proxy.NewClient() + err = client.Start(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials())) + require.NoError(t, err) + test.RunDATestSuite(t, client) +} diff --git a/proxy/server.go b/proxy/server.go new file mode 100644 index 0000000..ae77daf --- /dev/null +++ b/proxy/server.go @@ -0,0 +1,82 @@ +package proxy + +import ( + "context" + + "google.golang.org/grpc" + + "github.com/rollkit/go-da" + pbda "github.com/rollkit/go-da/types/pb/da" +) + +// NewServer creates new gRPC Server configured to serve DA proxy. +func NewServer(d da.DA, opts ...grpc.ServerOption) *grpc.Server { + srv := grpc.NewServer(opts...) + + proxy := &proxySrv{target: d} + + pbda.RegisterDAServiceServer(srv, proxy) + + return srv +} + +type proxySrv struct { + target da.DA +} + +func (p *proxySrv) Get(ctx context.Context, request *pbda.GetRequest) (*pbda.GetResponse, error) { + ids := idsPB2DA(request.Ids) + blobs, err := p.target.Get(ids) + return &pbda.GetResponse{Blobs: blobsDA2PB(blobs)}, err +} + +func (p *proxySrv) GetIDs(ctx context.Context, request *pbda.GetIDsRequest) (*pbda.GetIDsResponse, error) { + ids, err := p.target.GetIDs(request.Height) + if err != nil { + return nil, err + } + + return &pbda.GetIDsResponse{Ids: idsDA2PB(ids)}, nil +} + +func (p *proxySrv) Commit(ctx context.Context, request *pbda.CommitRequest) (*pbda.CommitResponse, error) { + blobs := blobsPB2DA(request.Blobs) + commits, err := p.target.Commit(blobs) + if err != nil { + return nil, err + } + + return &pbda.CommitResponse{Commitments: commitsDA2PB(commits)}, nil +} + +func (p *proxySrv) Submit(ctx context.Context, request *pbda.SubmitRequest) (*pbda.SubmitResponse, error) { + blobs := blobsPB2DA(request.Blobs) + + ids, proofs, err := p.target.Submit(blobs) + if err != nil { + return nil, err + } + + resp := &pbda.SubmitResponse{ + Ids: make([]*pbda.ID, len(ids)), + Proofs: make([]*pbda.Proof, len(proofs)), + } + + for i := range ids { + resp.Ids[i] = &pbda.ID{Value: ids[i]} + resp.Proofs[i] = &pbda.Proof{Value: proofs[i]} + } + + return resp, nil +} + +func (p *proxySrv) Validate(ctx context.Context, request *pbda.ValidateRequest) (*pbda.ValidateResponse, error) { + ids := idsPB2DA(request.Ids) + proofs := proofsPB2DA(request.Proofs) + //TODO implement me + validity, err := p.target.Validate(ids, proofs) + if err != nil { + return nil, err + } + return &pbda.ValidateResponse{Results: validity}, nil +} diff --git a/proxy/util.go b/proxy/util.go new file mode 100644 index 0000000..6ee79f9 --- /dev/null +++ b/proxy/util.go @@ -0,0 +1,70 @@ +package proxy + +import ( + "github.com/rollkit/go-da" + pbda "github.com/rollkit/go-da/types/pb/da" +) + +func blobsDA2PB(blobs []da.Blob) []*pbda.Blob { + pb := make([]*pbda.Blob, len(blobs)) + for i := range blobs { + pb[i] = &pbda.Blob{Value: blobs[i]} + } + return pb +} + +func blobsPB2DA(pb []*pbda.Blob) []da.Blob { + blobs := make([]da.Blob, len(pb)) + for i := range pb { + blobs[i] = pb[i].Value + } + return blobs +} + +func idsPB2DA(pb []*pbda.ID) []da.ID { + ids := make([]da.ID, len(pb)) + for i := range ids { + ids[i] = pb[i].Value + } + return ids +} + +func idsDA2PB(ids []da.ID) []*pbda.ID { + pb := make([]*pbda.ID, len(ids)) + for i := range ids { + pb[i] = &pbda.ID{Value: ids[i]} + } + return pb +} + +func commitsPB2DA(pb []*pbda.Commitment) []da.Commitment { + commits := make([]da.Commitment, len(pb)) + for i := range pb { + commits[i] = pb[i].Value + } + return commits +} + +func commitsDA2PB(commits []da.Commitment) []*pbda.Commitment { + pb := make([]*pbda.Commitment, len(commits)) + for i := range commits { + pb[i] = &pbda.Commitment{Value: commits[i]} + } + return pb +} + +func proofsPB2DA(pb []*pbda.Proof) []da.Proof { + proofs := make([]da.Proof, len(pb)) + for i := range pb { + proofs[i] = pb[i].Value + } + return proofs +} + +func proofsDA2PB(proofs []da.Proof) []*pbda.Proof { + pb := make([]*pbda.Proof, len(proofs)) + for i := range proofs { + pb[i] = &pbda.Proof{Value: proofs[i]} + } + return pb +} diff --git a/test/test_suite.go b/test/test_suite.go new file mode 100644 index 0000000..9c266b1 --- /dev/null +++ b/test/test_suite.go @@ -0,0 +1,143 @@ +package test + +import ( + "bytes" + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "github.com/rollkit/go-da" +) + +// RunDATestSuite runs all tests against given DA +func RunDATestSuite(t *testing.T, d da.DA) { + t.Run("Basic DA test", func(t *testing.T) { + BasicDATest(t, d) + }) + t.Run("Get IDs and all data", func(t *testing.T) { + GetIDsTest(t, d) + }) + t.Run("Check Errors", func(t *testing.T) { + CheckErrors(t, d) + }) +} + +// TODO(tzdybal): how to get rid of those aliases? + +// Blob is a type alias +type Blob = da.Blob + +// ID is a type alias +type ID = da.ID + +// BasicDATest tests round trip of messages to DA and back. +func BasicDATest(t *testing.T, da da.DA) { + msg1 := []byte("message 1") + msg2 := []byte("message 2") + + id1, proof1, err := da.Submit([]Blob{msg1}) + assert.NoError(t, err) + assert.NotEmpty(t, id1) + assert.NotEmpty(t, proof1) + + id2, proof2, err := da.Submit([]Blob{msg2}) + assert.NoError(t, err) + assert.NotEmpty(t, id2) + assert.NotEmpty(t, proof2) + + id3, proof3, err := da.Submit([]Blob{msg1}) + assert.NoError(t, err) + assert.NotEmpty(t, id3) + assert.NotEmpty(t, proof3) + + assert.NotEqual(t, id1, id2) + assert.NotEqual(t, id1, id3) + + ret, err := da.Get(id1) + assert.NoError(t, err) + assert.Equal(t, []Blob{msg1}, ret) + + commitment1, err := da.Commit([]Blob{msg1}) + assert.NoError(t, err) + assert.NotEmpty(t, commitment1) + + commitment2, err := da.Commit([]Blob{msg2}) + assert.NoError(t, err) + assert.NotEmpty(t, commitment2) + + oks, err := da.Validate(id1, proof1) + assert.NoError(t, err) + assert.NotEmpty(t, oks) + for _, ok := range oks { + assert.True(t, ok) + } + + oks, err = da.Validate(id2, proof2) + assert.NoError(t, err) + assert.NotEmpty(t, oks) + for _, ok := range oks { + assert.True(t, ok) + } + + oks, err = da.Validate(id1, proof2) + assert.NoError(t, err) + assert.NotEmpty(t, oks) + for _, ok := range oks { + assert.False(t, ok) + } + + oks, err = da.Validate(id2, proof1) + assert.NoError(t, err) + assert.NotEmpty(t, oks) + for _, ok := range oks { + assert.False(t, ok) + } +} + +// CheckErrors ensures that errors are handled properly by DA. +func CheckErrors(t *testing.T, da da.DA) { + blob, err := da.Get([]ID{[]byte("invalid")}) + assert.Error(t, err) + assert.Empty(t, blob) +} + +// GetIDsTest tests iteration over DA +func GetIDsTest(t *testing.T, da da.DA) { + msgs := [][]byte{[]byte("msg1"), []byte("msg2"), []byte("msg3")} + + ids, proofs, err := da.Submit(msgs) + assert.NoError(t, err) + assert.Len(t, ids, len(msgs)) + assert.Len(t, proofs, len(msgs)) + + found := false + end := time.Now().Add(1 * time.Second) + + // To Keep It Simple: we assume working with DA used exclusively for this test (mock, devnet, etc) + // As we're the only user, we don't need to handle external data (that could be submitted in real world). + // There is no notion of height, so we need to scan the DA to get test data back. + for i := uint64(1); !found && !time.Now().After(end); i++ { + ret, err := da.GetIDs(i) + if err != nil { + t.Error("failed to get IDs:", err) + } + if len(ret) > 0 { + blobs, err := da.Get(ret) + assert.NoError(t, err) + + // Submit ensures atomicity of batch, so it makes sense to compare actual blobs (bodies) only when lengths + // of slices is the same. + if len(blobs) == len(msgs) { + found = true + for b := 0; b < len(blobs); b++ { + if !bytes.Equal(blobs[b], msgs[b]) { + found = false + } + } + } + } + } + + assert.True(t, found) +} diff --git a/types/pb/da/da.pb.go b/types/pb/da/da.pb.go new file mode 100644 index 0000000..a854dfb --- /dev/null +++ b/types/pb/da/da.pb.go @@ -0,0 +1,3040 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: da/da.proto + +package da + +import ( + context "context" + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// Blob is the data submitted/received from DA interface. +type Blob struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *Blob) Reset() { *m = Blob{} } +func (m *Blob) String() string { return proto.CompactTextString(m) } +func (*Blob) ProtoMessage() {} +func (*Blob) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{0} +} +func (m *Blob) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Blob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Blob.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Blob) XXX_Merge(src proto.Message) { + xxx_messageInfo_Blob.Merge(m, src) +} +func (m *Blob) XXX_Size() int { + return m.Size() +} +func (m *Blob) XXX_DiscardUnknown() { + xxx_messageInfo_Blob.DiscardUnknown(m) +} + +var xxx_messageInfo_Blob proto.InternalMessageInfo + +func (m *Blob) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// ID should contain serialized data required by the implementation to find blob in Data Availability layer. +type ID struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *ID) Reset() { *m = ID{} } +func (m *ID) String() string { return proto.CompactTextString(m) } +func (*ID) ProtoMessage() {} +func (*ID) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{1} +} +func (m *ID) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ID.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ID) XXX_Merge(src proto.Message) { + xxx_messageInfo_ID.Merge(m, src) +} +func (m *ID) XXX_Size() int { + return m.Size() +} +func (m *ID) XXX_DiscardUnknown() { + xxx_messageInfo_ID.DiscardUnknown(m) +} + +var xxx_messageInfo_ID proto.InternalMessageInfo + +func (m *ID) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// Commitment should contain serialized cryptographic commitment to Blob value. +type Commitment struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *Commitment) Reset() { *m = Commitment{} } +func (m *Commitment) String() string { return proto.CompactTextString(m) } +func (*Commitment) ProtoMessage() {} +func (*Commitment) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{2} +} +func (m *Commitment) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Commitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Commitment.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Commitment) XXX_Merge(src proto.Message) { + xxx_messageInfo_Commitment.Merge(m, src) +} +func (m *Commitment) XXX_Size() int { + return m.Size() +} +func (m *Commitment) XXX_DiscardUnknown() { + xxx_messageInfo_Commitment.DiscardUnknown(m) +} + +var xxx_messageInfo_Commitment proto.InternalMessageInfo + +func (m *Commitment) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// Proof should contain serialized proof of inclusion (publication) of Blob in Data Availability layer. +type Proof struct { + Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *Proof) Reset() { *m = Proof{} } +func (m *Proof) String() string { return proto.CompactTextString(m) } +func (*Proof) ProtoMessage() {} +func (*Proof) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{3} +} +func (m *Proof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Proof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Proof.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Proof) XXX_Merge(src proto.Message) { + xxx_messageInfo_Proof.Merge(m, src) +} +func (m *Proof) XXX_Size() int { + return m.Size() +} +func (m *Proof) XXX_DiscardUnknown() { + xxx_messageInfo_Proof.DiscardUnknown(m) +} + +var xxx_messageInfo_Proof proto.InternalMessageInfo + +func (m *Proof) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +// GetRequest is the request type for the Get rpc method. +type GetRequest struct { + Ids []*ID `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"` +} + +func (m *GetRequest) Reset() { *m = GetRequest{} } +func (m *GetRequest) String() string { return proto.CompactTextString(m) } +func (*GetRequest) ProtoMessage() {} +func (*GetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{4} +} +func (m *GetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetRequest.Merge(m, src) +} +func (m *GetRequest) XXX_Size() int { + return m.Size() +} +func (m *GetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetRequest proto.InternalMessageInfo + +func (m *GetRequest) GetIds() []*ID { + if m != nil { + return m.Ids + } + return nil +} + +// GetResponse is the response type for the Get rpc method. +type GetResponse struct { + Blobs []*Blob `protobuf:"bytes,1,rep,name=blobs,proto3" json:"blobs,omitempty"` +} + +func (m *GetResponse) Reset() { *m = GetResponse{} } +func (m *GetResponse) String() string { return proto.CompactTextString(m) } +func (*GetResponse) ProtoMessage() {} +func (*GetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{5} +} +func (m *GetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetResponse.Merge(m, src) +} +func (m *GetResponse) XXX_Size() int { + return m.Size() +} +func (m *GetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetResponse proto.InternalMessageInfo + +func (m *GetResponse) GetBlobs() []*Blob { + if m != nil { + return m.Blobs + } + return nil +} + +// GetIDsRequest is the request type for the GetIDs rpc method. +type GetIDsRequest struct { + Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *GetIDsRequest) Reset() { *m = GetIDsRequest{} } +func (m *GetIDsRequest) String() string { return proto.CompactTextString(m) } +func (*GetIDsRequest) ProtoMessage() {} +func (*GetIDsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{6} +} +func (m *GetIDsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetIDsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetIDsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetIDsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetIDsRequest.Merge(m, src) +} +func (m *GetIDsRequest) XXX_Size() int { + return m.Size() +} +func (m *GetIDsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetIDsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetIDsRequest proto.InternalMessageInfo + +func (m *GetIDsRequest) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +// GetIDsResponse is the response type for the GetIDs rpc method. +type GetIDsResponse struct { + Ids []*ID `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"` +} + +func (m *GetIDsResponse) Reset() { *m = GetIDsResponse{} } +func (m *GetIDsResponse) String() string { return proto.CompactTextString(m) } +func (*GetIDsResponse) ProtoMessage() {} +func (*GetIDsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{7} +} +func (m *GetIDsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetIDsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetIDsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetIDsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetIDsResponse.Merge(m, src) +} +func (m *GetIDsResponse) XXX_Size() int { + return m.Size() +} +func (m *GetIDsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetIDsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetIDsResponse proto.InternalMessageInfo + +func (m *GetIDsResponse) GetIds() []*ID { + if m != nil { + return m.Ids + } + return nil +} + +// CommitRequest is the request type for the Commit rpc method. +type CommitRequest struct { + Blobs []*Blob `protobuf:"bytes,1,rep,name=blobs,proto3" json:"blobs,omitempty"` +} + +func (m *CommitRequest) Reset() { *m = CommitRequest{} } +func (m *CommitRequest) String() string { return proto.CompactTextString(m) } +func (*CommitRequest) ProtoMessage() {} +func (*CommitRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{8} +} +func (m *CommitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *CommitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitRequest.Merge(m, src) +} +func (m *CommitRequest) XXX_Size() int { + return m.Size() +} +func (m *CommitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CommitRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitRequest proto.InternalMessageInfo + +func (m *CommitRequest) GetBlobs() []*Blob { + if m != nil { + return m.Blobs + } + return nil +} + +// CommitResponse is the response type for the Commit rpc method. +type CommitResponse struct { + Commitments []*Commitment `protobuf:"bytes,1,rep,name=commitments,proto3" json:"commitments,omitempty"` +} + +func (m *CommitResponse) Reset() { *m = CommitResponse{} } +func (m *CommitResponse) String() string { return proto.CompactTextString(m) } +func (*CommitResponse) ProtoMessage() {} +func (*CommitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{9} +} +func (m *CommitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *CommitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitResponse.Merge(m, src) +} +func (m *CommitResponse) XXX_Size() int { + return m.Size() +} +func (m *CommitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CommitResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitResponse proto.InternalMessageInfo + +func (m *CommitResponse) GetCommitments() []*Commitment { + if m != nil { + return m.Commitments + } + return nil +} + +// SubmitRequest is the request type for the Submit rpc method. +type SubmitRequest struct { + Blobs []*Blob `protobuf:"bytes,1,rep,name=blobs,proto3" json:"blobs,omitempty"` +} + +func (m *SubmitRequest) Reset() { *m = SubmitRequest{} } +func (m *SubmitRequest) String() string { return proto.CompactTextString(m) } +func (*SubmitRequest) ProtoMessage() {} +func (*SubmitRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{10} +} +func (m *SubmitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SubmitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SubmitRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *SubmitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SubmitRequest.Merge(m, src) +} +func (m *SubmitRequest) XXX_Size() int { + return m.Size() +} +func (m *SubmitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SubmitRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SubmitRequest proto.InternalMessageInfo + +func (m *SubmitRequest) GetBlobs() []*Blob { + if m != nil { + return m.Blobs + } + return nil +} + +// SubmitResponse is the response type for the Submit rpc method. +type SubmitResponse struct { + Ids []*ID `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"` + Proofs []*Proof `protobuf:"bytes,2,rep,name=proofs,proto3" json:"proofs,omitempty"` +} + +func (m *SubmitResponse) Reset() { *m = SubmitResponse{} } +func (m *SubmitResponse) String() string { return proto.CompactTextString(m) } +func (*SubmitResponse) ProtoMessage() {} +func (*SubmitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{11} +} +func (m *SubmitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SubmitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SubmitResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *SubmitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SubmitResponse.Merge(m, src) +} +func (m *SubmitResponse) XXX_Size() int { + return m.Size() +} +func (m *SubmitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SubmitResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SubmitResponse proto.InternalMessageInfo + +func (m *SubmitResponse) GetIds() []*ID { + if m != nil { + return m.Ids + } + return nil +} + +func (m *SubmitResponse) GetProofs() []*Proof { + if m != nil { + return m.Proofs + } + return nil +} + +// ValidateRequest is the request type for the Validate rpc method. +type ValidateRequest struct { + Ids []*ID `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"` + Proofs []*Proof `protobuf:"bytes,2,rep,name=proofs,proto3" json:"proofs,omitempty"` +} + +func (m *ValidateRequest) Reset() { *m = ValidateRequest{} } +func (m *ValidateRequest) String() string { return proto.CompactTextString(m) } +func (*ValidateRequest) ProtoMessage() {} +func (*ValidateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{12} +} +func (m *ValidateRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidateRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ValidateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidateRequest.Merge(m, src) +} +func (m *ValidateRequest) XXX_Size() int { + return m.Size() +} +func (m *ValidateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ValidateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidateRequest proto.InternalMessageInfo + +func (m *ValidateRequest) GetIds() []*ID { + if m != nil { + return m.Ids + } + return nil +} + +func (m *ValidateRequest) GetProofs() []*Proof { + if m != nil { + return m.Proofs + } + return nil +} + +// ValidateResponse is the response type for the Validate rpc method. +type ValidateResponse struct { + Results []bool `protobuf:"varint,1,rep,packed,name=results,proto3" json:"results,omitempty"` +} + +func (m *ValidateResponse) Reset() { *m = ValidateResponse{} } +func (m *ValidateResponse) String() string { return proto.CompactTextString(m) } +func (*ValidateResponse) ProtoMessage() {} +func (*ValidateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_feb508392bc12c0f, []int{13} +} +func (m *ValidateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidateResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ValidateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidateResponse.Merge(m, src) +} +func (m *ValidateResponse) XXX_Size() int { + return m.Size() +} +func (m *ValidateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ValidateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidateResponse proto.InternalMessageInfo + +func (m *ValidateResponse) GetResults() []bool { + if m != nil { + return m.Results + } + return nil +} + +func init() { + proto.RegisterType((*Blob)(nil), "da.Blob") + proto.RegisterType((*ID)(nil), "da.ID") + proto.RegisterType((*Commitment)(nil), "da.Commitment") + proto.RegisterType((*Proof)(nil), "da.Proof") + proto.RegisterType((*GetRequest)(nil), "da.GetRequest") + proto.RegisterType((*GetResponse)(nil), "da.GetResponse") + proto.RegisterType((*GetIDsRequest)(nil), "da.GetIDsRequest") + proto.RegisterType((*GetIDsResponse)(nil), "da.GetIDsResponse") + proto.RegisterType((*CommitRequest)(nil), "da.CommitRequest") + proto.RegisterType((*CommitResponse)(nil), "da.CommitResponse") + proto.RegisterType((*SubmitRequest)(nil), "da.SubmitRequest") + proto.RegisterType((*SubmitResponse)(nil), "da.SubmitResponse") + proto.RegisterType((*ValidateRequest)(nil), "da.ValidateRequest") + proto.RegisterType((*ValidateResponse)(nil), "da.ValidateResponse") +} + +func init() { proto.RegisterFile("da/da.proto", fileDescriptor_feb508392bc12c0f) } + +var fileDescriptor_feb508392bc12c0f = []byte{ + // 423 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xc1, 0x0e, 0xd2, 0x40, + 0x10, 0x6d, 0x0b, 0x54, 0x98, 0x4a, 0xd1, 0x95, 0x98, 0xa6, 0xd1, 0x06, 0xf7, 0xa0, 0xc4, 0x28, + 0x28, 0x1e, 0x3c, 0x8b, 0x4d, 0x08, 0x07, 0x8d, 0x59, 0x12, 0xef, 0x2d, 0x5d, 0xa5, 0x49, 0x61, + 0xb1, 0xdd, 0xf2, 0x0b, 0x5e, 0xfd, 0x2c, 0x8f, 0x1c, 0x3d, 0x1a, 0xf8, 0x11, 0xb3, 0xdd, 0x2e, + 0xa5, 0x26, 0x0d, 0x7a, 0x9c, 0x99, 0xf7, 0xde, 0xce, 0xbc, 0xd7, 0x82, 0x15, 0x05, 0xd3, 0x28, + 0x98, 0xec, 0x53, 0xc6, 0x19, 0x32, 0xa2, 0x00, 0x3f, 0x82, 0xf6, 0x3c, 0x61, 0x21, 0x1a, 0x42, + 0xe7, 0x10, 0x24, 0x39, 0x75, 0xf4, 0x91, 0x3e, 0xbe, 0x4b, 0x64, 0x81, 0x5d, 0x30, 0x96, 0x7e, + 0xc3, 0x0c, 0x03, 0xbc, 0x67, 0xdb, 0x6d, 0xcc, 0xb7, 0x74, 0xc7, 0x1b, 0x30, 0x8f, 0xa1, 0xf3, + 0x29, 0x65, 0xec, 0x4b, 0xc3, 0xf8, 0x29, 0xc0, 0x82, 0x72, 0x42, 0xbf, 0xe5, 0x34, 0xe3, 0xc8, + 0x81, 0x56, 0x1c, 0x65, 0x8e, 0x3e, 0x6a, 0x8d, 0xad, 0x99, 0x39, 0x89, 0x82, 0xc9, 0xd2, 0x27, + 0xa2, 0x85, 0x5f, 0x82, 0x55, 0xe0, 0xb2, 0x3d, 0xdb, 0x65, 0x14, 0x79, 0xd0, 0x09, 0x13, 0x16, + 0x2a, 0x68, 0x57, 0x40, 0xc5, 0x11, 0x44, 0xb6, 0xf1, 0x33, 0xe8, 0x2f, 0x28, 0x5f, 0xfa, 0x99, + 0x52, 0x7e, 0x08, 0xe6, 0x86, 0xc6, 0x5f, 0x37, 0xbc, 0x78, 0xbe, 0x4d, 0xca, 0x0a, 0x3f, 0x07, + 0x5b, 0x01, 0x4b, 0xe9, 0xe6, 0x1d, 0xa6, 0xd0, 0x97, 0xe7, 0x2a, 0xd1, 0x5b, 0x5b, 0xcc, 0xc1, + 0x56, 0x84, 0x52, 0xfc, 0x15, 0x58, 0xeb, 0x8b, 0x63, 0x8a, 0x67, 0x0b, 0x5e, 0x65, 0x24, 0xb9, + 0x86, 0x88, 0x47, 0x57, 0x79, 0xf8, 0x1f, 0x8f, 0x7e, 0x00, 0x5b, 0x11, 0x6e, 0x5d, 0x84, 0x9e, + 0x80, 0xb9, 0x17, 0xe1, 0x64, 0x8e, 0x51, 0x0c, 0x7b, 0x62, 0x58, 0xc4, 0x45, 0xca, 0x01, 0xfe, + 0x08, 0x83, 0xcf, 0x41, 0x12, 0x47, 0x01, 0xa7, 0x37, 0x53, 0xfa, 0x17, 0xbd, 0x17, 0x70, 0xaf, + 0xd2, 0xbb, 0x2c, 0x78, 0x27, 0xa5, 0x59, 0x9e, 0x94, 0x8e, 0x74, 0x89, 0x2a, 0x67, 0xdf, 0x0d, + 0xe8, 0xf9, 0xef, 0x56, 0x34, 0x3d, 0xc4, 0x6b, 0x8a, 0xc6, 0xd0, 0x5a, 0x50, 0x8e, 0x0a, 0xbf, + 0xaa, 0xaf, 0xc6, 0x1d, 0x5c, 0x6a, 0xa9, 0x87, 0x35, 0xf4, 0x1a, 0x4c, 0x19, 0x2b, 0xba, 0x5f, + 0x0e, 0xab, 0x6f, 0xc1, 0x45, 0xd7, 0xad, 0x6b, 0x8a, 0xcc, 0x40, 0x52, 0x6a, 0x49, 0x4b, 0x4a, + 0x3d, 0x4b, 0x49, 0x91, 0x56, 0x4b, 0x4a, 0x2d, 0x27, 0x49, 0xa9, 0x27, 0x81, 0x35, 0xf4, 0x16, + 0xba, 0xea, 0x7c, 0xf4, 0x40, 0x20, 0xfe, 0x32, 0xd7, 0x1d, 0xd6, 0x9b, 0x8a, 0x38, 0x77, 0x7e, + 0x9e, 0x3c, 0xfd, 0x78, 0xf2, 0xf4, 0xdf, 0x27, 0x4f, 0xff, 0x71, 0xf6, 0xb4, 0xe3, 0xd9, 0xd3, + 0x7e, 0x9d, 0x3d, 0x2d, 0x34, 0x8b, 0x5f, 0xf9, 0xcd, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x88, + 0x1d, 0xf1, 0x7e, 0xd9, 0x03, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// DAServiceClient is the client API for DAService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type DAServiceClient interface { + // Get returns Blob for each given ID, or an error. + Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) + // GetIDs returns IDs of all Blobs located in DA at given height. + GetIDs(ctx context.Context, in *GetIDsRequest, opts ...grpc.CallOption) (*GetIDsResponse, error) + // Commit creates a Commitment for each given Blob. + Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error) + // Submit submits the given Blobs to Data Availability layer. + Submit(ctx context.Context, in *SubmitRequest, opts ...grpc.CallOption) (*SubmitResponse, error) + // Validate validates Commitments against corresponding Proofs. This should be possible without retrieving Blob. + Validate(ctx context.Context, in *ValidateRequest, opts ...grpc.CallOption) (*ValidateResponse, error) +} + +type dAServiceClient struct { + cc *grpc.ClientConn +} + +func NewDAServiceClient(cc *grpc.ClientConn) DAServiceClient { + return &dAServiceClient{cc} +} + +func (c *dAServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) { + out := new(GetResponse) + err := c.cc.Invoke(ctx, "/da.DAService/Get", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *dAServiceClient) GetIDs(ctx context.Context, in *GetIDsRequest, opts ...grpc.CallOption) (*GetIDsResponse, error) { + out := new(GetIDsResponse) + err := c.cc.Invoke(ctx, "/da.DAService/GetIDs", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *dAServiceClient) Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error) { + out := new(CommitResponse) + err := c.cc.Invoke(ctx, "/da.DAService/Commit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *dAServiceClient) Submit(ctx context.Context, in *SubmitRequest, opts ...grpc.CallOption) (*SubmitResponse, error) { + out := new(SubmitResponse) + err := c.cc.Invoke(ctx, "/da.DAService/Submit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *dAServiceClient) Validate(ctx context.Context, in *ValidateRequest, opts ...grpc.CallOption) (*ValidateResponse, error) { + out := new(ValidateResponse) + err := c.cc.Invoke(ctx, "/da.DAService/Validate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// DAServiceServer is the server API for DAService service. +type DAServiceServer interface { + // Get returns Blob for each given ID, or an error. + Get(context.Context, *GetRequest) (*GetResponse, error) + // GetIDs returns IDs of all Blobs located in DA at given height. + GetIDs(context.Context, *GetIDsRequest) (*GetIDsResponse, error) + // Commit creates a Commitment for each given Blob. + Commit(context.Context, *CommitRequest) (*CommitResponse, error) + // Submit submits the given Blobs to Data Availability layer. + Submit(context.Context, *SubmitRequest) (*SubmitResponse, error) + // Validate validates Commitments against corresponding Proofs. This should be possible without retrieving Blob. + Validate(context.Context, *ValidateRequest) (*ValidateResponse, error) +} + +// UnimplementedDAServiceServer can be embedded to have forward compatible implementations. +type UnimplementedDAServiceServer struct { +} + +func (*UnimplementedDAServiceServer) Get(ctx context.Context, req *GetRequest) (*GetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") +} +func (*UnimplementedDAServiceServer) GetIDs(ctx context.Context, req *GetIDsRequest) (*GetIDsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetIDs not implemented") +} +func (*UnimplementedDAServiceServer) Commit(ctx context.Context, req *CommitRequest) (*CommitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Commit not implemented") +} +func (*UnimplementedDAServiceServer) Submit(ctx context.Context, req *SubmitRequest) (*SubmitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Submit not implemented") +} +func (*UnimplementedDAServiceServer) Validate(ctx context.Context, req *ValidateRequest) (*ValidateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Validate not implemented") +} + +func RegisterDAServiceServer(s *grpc.Server, srv DAServiceServer) { + s.RegisterService(&_DAService_serviceDesc, srv) +} + +func _DAService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DAServiceServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/da.DAService/Get", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DAServiceServer).Get(ctx, req.(*GetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DAService_GetIDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetIDsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DAServiceServer).GetIDs(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/da.DAService/GetIDs", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DAServiceServer).GetIDs(ctx, req.(*GetIDsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DAService_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CommitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DAServiceServer).Commit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/da.DAService/Commit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DAServiceServer).Commit(ctx, req.(*CommitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DAService_Submit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubmitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DAServiceServer).Submit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/da.DAService/Submit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DAServiceServer).Submit(ctx, req.(*SubmitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DAService_Validate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ValidateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DAServiceServer).Validate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/da.DAService/Validate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DAServiceServer).Validate(ctx, req.(*ValidateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _DAService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "da.DAService", + HandlerType: (*DAServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Get", + Handler: _DAService_Get_Handler, + }, + { + MethodName: "GetIDs", + Handler: _DAService_GetIDs_Handler, + }, + { + MethodName: "Commit", + Handler: _DAService_Commit_Handler, + }, + { + MethodName: "Submit", + Handler: _DAService_Submit_Handler, + }, + { + MethodName: "Validate", + Handler: _DAService_Validate_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "da/da.proto", +} + +func (m *Blob) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Blob) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Blob) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintDa(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ID) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ID) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintDa(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Commitment) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Commitment) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Commitment) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintDa(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Proof) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Proof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Proof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintDa(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ids) > 0 { + for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ids[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *GetResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Blobs) > 0 { + for iNdEx := len(m.Blobs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Blobs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *GetIDsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetIDsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintDa(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GetIDsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetIDsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetIDsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ids) > 0 { + for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ids[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CommitRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CommitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Blobs) > 0 { + for iNdEx := len(m.Blobs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Blobs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *CommitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CommitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Commitments) > 0 { + for iNdEx := len(m.Commitments) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Commitments[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *SubmitRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SubmitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SubmitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Blobs) > 0 { + for iNdEx := len(m.Blobs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Blobs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *SubmitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SubmitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SubmitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Proofs) > 0 { + for iNdEx := len(m.Proofs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Proofs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Ids) > 0 { + for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ids[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ValidateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValidateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Proofs) > 0 { + for iNdEx := len(m.Proofs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Proofs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Ids) > 0 { + for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ids[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDa(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ValidateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ValidateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Results) > 0 { + for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- { + i-- + if m.Results[iNdEx] { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + } + i = encodeVarintDa(dAtA, i, uint64(len(m.Results))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintDa(dAtA []byte, offset int, v uint64) int { + offset -= sovDa(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Blob) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovDa(uint64(l)) + } + return n +} + +func (m *ID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovDa(uint64(l)) + } + return n +} + +func (m *Commitment) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovDa(uint64(l)) + } + return n +} + +func (m *Proof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovDa(uint64(l)) + } + return n +} + +func (m *GetRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Ids) > 0 { + for _, e := range m.Ids { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + return n +} + +func (m *GetResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Blobs) > 0 { + for _, e := range m.Blobs { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + return n +} + +func (m *GetIDsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovDa(uint64(m.Height)) + } + return n +} + +func (m *GetIDsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Ids) > 0 { + for _, e := range m.Ids { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + return n +} + +func (m *CommitRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Blobs) > 0 { + for _, e := range m.Blobs { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + return n +} + +func (m *CommitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Commitments) > 0 { + for _, e := range m.Commitments { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + return n +} + +func (m *SubmitRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Blobs) > 0 { + for _, e := range m.Blobs { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + return n +} + +func (m *SubmitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Ids) > 0 { + for _, e := range m.Ids { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + if len(m.Proofs) > 0 { + for _, e := range m.Proofs { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + return n +} + +func (m *ValidateRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Ids) > 0 { + for _, e := range m.Ids { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + if len(m.Proofs) > 0 { + for _, e := range m.Proofs { + l = e.Size() + n += 1 + l + sovDa(uint64(l)) + } + } + return n +} + +func (m *ValidateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Results) > 0 { + n += 1 + sovDa(uint64(len(m.Results))) + len(m.Results)*1 + } + return n +} + +func sovDa(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozDa(x uint64) (n int) { + return sovDa(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Blob) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: Blob: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Blob: 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 ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDa + } + 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 := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ID) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: ID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ID: 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 ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDa + } + 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 := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Commitment) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: Commitment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Commitment: 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 ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDa + } + 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 := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Proof) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: Proof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Proof: 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 ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDa + } + 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 := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: GetRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ids = append(m.Ids, &ID{}) + if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: GetResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Blobs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Blobs = append(m.Blobs, &Blob{}) + if err := m.Blobs[len(m.Blobs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetIDsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: GetIDsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetIDsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetIDsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: GetIDsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetIDsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ids = append(m.Ids, &ID{}) + if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommitRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: CommitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Blobs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Blobs = append(m.Blobs, &Blob{}) + if err := m.Blobs[len(m.Blobs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CommitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: CommitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commitments", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Commitments = append(m.Commitments, &Commitment{}) + if err := m.Commitments[len(m.Commitments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SubmitRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: SubmitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SubmitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Blobs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Blobs = append(m.Blobs, &Blob{}) + if err := m.Blobs[len(m.Blobs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SubmitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: SubmitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SubmitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ids = append(m.Ids, &ID{}) + if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proofs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proofs = append(m.Proofs, &Proof{}) + if err := m.Proofs[len(m.Proofs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: ValidateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ids = append(m.Ids, &ID{}) + if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proofs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proofs = append(m.Proofs, &Proof{}) + if err := m.Proofs[len(m.Proofs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ValidateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + 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: ValidateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthDa + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthDa + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + elementCount = packedLen + if elementCount != 0 && len(m.Results) == 0 { + m.Results = make([]bool, 0, elementCount) + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDa + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Results = append(m.Results, bool(v != 0)) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipDa(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDa + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipDa(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowDa + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowDa + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowDa + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthDa + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupDa + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthDa + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthDa = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDa = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupDa = fmt.Errorf("proto: unexpected end of group") +)